先看一个例子:
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 = []
并不可怕, 我们也可以适当地利用它, 在多个实例之间 “共享” 一些数据的变化.