《Fluent Python》学习笔记chapter 8

《Fluent Python》学习笔记

标识、相等性与别名

别名指两个变量绑定到同一个对象中，

>>> charles = {'name': 'Charles L. Dodgson', 'born': 1832}>>> lewis = charles>>> lewis is charlesTrue

lewis 是 charles 的别名。

charles 和 lewis 绑定同一个对象，alex 绑定另一个具有相同内容的对象。

>>> alex = {'name': 'Charles L. Dodgson', 'born': 1832, 'balance': 950}>>> alex == charlesTrue>>> alex is not charlesTrue

Python 说明标识不同的方式： a is not b 。所以alex与charles不同。
上述中，lewis 和 charles 是别名，即两个变量绑定同一个对象。而 alex 不是 charles 的别名，因为二者绑定的是不同的对象。 alex 和 charles 绑定的对象具有相同的值（ == 比较的就是值），但是它们的标识不同。

注： 每个变量都有标识、类型和值。对象一旦创建，它的标识绝不会变；可以把标识理解为对象在内存中的地址。is 运算符比较两个对象的标识,而==运算符比较的是两个对象的值；id() 函数返回对象标识的整数表示。

元组的相对不可变

元组与多数 Python 集合（列表、字典、集，等等）一样，保存的是对象的引用。如果引用的元素是可变的，即便元组本身不可变，元素依然可变。也就是说，元组的不可变性其实是指 tuple 数据结构的物理内容（即保存的引用）不可变，与引用的对象无关。

>>> a1 = (1, 2, [3, 4]) # a1不可变，但a1[-1]列表可变>>> a2 = (1, 2, [3, 4])>>> a1 == a2True# 虽然 a1 和 a2 是不同的对象，但是二者值相等>>> id(a1[-1])1974448920392>>> a1[-1][3, 4]>>> a1[-1].append(5)>>> a1(1, 2, [3, 4, 5])>>> id(a1[-1])1974448920392 # 标识没变，值改变>>> a1 == a2False>>>

浅复制与深复制

只复制了外层的容器壳，而副本中的元素是源容器中元素的引用。
如果所有元素都是不可变的，那么这样没有问题，还能节省内存。但是，如果有可变的元素，可能就会导致意想不到的问题。

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

执行完前两行代码图：
l1 和 l2 指代不同的列表，但是二者引用同一个列表 [66, 55, 44] 和元组 (7, 8, 9)

执行完后图：
二者依然引用同一个列表对象，现在列表的值是 [66, 44, 33, 22]，不过 l2[2] += (10, 11) 创建一个新元组，内容是 (7, 8, 9, 10, 11)，它与 l1[2] 引用的元组 (7, 8, 9) 无关

图表由 Python Tutor 网站生成。

浅复制没什么问题，但有时我们需要的是深复制（即副本不共享内部对象的引用）。 copy模块提供的 deepcopy 和 copy 函数能为任意对象做深复制和浅复制。

# -*- coding: utf-8 -*- import copyclass 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)if __name__ == '__main__':    bus1 = Bus(['Alice', 'Bill', 'Claire', 'Dacid'])    bus2 = copy.copy(bus1)    bus3 = copy.deepcopy(bus1)    print(id(bus1),id(bus2),id(bus3))    bus1.drop('Alice')    print(bus2.passengers)

共享传参

共享传参指函数的各个形式参数获得实参中各个引用的副本。

>>> def f(a, b):...     a += b...     return a...>>> x = 1>>> y = 2>>> f(x, y)3       >>> x,y(1, 2)   # 数字没变>>> a = [1,2]>>> b = [3,4]>>> f(a, b)[1, 2, 3, 4]>>> a, b([1, 2, 3, 4], [3, 4])  # 列表改变>>> m = (11,22)>>> n = (33, 44)>>> f(m, n)(11, 22, 33, 44)>>> m, n((11, 22), (33, 44)) # 元组没变>>>

不要使用可变类型作为参数的默认值

如果默认值是可变对象，而且修改了它的值，那么后续的函数调用都会受到影响。

小结

每个 Python 对象都有标识、类型和值。只有对象的值会不时变化。
如果两个变量指代的不可变对象具有相同的值（ a == b 为 True ），实际上它们指代的是副本还是同一个对象的别名基本没什么关系，因为不可变对象的值不会变，但有一个例外。这里说的例外是不可变的集合，如元组和 frozenset ：如果不可变集合保存的是可变元素的引用，那么可变元素的值发生变化后，不可变集合也会随之改变。实际上，这种情况不是很常见。不可变集合不变的是所含对象的标识。