目录

类方法 静态方法 实例方法

类方法

静态方法

类属性（变量）类方法（函数）

类变量

实例变量

局部变量 

什么是类属性，类方法，什么时候实例属性实例方法，静态方法

什么时候写“实例方法”（def func(self, ...)）

什么时候写“类方法”（@classmethod）

什么时候写“静态方法”（@staticmethod）

什么时候写“类属性”

什么时候在 __init__ 里放“实例属性”

什么时候在“实例方法里动态新增实例属性”

继承和多态

好处

通过“实例”访问属性的完整流程

数据描述器

通过“类”访问属性

 MRO （方法解析顺序）

属性查找

访问限制

双下划线

类中函数的顺序

 类外函数的顺序

类方法 静态方法 实例方法

 自定义类 - 白月黑羽

类方法-->使用@classmethod修饰的方法，使用类名直接访问的方法
静态方法-->使用@staticmethod修饰的方法，使用类名直接访问的方法，类的所有实例共有的方法,所有的实例这个方法都是一样的。静态方法是不能访问实例属性的。
通常类的实例方法，都是要 访问类的实例属性的。 包括： 创建、修改、删除 类的实例属性。

因为 实例方法 就是要操作 实例独有的属性，否则不操作任何实例属性的话，就应该定义为 类方法。

类方法

类方法

• 定义：@classmethod，第一个参数是 cls

• 调用：类名.方法() ✅，实例.方法() ✅

• Python 会自动把“调用它的那个类”传给 cls。 cls 永远是“调用它的那个类”

静态方法

• 定义：@staticmethod，参数全自己写

• 调用：类名.方法() ✅，实例.方法() ✅

• Python 不会自动传 self 或 cls，就跟普通函数一样

类属性（变量）类方法（函数）

类中定义的变量又称之为属性，类中定义的函数又称之为方法。

1. 类中、所有函数（方法）之外：此范围定义的变量，称为类属性或类变量；被该类所有对象共享, 是类的所有实例共有的属性
2. 类中，所有函数（方法）内部：以“self.变量名”的方式定义的变量，称为实例属性或实例变量；每个实例独有的属性，称之为类的实例属性。实例属性通常是在类的 初始化方法 __init__ 里面定义的。__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法.self 代表类的实例，self 在定义类的方法时是必须有的，在调用时不必传入相应的参数，解释器会自动传相应的参数.
3. 
4. 类中，所有函数（方法）内部：以“变量名=变量值”的方式定义的变量，称为局部变量。

类变量

类变量（类属性）：

类变量指的是在

类中，但在各个类方法外定义的变量。被该类所有对象共享, 是类的所有实例共有的属性。

举个例子：

class Person :
    # 下面定义了2个类变量
    name = "love is love"
    add = "yes"
    # 下面定义了一个say实例方法
    def say(self, content):
        print(content)
'''
此程序中，name和add就属于类变量
'''

 类变量的特点是，所有类的实例化对象都同时共享类变量，也就是说，类变量在所有实例化对象中是作为公用资源存在的。类变量的调用方式有 2 种，既可以使用类名直接调用，也可以使用类的实例化对象调用（这个方法不推荐）。

使用类名 .属性进行调用。同时还可以看到，

通过类名不仅可以调用类变量，也可以修改它的值。

class Person :
    # 下面定义了2个类变量
    name = "love is love"
    add = "yes"
    # 下面定义了一个say实例方法
    def say(self, content):
        print(content)
#使用类名直接调用
print(Person.name)
print(Person.add)
#修改类变量的值
Person.name = "sad"
Person.add = "no"
print(Person.name)
print(Person.add)
'''
love is love
yes
sad
no
'''

当然，也可以使用类实例对象来调用所属类中的类变量（此方式不推荐使用，因为通过类实例对象修改类变量的值，不是在给“类变量赋值”，而是定义新的实例变量，后边实例变量会看到例子） 

注意，通过类实例对象是无法修改类变量的。通过类实例对象对类变量赋值，其本质将不再是修改类变量的值，而是在给该实例对象定义新的实例变量（在讲实例变量时会进行详细介绍）。

type(self).x

class Animal:
    kind = "animal"

    def who_am_i(self):
        print("I am", Animal.kind)


class Dog(Animal):
    kind = "dog"


class Cat(Animal):
    kind = "cat"
Dog().who_am_i()  # I am animal
Cat().who_am_i()  # I am animal

cls 的值取决于“你是通过哪个类来调用这个类方法”的

class Person :
    # 下面定义了2个类变量
    name = "love is love"
    add = "yes"
    # 下面定义了一个say实例方法
    def say(self, content):
        print(content)
a=Person()
print(a.name)
print(a.add)
'''
love is love
yes
'''

 注意，因为类变量为所有实例化对象共有，通过类名修改类变量的值，会影响所有的实例化对象。例如

class Person :
    # 下面定义了2个类变量
    name = "love is love"
    add = "yes"
    # 下面定义了一个say实例方法
    def say(self, content):
        print(content)
a=Person()
b=Person()
print('修改前，类实例对象中类变量的值')
print(a.name)
print(a.add)
print(b.name)
print(b.add)
print('修改后，类实例对象中类变量的值')
Person.name='sad'
Person.add='no'
print(a.name)
print(a.add)
print(b.name)
print(b.add)
'''
修改前，类实例对象中类变量的值
love is love
yes
love is love
yes
修改后，类实例对象中类变量的值
sad
no
sad
no
'''

显然，通过类名修改类变量，会作用到所有的实例化对象

实例变量

 实例变量（实例属性）

实例变量指的是在任意类方法内部，以“self.变量名”的方式定义的变量，其特点是只作用于调用方法的对象。另外，实例变量只能通过对象名访问，无法通过类名访问。

class Person :
    def __init__(self):
        self.name = "love is love"
        self.add = "yes"
    def say(self, content):
        self.eir='two'

此 Person类中，name、add 以及 eir 都是实例变量。其中，由于 __init__() 函数在创建类对象时会自动调用，而 say() 方法需要类实例对象手动调用。因此，Person类的实例对象都会包含 name 和 add 实例变量，而只有调用了 say() 方法的实例对象，才包含 eir 实例变量。 

class Person :
    def __init__(self):
        self.name = "love is love"
        self.add = "yes"
    def say(self):
        self.eir='two'
a = Person()
print(a.name)
print(a.add)
#由于 a 对象未调用 say() 方法，因此其没有 eir 变量，下面这行代码会报错
#print(a.eir)
b = Person()
print(b.name)
print(b.add)
#只有调用 say()，才会拥有 catalog 实例变量
b.say()
print(b.eir)
'''
love is love
yes
love is love
yes
two
'''

前面讲过，通过类实例对象可以访问类变量，但无法修改类变量的值。这是因为，通过类实例对象修改类变量的值，不是在给“类变量赋值”，而是定义新的实例变量。例如，

class Person :
    name = "love is love"
    add = "yes"
    def say(self):
        self.eir='two'
a = Person()
#访问类变量
print(a.name)
print(a.add)
a.name='sad'
a.add='no'
#a实例变量的值
print(a.name)
print(a.add)
#类变量的值
print(Person.name)
print(Person.add)
'''
love is love
yes
sad
no
love is love
yes
'''

显然，通过类实例对象是无法修改类变量的值的，本质其实是给 a对象新添加 name 和 add 这 2 个实例变量。 

类中，实例变量和类变量可以同名，但这种情况下使用类实例对象将无法调用类变量，它会首选实例变量，这也是不推荐“类变量使用实例对象调用”的原因。 

和类变量不同，通过某个实例对象修改实例变量的值，不会影响类的其它实例化对象，更不会影响同名的类变量。例如：

class Person :
    name = "xxx"
    add = "http"
    def __init__(self):
        self.name='love is love'
        self.add='yes'
    def say(self):
        self.eir='two'
a = Person()
#修改a的实例变量
print(a.name)
print(a.add)
a.name='sad'
a.add='no'
#a实例变量的值
print(a.name)
print(a.add)
b=Person()
print(b.name)
print(b.add)
#类变量的值
print(Person.name)
print(Person.add)
'''
love is love
yes
sad
no
love is love
yes
xxx
http
'''

局部变量 

局部变量

除了实例变量，类方法中还可以定义局部变量。和前者不同，局部变量直接以“变量名=值”的方式进行定义，例如： 

class Price :
    def count(self,money):
        sale = 0.8*money
        print("优惠后的价格为：",sale)
a=Price()
a.count(100)
'''
优惠后的价格为： 80.0
'''

 通常情况下，定义局部变量是为了所在类方法功能的实现。需要注意的一点是，局部变量只能用于所在函数中，函数执行完成后，局部变量也会被销毁。

举几个例子，看能否掌握

class Mc():
    def one(self):
        self.name='xyq'
class Mcc():
    def two(self):
        name='angle'
a=Mc()
a.one()
print(a.name)
b=Mcc()
print(b.name)
'''
AttributeError: 'Mcc' object has no attribute 'name'
'''

方法的局部变量，不能被调用，只能在该方法内部使用！

加了self作用域是当前实例，相当于self.xxx是全局的，在该类哪里都可调用

xxx是局部的，只能在该方法内部使用

在给个例子 

class Student:
    company="SXT"
    count=0
    def __init__(self,name,score):
        self.name=name
        self.score=score
        Student.count=Student.count+1
    def say_score(self):
        print("我的公司是：", Student.company)
        print(self.name, '的分数是：', self.score)
a=Student('xm','96')
a.say_score()
print(Student.count)

花了我好长时间，希望对大家有帮助

什么是类属性，类方法，什么时候实例属性实例方法，静态方法

什么时候写“实例方法”（def func(self, ...)）

只要方法里需要用到 self（访问/修改实例属性），就应该是实例方法。

什么时候写“类方法”（@classmethod）

操作“类本身”的东西，或者需要知道“当前到底是哪个子类”时

对所有实例生效，所以用类方法 + 类属性

什么时候写“静态方法”（@staticmethod）

逻辑上属于这个类，但不需要 self 也不需要 cls。

其实它就是“普通函数，但放在类的命名空间里

什么时候写“类属性”

所有实例共享的状态 / 常量 / 配置 / 计数器。

什么时候在 __init__ 里放“实例属性”

几乎所有“属于这个对象本身的数据”，都应该在 __init__ 里定义清楚

什么时候在“实例方法里动态新增实例属性”

合理场景 1：属性只在某个状态之后才有意义

继承和多态

好处

1、子类会自动拥有父类的一切属性和方法

2、一个子类在继承父类的一切特性的基础上，可以有自己的属性和方法。 

3、如果子类 没有 自己的初始化方法，实例化子类对象时，解释器会自动调用父类初始化方法

子类的初始化方法里面，如果有一部分的初始化代码和父类的初始化相同（通常都是这样），需要显式的 调用父类的初始化方法 __init__

4、当函数的参数是父类是，不仅可以传入父类对象，子类对象也可以传入

所有的类属性，实例属性、实例方法、类方法、静态方法，最后都只是“属性”

方法本身也只是普通属性，只是它们的值是特殊类型的对象（描述器）
✔️ Python 访问这些“属性”时，都用同一套规则：
    先做属性查找，然后在类的 MRO 顺序里往上找

通过“实例”访问属性的完整流程

数据描述器

描述器（descriptor）：
只要一个对象实现了 __get__ / __set__ / __delete__ 里任意一个，它就是“描述器”。

数据描述器（data descriptor）：
实现了 __get__ 并且 实现了 __set__ 或 __delete__ 的描述器。

@property 就是一个典型的数据描述器。

描述器对象（包括 @property）都在 cls __dict__ 里

为啥要区分“数据描述器”和“非数据描述器”？

# 1. 先找类链上的“数据描述器”（data descriptor）

# 2. 如果没有数据描述器，再看实例自己的字典

# 3. 再看类链上的“普通属性 / 非数据描述器”

cls.__dict__ 不包含继承来的父类的属性（那些在父类各自的 __dict__ 里，通过 MRO 查）

实例的 __dict__ 里只包含“当前这个实例被各级方法（父类/子类）通过 self.xxx = ... 实际写入过的属性”。【实例.__dict__ 只包含“这个实例自己被赋值过的属性”。没有真正意义上的“继承来的实例属性”。但父类的方法里给 self.xxx 赋值时，确实会把属性写进子类实例的 __dict__】

通过“类”访问属性

 MRO （方法解析顺序）

类属性 / 各种方法：由 MRO 决定在哪个类找到

MRO = Method Resolution Order = 方法解析顺序

当你访问 obj.attr 或调用 obj.method() 时，Python 会按照一条“搜索链”去父类里找，这条搜索顺序就是 MRO

翻成大白话就是：

“当我在这个类以及它的所有父类里找东西时，要按什么顺序去找？”

这个顺序，Python 是帮你算好了的，保存在 类.__mro__ 里

python是按照 C3 线性化算法算出来的顺序。

关于多重继承的资料补充

建议只看第一点拓扑排序和第三点多重继承。也就是按照从左到右的顺序一个一个找

属性查找

简单说，就是：Python 按照一定顺序去“翻盒子找 x”。

A.init 里写的 self.xxx，只要是 SubA 的实例在调用，它就会把属性写进 SubA 的实例对象里

class A:
    def __init__(self):
        self.parent_var = "from A"

    def show(self):
        print("self is:", self)
        print("parent_var =", self.parent_var)


class SubA(A):
    pass


a = SubA()
print("a.__dict__ =", a.__dict__)
a.show()

访问限制

双下划线

双下划线会先“改名”，然后再按属性查找和MRO的规则查

class A:
    def __init__(self):
        self.__val = 42      # 真正保存为 self._A__val

    def show(self):
        print("A.show:", self.__val)   # 这里的 __val 也会变成 _A__val


class B(A):
    def test(self):
        # 这里写 self.__val，其实会被编译成 self._B__val
        print("B.test, self.__val =", self.__val)
b = B()
print(b.__dict__) # {'_A__val': 42}
b.show()     # ✅ 正常打印：A.show: 42
b.test()     # ❌ AttributeError: 'B' object has no attribute '_B__val'

class A:
    def __init__(self):
        self.__val = 42          # -> self._A__val

    def __private(self):         # -> 名字变成 _A__private
        print("A.__private:", self.__val)

    def call_private(self):
        self.__private()         # 在 A 内部，用 __private 没问题
class B(A):
    def test(self):
        # 这里写 self.__private，会被改成 self._B__private
        self.__private()         # ❌ AttributeError: 'B' has no attribute '_B__private'

类中函数的顺序

 

 类外函数的顺序