一文解密Python的弱引用

class A:
    def __init__(self, obj):
        self.obj = obj
    def __del__(self):
        print("当实例对象被回收时, 会触发我的执行······")
# 显然我们创建了一个对象 A(123), 然后让变量 a 指向（引用）它
# 然后 b = a, 让 b 也指向 a 指向的对象
a = A(123)
b = a
# 此时对象的引用计数为 2, 然后我们将 a 删除掉
del a
print("无事发生, 一切正常")
# 如果再 del b, 那么 A(123) 的引用计数就变成了 0, 那么它就该被回收了
# 一旦被回收, 就会触发析构函数 __del__
del b
print("触发完析构函数, 这里会打印")
"""
无事发生, 一切正常
当实例对象被回收时, 会触发我的执行······
触发完析构函数, 这里会打印
"""

class A:
    def __init__(self, obj):
        self.obj = obj
    def __del__(self):
        print("当实例对象被回收时, 会触发我的执行······")
# 创建两个对象, 分别让 a 和 b 引用
a = A(123)
b = A(123)
# 然后, 重点来了
a.obj = b
b.obj = a
# 此时 a 引用的实例对象被 b.obj 引用了
# b 引用的实例对象被 a.obj 引用了
# 这个时候，两个对象的引用计数都为 2
# 然后我们 del a, b，这个时候能把对象删除掉吗? 显然是不能的
# 因为它们的引用计数都变成了 1, 不是 0。只要不为 0, 就不会被回收
del a, b

import gc
class A:
    def __init__(self, obj):
        self.obj = obj
    def __del__(self):
        print("当实例对象被回收时, 会触发我的执行······")
a = A(123)
b = A(123)
a.obj = b
b.obj = a
del a, b
print("析构函数没有被执行, 因为引用计数不为零")
# gc 触发是需要条件的, 但是 Python 支持我们手动引发 gc
# gc 发动之后会找出发生循环引用的对象
# 由于这里的两个对象没有外部的变量引用, 所以它们都是要被回收的
gc.collect()
print("两个对象都被回收了")
"""
析构函数没有被执行, 因为引用计数不为零
当实例对象被回收时, 会触发我的执行······
当实例对象被回收时, 会触发我的执行······
两个对象都被回收了
"""

import weakref
class RefObject:
    def __del__(self):
        print("del executed")
obj = RefObject()
# 对象的弱引用通过 weakref.ref 类来创建
r = weakref.ref(obj)
print(obj) 
"""
<__main__.RefObject object at 0x000001B7C573A5E0>
"""
# 显示关联 RefObject
print(r)
"""
<weakref at 0x000001B7DCAE19A0; to 'RefObject' at 0x000001B7C573A5E0>
"""
# 对引用进行调用的话, 即可得到原对象
print(r() is obj)  
"""
True
"""
# 删除 obj 会执行析构函数
del obj  
"""
del executed
"""
# 之前说过 r() 等价于 obj, 但是obj被删除了, 所以返回 None
# 从这里返回 None 也能看出这个弱引用是不会增加引用计数的
print("r():", r()) 
"""
r(): None
"""
# 打印弱引用, 告诉我们状态已经变成了 dead
print(r)  
"""
<weakref at 0x000001B7DCAE19A0; dead>
"""

import weakref
class RefObject:
    def __del__(self):
        print("del executed")
obj = RefObject()
r = weakref.ref(obj, lambda ref: print("引用被删除了", ref))
del obj  
print("r():", r()) 
"""
del executed
引用被删除了 <weakref at 0x0000021A69681900; dead>
r(): None
"""
# 回调函数会接收一个参数, 也就是死亡之后的弱引用; 

import weakref
class RefObject:
    def __init__(self, name):
        self.name = name
    def __del__(self):
        print("del executed")
obj = RefObject("my obj")
r = weakref.ref(obj)
p = weakref.proxy(obj)
# 可以看到引用加上()才相当于原来的对象
# 而代理不需要，直接和原来的对象保持一致
print(obj.name)  # my obj
print(r().name)  # my obj
print(p.name)  # my obj
# 但是注意: 弱引用在调用之后就是原对象, 而代理不是
print(r() is obj)  # True
print(p is obj)  # False
del obj  # del executed
try:
    # 删除对象之后, 再调用引用, 打印为None
    print(r())  # None
    # 如果是使用代理, 则会报错
    print(p)
except Exception as e:
    print(e)  # weakly-referenced object no longer exists

class A:
    def __del__(self):
        print("__del__")
a = A()
# 创建一个普通字典
d = {}
# 由于 a 作为了字典的 key, 那么 a 指向的对象引用计数会加 1, 变成 2
d[a] = "xxx"
# 删除 a, 对对象无影响, 不会触发析构函数
del a
print(d)
"""
{<__main__.A object at 0x000002092669A5E0>: 'xxx'}
__del__
"""
# 最后打印的 __del__ 是程序结束时, 将对象回收时打印的

import weakref
class A:
    def __del__(self):
        print("__del__")
a = A()
# 创建一个弱引用字典, 它的 api 和普通字典一样
d = weakref.WeakKeyDictionary()
print("d:", d)  
"""
d: <WeakKeyDictionary at 0x7f8a581a0d30>
"""
# 此时 a 指向的对象的引用计数不会增加
d[a] = "xxx"
print("before del a:", list(d.items()))
"""
before del a: [(<__main__.A object at 0x7f8a581a0d60>, 'xxx')]
"""
# 删除 a, 对象会被回收
del a
"""
__del__
"""
print("after del a:", list(d.items()))
"""
after del a: []
"""

import weakref
class A:
    def __del__(self):
        print("__del__")
a = A()
d = weakref.WeakValueDictionary()
# value 为弱引用
d["xxx"] = a
print("before del a:", list(d.items()))
"""
before del a: [('xxx', <__main__.A object at 0x7f89580a7d60>)]
"""
# 删除 a, 对象会被回收
del a
"""
__del__
"""
print("after del a:", list(d.items()))
"""
after del a: []
"""

import weakref
class A:
    def __del__(self):
        print("__del__")
a = A()
s = weakref.WeakSet()
s.add(a)
print(len(s))
del a
print(len(s))
"""
1
__del__
0
"""

import weakref
class A:
    __slots__ = ("name", "age")
    def __init__(self):
        self.name = "古明地觉"
        self.age = 17
a = A()
try:
    weakref.ref(a)
except Exception as e:
    print(e)  # cannot create weak reference to 'A' object
try:
    weakref.proxy(a)
except Exception as e:
    print(e)  # cannot create weak reference to 'A' object
try:
    d = weakref.WeakSet()
    d.add(a)
except Exception as e:
    print(e)  # cannot create weak reference to 'A' object

import weakref
class A:
    # 多指定一个__weakref__, 表示支持弱引用
    __slots__ = ("name", "age", "__weakref__")
    def __init__(self):
        self.name = "古明地觉"
        self.age = 17
a = A()
weakref.ref(a)
weakref.proxy(a)
d = weakref.WeakSet()
d.add(a)