Python 类属性, 实例属性, 类的单例化行为解惑

先看一个例子:

class AAA:
    m = 10
    
    def __init__(self):
        self.n = 20


print('[1]', AAA.__dict__)

print('[2]', AAA().__dict__)

a1 = AAA()
print('[3]', a1.__dict__)

a2 = AAA()
a2.m += 2
print('[4]', a2.__dict__)

打印结果:

[1] {'m': 10, '__module__': '__main__', '__doc__': None, ...} (有 'm', 但没有 'n')
[2] {'n': 20}
[3] {'n': 20}
[4] {'n': 20, 'm': 12}

怎么回事?

class AAA:
    m = 10
    #   m 写在类定义下, m 是 '类属性'
    
    def __init__(self):
        self.n = 20
        #   self 代表着实例, 所以 self.n 是 '实例属性'


'''
类属性和实例属性不同. 所以 AAA.__dict__ 与 AAA().__dict__ 的结果不同.
(注: `AAA` 是类, `AAA()` 是实例化的类, 简称 '实例' 或 '类实例'.
 `__dict__` 是类或类实例的属性字典.)
'''

'''
但为什么实例可以访问 m, 而且对 m 做了一些操作以后, 就导致实例中出现了 m?
这跟 __getattr__, __setattr__ 有关.
当我们使用 `a2.m += 2` 时, 经历了以下过程:

   a2.m += 2
-> a2.m = a2.m + 2
   ^--^   ^--^
    B      A
    A: a2.m 在等式右边, 是一个 '取值' 行为, 意思是取 a2 的 m 属性.
       当发生取值行为时, 会触发 a2 的 __getattr__ 魔术方法.
       在 __getattr__ 中, 会先看 m 在不在实例的 __dict__ 内; 如果不在, 再看在不在类的 
       __dict__ 内.
       因为 m 在类的 __dict__ 内, 所以得到了它的值: 10
-> a2.m = 10 + 2
   ^--^   ^^
    B     A
    B: a2.m 在等式左边, 是一个 '赋值' 行为, 意思是将等值右边的值赋给 a2.m 属性.
       当发生赋值行为时, 会触发 a2 的 __setattr__ 魔术方法.
       在 __setattr__ 中, 会先看 m 在不在实例的 __dict__ 内; 如果不在, 则作为键加进去.
       于是 m 就被加到了实例的 __dict__ 内, 因此实例就用了 m 属性.
       
至此, 该操作完成. 接下来我们打印 a2.__dict__, 自然就看到了刚才截图中的结果.
'''

如果上面的解释能够看懂, 再看下面的示例, 就能有新的理解:

class AAA:
    m = []
    
    def __init__(self):
        self.n = 10
        self.o = []


a = AAA()
a.m.append(1)
a.n += 10
a.o.append(-1)

b = AAA()
b.m.append(2)
b.n = 50
b.o.append(-2)

print(a.m, a.n, a.o)
print(b.m, b.n, b.o)

打印结果:

[1, 2] 20 [-1]
[1, 2] 50 [-2]

总结

区分清 “类属性” 和 “实例属性” 的概念: 直接定义在类下面的是类属性, 定义在 __init__ 中的 self.xxx 是实例属性.

当类属性是可变类型的对象时, 你才会看到它的多个实例化对象的类属性之间在相互 “干扰” (因为可变类型本质是一个引用, 你修改了这个引用, 别的实例也在持有这个引用, 也就看到引用的内容变了). 而相比之下, 实例属性则是每个实例各自持有的, 不会产生干扰.

最后再补充一句, 平时我们所认为的:

如果在类定义下面直接写 xx 变量等于可变类型的对象 (比如字典, 列表), 就导致这个类变成 “单例” 了!

所以为了不变成单例, 一定要在 __init__ 方法下赋值…

这种认知与事实是有偏差的.

理解上面示例中的打印结果及其原因, 才能了解到类属性真实的一面. 其实在类定义下面直接写 xx = [] 并不可怕, 我们也可以适当地利用它, 在多个实例之间 “共享” 一些数据的变化.