第8章 对象引用、可变性和垃圾回收

#《流畅的Python》读书笔记
# 第四部分 面向对象惯用法
# 第8章 对象引用、可变性和垃圾回收

# 8.1　变量不是盒子
# Python 变量类似于 Java 中的引用式变量，因此最好把它们理解为附加在对象上的标注。

# 示例 8-1　变量 a 和 b 引用同一个列表，而不是那个列表的副本
# 对引用式变量来说，说把变量分配给对象更合理，反过来说就有问题。
# >>> a=[1,2,3]
# >>> b=a
# >>> b.append(4)
# >>> a
# [1, 2, 3, 4]

# 示例 8-2　创建对象之后才会把变量分配给对象
# 为了理解 Python 中的赋值语句，应该始终先读右边。
#     对象在右边创建或获取，在此之后左边的变量才会绑定到对象上，这就像为对象贴上标注。
# 因为变量只不过是标注，所以无法阻止为对象贴上多个标注。贴的多个标注，就是别名。
# >>> x=Gizmo()
# ❶ 输出的 Gizmo id: ... 是创建 Gizmo 实例的副作用。
# Gizmo id: 34079216
# ❷ 在乘法运算中使用 Gizmo 实例会抛出异常。
# >>> y=Gizmo() * 10
# ❸ 这里表明，在尝试求积之前其实会创建一个新的 Gizmo 实例。
# Gizmo id: 35171312
# ❹ 但是，肯定不会创建变量 y，因为在对赋值语句的右边进行求值时抛出了异常。
# Traceback (most recent call last):
#   File "<pyshell#9>", line 1, in <module>
#     y=Gizmo() * 10
# TypeError: unsupported operand type(s) for *: 'Gizmo' and 'int'
# >>> dir()
# ['Gizmo', '__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'b', 'x']

# 8.2　标识、相等性和别名
# Lewis Carroll 是 Charles Lutwidge Dodgson 教授的笔名。Carroll 先生指的就是 Dodgson 教授，二者是同一个人。

# 示例 8-3　charles 和 lewis 指代同一个对象
# >>> charles={'name':'Charles L. Dodgson','born':1832}
# >>> lewis=charles
# >>> lewis is charles
# True
# >>> id(charles),id(lewis)
# (34927120, 34927120)
# >>> lewis['balance']=950
# >>> charles
# {'name': 'Charles L. Dodgson', 'born': 1832, 'balance': 950}

# 示例 8-4　alex 与 charles 比较的结果是相等，但 alex 不是charles
# 在那段代码中，lewis 和 charles 是别名，即两个变量绑定同一个对象。
#     而 alex 不是 charles 的别名，因为二者绑定的是不同的对象。
#     alex 和 charles 绑定的对象具有相同的值（== 比较的就是值），但是它们的标识不同。
# 每个变量都有标识、类型和值。
#     对象一旦创建，它的标识绝不会变；你可以把标识理解为对象在内存中的地址。
#     is 运算符比较两个对象的标识；id() 函数返回对象标识的整数表示。
# >>> alex={'name': 'Charles L. Dodgson', 'born': 1832, 'balance': 950}
# ❷ 比较两个对象，结果相等，这是因为 dict 类的 __eq__ 方法就是这样实现的。
# >>> alex  == charles
# True
# ❸ 但它们是不同的对象。这是 Python 说明标识不同的方式：a is notb。
# >>> alex is not charles
# True

# 8.2.1　在==和is之间选择
# == 运算符比较两个对象的值（对象中保存的数据），而 is 比较对象的标识。
# 通常，我们关注的是值，而不是标识，因此 Python 代码中 == 出现的频率比 is 高。

# 8.2.2　元组的相对不可变性
# 元组与多数 Python 集合（列表、字典、集，等等）一样，保存的是对象的引用。
# 如果引用的元素是可变的，即便元组本身不可变，元素依然、可变。

# 示例 8-5　一开始，t1 和 t2 相等，但是修改 t1 中的一个可变元素后，二者不相等了
# ❶ t1 不可变，但是 t1[-1] 可变。
# >>> t1=(1,2,[30,40])
# ❷ 构建元组 t2，它的元素与 t1 一样。
# >>> t2=(1,2,[30,40])
# ❸ 虽然 t1 和 t2 是不同的对象，但是二者相等——与预期相符。
# >>> t1 == t2
# True
# ❹ 查看 t1[-1] 列表的标识。
# >>> id(t1[-1])
# 33289600
# ❺ 就地修改 t1[-1] 列表。
# >>> t1[-1].append(99)
# >>> t1
# (1, 2, [30, 40, 99])
# ❻ t1[-1] 的标识没变，只是值变了。
# >>> id(t1[-1])
# 33289600
# ❼ 现在，t1 和 t2 不相等。
# >>> t1 == t2
# False

# 8.3　默认做浅复制
# 复制列表（或多数内置的可变集合）最简单的方式是使用内置的类型构造方法。
# >>> l1=[3,[55,44],(7,8,9)]
# ❶ list(l1) 创建 l1 的副本。
# >>> l2=list(l1)
# >>> l2
# [3, [55, 44], (7, 8, 9)]
# ❷ 副本与源列表相等。
# >>> l2 == l1
# True
# ❸ 但是二者指代不同的对象。对列表和其他可变序列来说，还能使用简洁的 l2 = l1[:] 语句创建副本。
# >>> l1 is l2
# False

# 示例 8-6　为一个包含另一个列表的列表做浅复制；把这段代码复制粘贴到 Python Tutor 网站中，看看动画效果
# >>> l1=[3,[66,55,44],(7,8,9)]
# ❶ l2 是 l1 的浅复制副本。
# >>> l2=list(l1)
# ❷ 把 100 追加到 l1 中，对 l2 没有影响。
# >>> l1.append(100)
# ❸ 把内部列表 l1[1] 中的 55 删除。这对 l2 有影响，因为 l2[1] 绑定的列表与 l1[1] 是同一个。
# >>> l1[1].remove(55)
# >>> print('li',l1)
# li [3, [66, 44], (7, 8, 9), 100]
# >>> print('l2',l2)
# l2 [3, [66, 44], (7, 8, 9)]
# >>> l2[1] += [33,22]
# >>> l2[2] += (10,11)
# >>> print('l1',l1)
# l1 [3, [66, 44, 33, 22], (7, 8, 9), 100]
# >>> print('l2',l2)
# l2 [3, [66, 44, 33, 22], (7, 8, 9, 10, 11)]

# 示例 8-8　校车乘客在途中上车和下车
class Bus:
    def __init__(self,passengers):
        if passengers is None:
            self.passengers=[]
        else:
            self.passengers=list(passengers)
    def pick(self,name):
        self.passengers.append(name)
    def drop(self,name):
        self.passengers.remove(name)

# 示例 8-9　使用 copy 和 deepcopy 产生的影响
# >>> import copy
# >>> bus1=Bus(['Alice','Bill','Claire','David'])
# >>> bus2=copy.copy(bus1)
# >>> bus3=copy.deepcopy(bus1)
# >>> id(bus1),id(bsu2),id(bus3)
# Traceback (most recent call last):
#   File "<pyshell#44>", line 1, in <module>
#     id(bus1),id(bsu2),id(bus3)
# NameError: name 'bsu2' is not defined
# >>> id(bus1),id(bus2),id(bus3)
# (35175888, 35175856, 37550768)
# ❷ bus1中的'Bill'下车后，bus2中也没有他了。
# >>> bus2.passengers
# ['Alice', 'Claire', 'David']
# >>> id(bus1.passengers),id(bus2.passengers),id(bus3.passengers)
# ❸ 审查passengers属性后发现，bus1和bus2共享同一个列表对象，因为bus2是bus1的浅复制副本。
# (37562848, 37562848, 37609760)
# ❹ bus3是bus1的深复制副本，因此它的passengers属性指代另一个列表。
# >>> bus3.passengers
# ['Alice', 'Bill', 'Claire', 'David']

# 示例 8-10　循环引用：b 引用 a，然后追加到 a 中；deepcopy 会想办法复制 a
# >>> a=[10,20]
# >>> b=[a,30]
# >>> a.append(b)
# >>> a
# [10, 20, [[...], 30]]
# >>> from copy import deepcopy
# >>> c=deepcopy(a)
# >>> c
# [10, 20, [[...], 30]]

# 8.4　函数的参数作为引用时
# Python 唯一支持的参数传递模式是共享传参（call by sharing）。
# 共享传参指函数的各个形式参数获得实参中各个引用的副本。
#     也就是说，函数内部的形参是实参的别名。
# >>> def f(a,b):
#     a += b
#     return a
# >>> x=1
# >>> y=2
# >>> f(x,y)
# 3
# ❶ 数字x没变。
# >>> x,y
# (1, 2)
# >>> a=[1,2]
# >>> b=[3,4]
# >>> f(a,b)
# [1, 2, 3, 4]
# ❷ 列表a变了。
# >>> a,b
# ([1, 2, 3, 4], [3, 4])
# >>> t=(10,20)
# >>> u=(30,40)
# >>> f(t,u)
# (10, 20, 30, 40)
# >>> t,u
# ❸ 元组t没变。
# ((10, 20), (30, 40))

# 8.4.1　不要使用可变类型作为参数的默认值
# 可选参数可以有默认值，这是 Python 函数定义的一个很棒的特性，这样我们的 API 在进化的同时能保证向后兼容。
#     然而，我们应该避免使用可变的对象作为参数的默认值。

# 示例 8-12　一个简单的类，说明可变默认值的危险
class HauntedBus:
    """备受幽灵乘客折磨的校车"""
    # ❶ 如果没传入passengers参数，使用默认绑定的列表对象，一开始是空列表。
    def __init__(self,passengers=[]):
        self.passengers = passengers
    def pick(self,name):
        self.passengers.append(name)
    def drop(self,name):
        self.passengers.remove(name)

# 示例 8-13　备受幽灵乘客折磨的校车
# >>> bus1=HauntedBus(['Alice','Bill'])
# >>> bus1.passengers
# ['Alice', 'Bill']
# >>> bus1.pick('Charles')
# >>> bus1.drop('Alice')
# ❶ 目前没什么问题，bus1 没有出现异常。
# >>> bus1.passengers
# ['Bill', 'Charles']
# ❷ 一开始，bus2 是空的，因此把默认的空列表赋值给self.passengers。
# >>> bus2=HauntedBus()
# >>> bus2.pick('Carrie')
# >>> bus2.passengers
# ['Carrie']
# ❸ bus3 一开始也是空的，因此还是赋值默认的列表。
# >>> bus3=HauntedBus()
# ❹ 但是默认列表不为空！
# >>> bus3.passengers
# ['Carrie']
# ❺ 登上 bus3 的 Dave 出现在 bus2 中。
# >>> bus3.pick('Dave')
# >>> bus2.passengers
# ['Carrie', 'Dave']
# ❻ 问题是，bus2.passengers 和 bus3.passengers 指代同一个列表。
# >>> bus2.passengers is bus3.passengers
# True
# ❼ 但 bus1.passengers 是不同的列表。
# >>> bus1.passengers
# ['Bill', 'Charles']

# 可以审查 HauntedBus.__init__ 对象，看看它的 __defaults__ 属性中的那些幽灵学生：
# >>> dir(HauntedBus.__init__)
# ['__annotations__', '__call__', ...,'__defaults__',...]
# >>> HauntedBus.__init__.__defaults__
# (['Carrie', 'Dave'],)
# 最后，我们可以验证 bus2.passengers 是一个别名，它绑定到HauntedBus.__init__.__defaults__ 属性的第一个元素上：
# >>> HauntedBus.__init__.__defaults__[0] is bus2.passengers
# True

# 8.4.2　防御可变参数
# 如果定义的函数接收可变参数，应该谨慎考虑调用方是否期望修改传入的参数。

# 示例 8-15　一个简单的类，说明接受可变参数的风险
class TwilightBus:
    """让乘客销声匿迹的校车"""
    def __init__(self,passengers=None):
        if passengers is None:
            # ❶ 这里谨慎处理，当passengers为None时，创建一个新的空列表。
            self.passengers = []
        else:
            self.passengers = passengers
    def pick(self,name):
        self.passengers.append(name)
    def drop(self,name):
        self.passengers.remove(name)

# 示例8 - 14　从TwilightBus下车后，乘客消失了
# ❶ basketball_team 中有 5 个学生的名字。
# >>> basketball_team=['Sue','Tina','Maya','Diana','pat']
# ❷ 使用这队学生实例化 TwilightBus。
# >>> bus=TwilightBus(basketball_team)
# ❸ 一个学生从 bus 下车了，接着又有一个学生下车了。
# >>> bus.drop('Tina')
# >>> bus.drop('pat')
# ❹ 下车的学生从篮球队中消失了！
# >>> basketball_team
# ['Sue', 'Maya', 'Diana']

# 8.5　del和垃圾回收
# 对象绝不会自行销毁；然而，无法得到对象时，可能会被当作垃圾回收。
# del 语句删除名称，而不是对象。
#     del 命令可能会导致对象被当作垃圾回收，但是仅当删除的变量保存的是对象的最后一个引用，或者无法得到对象时。
#     重新绑定也可能会导致对象的引用数量归零，导致对象被销毁。

# 示例 8-16　没有指向对象的引用时，监视对象生命结束时的情形
# >>> import weakref
# >>> s1={1,2,3}
# ❶ s1 和 s2 是别名，指向同一个集合，{1, 2, 3}。
# >>> s2=s1
# ❷ 这个函数一定不能是要销毁的对象的绑定方法，否则会有一个指向对象的引用。
# >>> def bye():
#     print('Gone    with the wind...')
# ❸ 在 s1 引用的对象上注册 bye 回调。
# >>> ender=weakref.finalize(s1,bye)
# ❹ 调用 finalize 对象之前，.alive 属性的值为 True。
# >>> ender.alive
# True
# >>> del s1
# ❺ 如前所述，del 不删除对象，而是删除对象的引用。
# >>> ender.alive
# True
# ❻ 重新绑定最后一个引用 s2，让 {1, 2, 3} 无法获取。对象被销毁了，调用了 bye 回调，ender.alive 的值变成了 False。
# >>> s2='spam'
# Gone    with the wind...
# >>> ender.alive
# False

# 8.6　弱引用
# 正是因为有引用，对象才会在内存中存在。当对象的引用数量归零后，垃圾回收程序会把对象销毁。
#     但是，有时需要引用对象，而不让对象存在的时间超过所需时间。这经常用在缓存中。

# 示例 8-17　弱引用是可调用的对象，返回的是被引用的对象；如果所指对象不存在了，返回 None
# >>> import weakref
# >>> a_set={0,1}
# ❶ 创建弱引用对象 wref，下一行审查它。
# >>> wref=weakref.ref(a_set)
# >>> wref
# <weakref at 0x023D19C0; to 'set' at 0x02185558>
# ❷ 调用wref()返回的是被引用的对象，{0, 1}。因为这是控制台会话，所以{0, 1}会绑定给_变量。
# >>> wref()
# {0, 1}
# ❸ a_set 不再指代 {0, 1} 集合，因此集合的引用数量减少了。但是 _变量仍然指代它。
# >>> a_set={2,3,4}
# ❹ 调用 wref() 依旧返回 {0, 1}。
# >>> wref()
# {0, 1}
# ❺ 计算这个表达式时，{0, 1} 存在，因此 wref() 不是 None。
#     但是，随后 _ 绑定到结果值 False。现在 {0, 1} 没有强引用了。
# >>> wref() is None
# ❻ 因为 {0, 1} 对象不存在了，所以 wref() 返回 None。
# False
# >>> wref() is None
# True

# 8.6.1　WeakValueDictionary简介
# WeakValueDictionary 类实现的是一种可变映射，里面的值是对象的弱引用。
#     被引用的对象在程序中的其他地方被当作垃圾回收后，对应的键会自动从 WeakValueDictionary 中删除。
#     因此，WeakValueDictionary 经常用于缓存。
class Cheese:
    def __init__(self,kind):
        self.kind=kind
    def __repr__(self):
        return 'Cheese(%r)'%self.kind

# 示例 8-19　顾客：“你们店里到底有没有奶酪？”
>>> import weakref
>>> stock = weakref.WeakValueDictionary()
>>> catalog=[Cheese('red Leicester'),Cheese('Tilsit'),Cheese('Brie'),Cheese('Parmesan')]
>>> for cheese in catalog:
    stock[cheese.kind]=cheese
>>> sorted(stock.keys())
['Brie', 'Parmesan', 'Tilsit', 'red Leicester']
>>> del catalog
>>> sorted(stock.keys())
['Parmesan']
>>> del cheese
>>> sorted(stock.keys())
[]

# 8.6.2　弱引用的局限
# 不是每个 Python 对象都可以作为弱引用的目标（或称所指对象）。基本的 list 和 dict 实例不能作为所指对象，但是它们的子类可以轻松地解决这个问题：

# 8.7　Python对不可变类型施加的把戏
# 你可以放心跳过本节。这里讨论的是 Python 的实现细节，对Python 用户来说没那么重要。

# 8.8　本章小结
# 每个 Python 对象都有标识、类型和值。只有对象的值会不时变化。

# 8.9　延伸阅读