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

1.变量不是盒子
变量不是一个用来装数值的盒子，而是一个贴在内存地址上的标签。所以多个变量可以同时指向一个地址，代表同一个数值，修改其中的一个变量所指向的值，其他变量的值也会跟着改变。
示例：指向内存中同一个列表的三个标识

lst1 = [1,]
lst2 = lst1
lst3 = lst1
print(lst1)
print(lst2)
print(lst3)
lst3.append(3)
print(lst1)
print(lst2)
print(lst3)

当代码执行完前三行的时候，实际上是这样的状态。

当执行完语句lst3.append(3)后：

整段代码的输出：

[1]
[1]
[1]
[1, 3]
[1, 3]
[1, 3]

2.is 和 == 的区别
is比较的是两个对象的id值，==比较的是对象内存储的值。
目前is最常用的场景是x is None，其否定的写法是x is not None。
示例：比较两个字典

charles = {'name': "Charles L. Dodgson", 'born': 1832}
lewis = charles
print(lewis is charles)
print(lewis == charles)
print(id(charles),id(lewis))
alex = {'name': "Charles L. Dodgson", 'born': 1832}
print(alex == charles)
print(alex is charles)

运行结果：

True
True
2095027395392 2095027395392
True
False

可以看到，lewis和charles是一模一样的，既值和地址（id）都一样，所有可以说lewis是charles的别名。
而ales虽然值和charles相等，但实际是内存中两块不同的地址上存储了相等的值。可以预见，修改某个字典的内容，对另一个字典不会有影响。
3.元组的相对不可变性
我们都知道，元组是不可变的。Python中的集合（list、set、tuple等）保存的是对象的引用。所以如果元组中保存的是可变对象的引用，那么虽然元组中保存的对象引用不能改变，但这个引用指向的对象是可以变的。
示例：观察两个元组的变化

t1 = (1,2,[30,40])
t2 = (1,2,[30,40])
print(t1 == t2)
print(id(t1[-1]))
t1[-1].append(99)
print(t1)
print(id(t1[-1]))
print(t1 == t2)

执行前两行语句后，Python为我们在内存中创建了两个一模一样的元组对象，标识分别是t1和t2。

接着，我们给t1的最后一个元素（列表）追加一个值。
通过比较这个列表的id，发现列表的地址并没改变。
但此时这两个列表内存储的值已经不相等了。

代码完整输出结果：

True
140492395547912
(1, 2, [30, 40, 99])
140492395547912
False

4.浅复制和深复制
浅复制：复制的是原来标识指向的引用，修改引用指向的值，对复制前后的两个变量都会有影响。
深复制：复制前后的变量不共享所存储对象的引用，既复制前后的变量除了值相等之外没有其他关系。
Python提供了copy和deepcopy来区分浅复制和深复制。
示例：观察两个列表的状态

l1 = [3,[66,55,44],(7,8,9)]
l2 = list(l1)
l1.append(100)
l1[1].remove(55)
print(f"l1:{l1}")
print(f'l2：{l2}')
l2[1] += [33,22]
l2[2] += (10,11)
print(f"l1:{l1}")
print(f"l2:{l2}")

注意，这里不能直接用l2 = l1的写法，因为这种写法是表示将l1和l2都指向同一块内存地址，在内存中压根不会创建两个列表。
执行l2 = list(l1)语句之后，内存中创建了两个列表，但这是做浅复制，只会复制列表的外壳，所以内层的列表是公用的，这会有一点问题。
执行完前两句之后，内存中的状态如图所示。

分别修改l1和l2的内层列表，会发现这个修改对l1，l2都产生了影响。
最后的状态如图所示。

整段代码的输出：

l1:[3, [66, 44], (7, 8, 9), 100]
l2：[3, [66, 44], (7, 8, 9)]
l1:[3, [66, 44, 33, 22], (7, 8, 9), 100]

Python中的copy模块提供了可供选择的浅复制或深复制。
示例：观察id，理解深复制与浅复制的区别

class Bus:
    def __init__(self,passengers=None):
        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)

import copy

bus1 = Bus(['A','B','C','D'])
bus2 = copy.copy(bus1)
bus3 = copy.deepcopy(bus1)
print(id(bus1),id(bus2),id(bus3))
bus1.drop('B')
print(bus2.passengers)
print(id(bus1.passengers),id(bus2.passengers),id(bus3.passengers))
print(bus3.passengers)

运行结果：

2928614980768 2928615006944 2928615007616
['A', 'C', 'D']
2928691588288 2928691588288 2928691618624
['A', 'B', 'C', 'D']

创建了一个Bus类，并实例化了bus1，bus2和bus3分别是bus1的浅复制和深复制。
bus1、bus2和bus3的id各不相同，说明他们分别在内存中对应了不同的地址。
而bus1和bus2的passengers属性的id是相同的，他们与bus3的passengers属性不同。
于是可以得出结论：浅复制复制的是外壳，深复制会复制所有内层的东西，类似于迭代的复制。

5.共享传参
Python唯一支持的传参模式是共享传参（call by sharing）。
共享传参的意思是函数中的各个形参获得传入的各个实参引用的副本。可以说在函数内部，形参是实参的别名。
这将导致函数可能会修改所传入的可变对象内存储的值，虽然无法修改他们的标识。
示例：函数修改可变对象

def f(a,b):
    a += b

x = 1
y = 2
f(x,y)
print(x,y)
u = [1,2]
v = [3,4]
f(u,v)
print(u,v)
a = (10,20)
b = (20,30)
f(a,b)
print(a,b)

运行结果：

1 2
[1, 2, 3, 4] [3, 4]
(10, 20) (20, 30)

可以看到，当传入的参数是列表时，原来列表的值被修改了。
而当传入的是常数或者元组时，原来的值没有被改变。
因此，函数可能会修改那些传入的可变对象，在给函数传入可变对象前要谨慎。
6.不要将可变类型用作参数的默认值
不要将可选参数的默认值设置为可变类型，这可能将会给后续代码造成麻烦。
示例：一个奇怪的巴士

class HauntedBus:
    """与上面的Bus类类似，但这个bus有点诡异"""
    def __init__(self,passengers=[]):
        """一个有点'聪明'的做法，省去了if判断"""
        self.passengers = passengers

    def pick(self,name):
        self.passengers.append(name)

    def drop(self,name):
        self.passengers.remove(name)

bus1 = HauntedBus(['A','B'])
print(bus1.passengers)
bus1.drop('A')
print(bus1.passengers)
bus2 = HauntedBus()
bus2.pick('C')
print(bus2.passengers)
bus3 = HauntedBus()
print(bus3.passengers)
bus3.pick('D')
print(bus3.passengers)
print(bus2.passengers is bus3.passengers)

执行结果：

['A', 'B']
['B']
['C']
['C']
['C', 'D']
True

当手动传入列表初始化bus1时，没有什么意外发生。
当使用默认的空列表初始化bus2时，似乎也没有问题。
但是当再次尝试使用默认列表初始化bus3时，奇怪的事情发生了，bus3上坐着bus2的乘客。
打印id发现，bus2和bus3内passengers属性指向的是同一块内存地址。
最后的状态如图所示：

上述状况发生的根本原因是：默认值作为函数对象的属性存储，如果默认值是可变对象，那么修改了这个可变读写，后续的调用都会被影响。
7.接受可变类型的参数有风险
上面的示例告诉我们当可变对象当做参数的默认值时，会函数的后续调用产生影响。
那么当传入的参数是可变对象，其实也会产生一定的风险。
示例：让乘客消失的bus

class TwilightBus:
    """让乘客销声匿迹的bus"""
    def __init__(self, passengers=None):
        if passengers is None:
            self.passengers = []
        else:
            self.passengers = passengers

    def pick(self, name):
        self.passengers.append(name)

    def drop(self, name):
        self.passengers.remove(name)

passengers_list = ['A','B','C','D']
bus = TwilightBus(passengers_list)
print(bus.passengers)
bus.drop('A')
bus.drop('B')
print(bus.passengers)
print(passengers_list)

运行结果：

['A', 'B', 'C', 'D']
['C', 'D']
['C', 'D']

实例化了一个bus，传入的参数是乘客列表。
bus的运行似乎没有问题，但问题是原来的乘客列表passengers_list也被修改了。
最后的状态如图所示：

解决方法很简单，只需要把self.passengers = passengers语句变成self.passengers = list(passengers)。
前者传给函数的是实参的引用，而后者则会真实地创建一个列表，虽然是浅复制。
8.Python的垃圾回收机制
Python使用del关键字删除变量，但del并不是直接删除某个对象，而是只去掉变量标识，在某个对象的引用数变成0后，Python会自动将这个无人引用的对象回收。
示例：观察对象何时被回收

import weakref
s1 = {1,2,3}
s2 = s1
def bye():
    print('bye bye bye ~')

ender = weakref.finalize(s1,bye)
print(ender.alive)
del s1
print(ender.alive)
s2 = 'spam'
print(ender.alive)

注：weakref是内置的弱引用模块，finalize函数为s1指向的对象注册回调bye，当对象被销毁时，会执行这个回调。
运行结果：

True
True
bye bye bye ~
False

一开始s1和s2标识都指向了同一个{1,2,3}对象，因此，即使用del删除了s1对集合对象的引用，依然还有s2，此时这个对象的引用数为1。当再次用赋值语句将s2标识执行另一个对象时，这个集合对象的引用计数就为0了，此时该对象被销毁，触发回调函数。
9.弱引用
当对象有了引用，对象才能在内存中存在，否则当对象的引用数为0时，系统就会把这个对象回收。
弱引用不会增加对象的引用数，引用的目标对象称为所指对象（referent），因此弱引用不会妨碍垃圾回收机制。