《Fluent Python》学习笔记chapter 8

《Fluent Python》学习笔记

标识、相等性与别名

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

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

lewis 是 charles 的别名。

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

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

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 == a2
True
# 虽然 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 == a2
False
>>>

浅复制与深复制

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

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 copy

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)

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 ：如果不可变集合保存的是可变元素的引用，那么可变元素的值发生变化后，不可变集合也会随之改变。实际上，这种情况不是很常见。不可变集合不变的是所含对象的标识。