python类实例作为另一个类属性_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 = []

并不可怕, 我们也可以适当地利用它, 在多个实例之间 “共享” 一些数据的变化.