Python类的静态方法和类方法和__的意义

实例方法只能被实例对象调用,第一个参数必须要默认传实例对象，一般习惯用self。

类方法(由@classmethod装饰的方法)，可以被类或类的实例对象调用。第一个参数必须要默认传类，一般习惯用cls。

子类的实例继承了父类的class_method类方法，调用该方法，调用的是子类的方法和子类的类属性（如果子类有的话，否则还是调父类的函数，但是属性一定是子类的）

静态方法(由@staticmethod装饰的方法)、可以被类或类的实例对象调用，参数没有要求。

子类的实例继承了父类的static_method静态方法，调用该方法，还是调用的父类的方法和类属性。如果子类有一样的静态方法，子类覆盖了父类的静态方法。

静态方法最强！！！

挺好理解的:子类调父类的class_method函数，但此时类函数的类变成子类的类了，所以调的是

子类的方法和子类的类属性。

class Foo(object):
    X = 1
    Y = 2

    @staticmethod
    def averag(*mixes):
        return sum(mixes) / len(mixes)

    @staticmethod
    Def static_method():
        return Foo.averag(Foo.X, Foo.Y)

    @classmethod
    Def class_method(CLS):
        return cls.averag(cls. X, cls. Y)


class Son(Foo):
    X = 3
    Y = 5

    @staticmethod
    def averag(*mixes):
        return sum(mixes) / 3

p = Son()
print(p.static_method())
print(p.class_method())
# 1.5#调的父类的函数和属性
# 2.6666666666666665#调的子类的函数和属性

类方法用在定义多个构造函数的情况

class Book(object):

    def __init__(self, title1):
        self.title2 = title1

    @classmethod
    def create(cls, title4):
        book = cls(title1=title4)
        return book

book1 = Book("python")
book2 = Book.create("python and django")

类中静态方法和类方法调用静态方法

class Foo(object):
    X = 1
    Y = 2

    @staticmethod
    def averag(*mixes):
        return sum(mixes) / len(mixes)

    @staticmethod
    def static_method():
        return Foo.averag(Foo.X, Foo.Y)

    @classmethod
    def class_method(cls):
        return cls.averag(cls.X, cls.Y)

foo = Foo()
print(foo.static_method())
print(foo.class_method())

类方法调用好处：防止类名修改了，不用在类定义中修改原来的类名。

class MyClass:
    def __init__(self):
        self._var = 10

    def _internal_method(self):
        pass

在上述示例中，_var 和 _internal_method 被认为是类的内部实现细节，外部的代码应该避免访问或调用它们。

在Python中，__（双下划线）是一种约定俗成的命名规范，用于标识特殊的方法或属性。以避免与用户定义的方法或属性发生冲突，并提供一种一致的方式来定义类似的功能。

这些特殊方法具有特殊的行为，它们在特定的情况下会被自动调用。例如，__init__方法在创建类的实例时自动调用，__str__方法在将对象转换为字符串时自动调用，__add__方法在对象之间执行加法操作时自动调用。

除了特殊方法，双下划线也用于其他约定俗成的命名约定，例如：

• __name__：表示一个特殊的变量，包含当前模块的名称。
• __doc__：表示一个特殊变量，包含类或函数的文档字符串。

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __add__(self, other):
        if isinstance(other, Vector):
            return Vector(self.x + other.x, self.y + other.y)
        else:
            raise TypeError("Unsupported operand type")

    def __str__(self):
        return f"Vector({self.x}, {self.y})"

vector1 = Vector(2, 3)
vector2 = Vector(4, 5)
result = vector1 + vector2
print(result)  # 输出：Vector(6, 8)
print(Vector.__doc__)

# main.py

import utils

print("Inside main.py")
print(f"main's __name__ value: {__name__}")


# utils.py

print("Inside utils.py")
print(f"utils's __name__ value: {__name__}")

当我们直接运行 main.py 作为主程序时，输出如下：
"""Inside utils.py
utils's __name__ value: utils
Inside main.py
main's __name__ value: __main__