Python weakref (弱引用 ) 教程

my_list = [1,2,3,4]
my_list = [3,4,5,6]

# 代码示例1
>>> import weakref
>>> s1 = {1,2,3}    # 给对象{1,2,3}贴了一个标签s1
>>> def bye():      # 对象{1,2,3}被销毁时，调用这个函数
...     print("拜拜，你被销毁了")
...
>>> ender = weakref.finalize(s1,bye)      # 绑定回调函数
>>> ender.alive                           # 看对象{1,2,3}仍然存活
True
>>> s1 = {4,5,6}                          # 当标签s1从{1,2,3}上撕下来，对象{1,2,3}被销毁了
拜拜，你被销毁了
>>> ender.alive
False

# 代码示例2
# 使用 weakref.finalize 注册一个在销毁对象时调用的回调函数。
In [166]: import weakref
 
In [167]: s1 = {1,2,3}
 
In [168]: s2 =  s1  # 指向同一个集合.
 
In [169]: def bye():  # 回调函数一定不能是要销毁的对象的绑定方法（类方法），否则会有一个指向对象的引用。
     ...:     print("拜拜，你被销毁了")
     ...:
 
In [170]: ender = weakref.finalize(s1,bye)  # 注册回调， 并返回一个变量，判断是否销毁。
 
In [171]: ender.alive
Out[171]: True
 
In [172]: del s1
 
In [173]: ender.alive # 说明 del s1 是删除引用，而不是对象。
Out[173]: True
 
In [174]: s2 = 'spam'  # 重新绑定 s2 后，表示 {1,2,3} 无法获取 （引用计数为0），此时调用 bye 回调函数.
拜拜，你被销毁了
 
In [175]: ender.alive  # ender 为 弱引用， 不在 计数 范围内.
Out[175]: False

# 前提： Python 控制台会自动把 _ 变量绑定到结果不为 None 的表达式结果上。
In [1]: import weakref
 
In [2]: a_set = {0,1}
 
In [3]: wref = weakref.ref(a_set)  # 弱引用对象 wref
 
In [4]: wref
Out[4]: <weakref at 0x10f29aea8; to 'set' at 0x10e906f28>
 
In [5]: wref()  # 返回的是被引用的对象，{0, 1}。因为是控制台会话，所以 {0, 1} 会绑定给 _ 变量。
Out[5]: {0, 1}
 
In [6]: a_set = {2, 3, 4}   # a_set 不再指代 {0, 1} 集合，因此集合的引用数量减少了。但是 _ 变量仍然指代它。
 
In [7]: wref()
Out[7]: {0, 1}
 
In [8]: wref() is None  # 计算这个表达式时，{0, 1} 存在，因此 wref() 不是 None。但是，随后 _ 绑定到结果值 False。现在 {0, 1} 没有强引用了。
Out[8]: False
 
In [9]: wref() is None  # 因为 {0, 1} 对象不存在了，所以 wref() 返回 None。
Out[9]: Ture  

class Cheese:
 
    def __init__(self, kind):
        self.kind = kind
 
    def __repr__(self):
        return 'Cheese(%r)' % self.kind

# 执行：
In [2]: import weakref
 
In [3]: stock = weakref.WeakValueDictionary()  # 创建弱引用字典实例。
 
In [4]: catalog = [Cheese('Read Leicester'), Cheese('Tilsit'),Cheese('Brie'), Cheese('Parmesan')]
 
In [6]: for cheese in catalog:
   ...:     stock[cheese.kind] = cheese  # 名称映射到实例. [弱引用]
   ...:
 
In [7]: sorted(stock.keys())
Out[7]: ['Brie', 'Parmesan', 'Read Leicester', 'Tilsit']
 
In [8]: del catalog
 
In [9]: sorted(stock.keys())  # 为什么还剩一个？ 因为临时变量。
Out[9]: ['Parmesan']
 
In [10]: del cheese
 
In [11]: sorted(stock.keys())  # 临时变量删除后，为空.
Out[11]: []

>>> import weakref
>>>
>>> class C:                            # 这里新建一个类，因为WeakValueDictionary()
...     def __init__(self, value):      # 要求value是一个obj
...             self.value = value
...
>>> def test_weak_value_dict():
...     d= weakref.WeakValueDictionary()
...     k1 = 'test1'                    
...     v1 = C(1)                       # 这时候C(1)是有一个强引用的：v1
...     d[k1] = v1                      # 这个语句也就是字典赋值，但是由于我们用的
...     print(d[k1])                    # WeakValueDictionary()，所以字典里的是弱引用
...     del v1                          # 这时候删除了C(1)唯一的强引用 v1，因此
...     print(d[k1])                    # WeakValueDictionary()里面 k1,v1 这个键值对消失了
...
>>> test_weak_value_dict()
<__main__.C object at 0x000001793E545198>
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 8, in test_weak_value_dict
  File "C:\Users\ASUS\Anaconda3\lib\weakref.py", line 137, in __getitem__
    o = self.data[key]()
KeyError: 'test1'
>>>

>>> import weakref
>>>
>>> class C:
...     def __init__(self, value):
...             self.value = value
...
>>> def test_weak_value_dict():
...     d= dict()
...     k1 = 'test1'
...     v1 = C(1)
...     d[k1] = v1
...     print(d[k1])
...     del v1
...     print(d[k1])
...
>>> test_weak_value_dict()
<__main__.C object at 0x000001793E545390>
<__main__.C object at 0x000001793E545390>

>>> import weakref
>>>
>>> class C:
...     def __init__(self, value):
...             self.value = value
...
>>> def test_weak_value_dict():
...     d= weakref.WeakValueDictionary()
...     k1 = 'test1'
...     d[k1] = C(1)
...     print(d[k1])
...
>>> test_weak_value_dict()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 5, in test_weak_value_dict
  File "C:\Users\ASUS\Anaconda3\lib\weakref.py", line 137, in __getitem__
    o = self.data[key]()
KeyError: 'test1'

>>>
>>> import weakref
>>> class C:
...     def __init__(self, value):
...             self.value = value
>>> c_obj = C(1)
>>> ref = weakref.ref(c_obj)
>>> ref()
<__main__.C object at 0x000001793E5454A8>
>>> ref().value
1
>>>
>>> proxy = weakref.proxy(c_obj)
>>> proxy
<weakproxy at 0x000001793DF55CC8 to C at 0x000001793E5454A8>
>>> proxy.value
1