Fluent Python 笔记 —— 对象引用、可变性及其影响

发表于 | 分类于 | | 阅读次数:
字数统计: 7.9k | 阅读时长 ≈ 0:08

别名

Python 中的变量类似于 Java 中的引用式变量，可以理解为附加在对象上的“标注”。

比如下面代码中的变量 a 和 b 实际上指向同一个列表：

1
2
3
4
5
>>> a = [1, 2, 3]
>>> b = a
>>> a.append(4)
>>> b
[1, 2, 3, 4]

list

对于引用式变量的赋值，“把变量分配给对象”的说法更为合理。即赋值语句的右边先执行，右侧产生的对象在赋值前就已经创建了。

尝试运行以下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
>>> class Gizmo:
...     def __init__(self):
...             print(f'Gizmo id: {id(self)}')
...
>>> x = Gizmo()
Gizmo id: 140497327120880
>>> y = Gizmo() * 10
Gizmo id: 140497327319840
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for *: 'Gizmo' and 'int'
>>> dir()
['Gizmo', '__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'x']

输出的 Gizmo id: ... 是创建 Gizmo 实例时的副作用。因此 y = Gizmo() * 10 实际上创建了一个新的 Gizmo 实例，但绝不会创建变量 y。因为赋值语句右侧在求值时抛出了异常。
因此在赋值语句中，对象在右边创建或获取，之后左边的变量才会绑定给对象。类似于给对象贴标签，贴的多个标签就是别名。

相等性

两个变量指向同一个对象：

1
2
3
4
5
6
7
8
9
>>> charles = {'name': 'Charles L. Dodgson', 'born': 1832}
>>> lewis = charles
>>> lewis is charles
True
>>> id(charles), id(lewis)
(140497326642048, 140497326642048)
>>> lewis['balance'] = 950
>>> charles
{'name': 'Charles L. Dodgson', 'born': 1832, 'balance': 950}

lewis 是 charles 的别名，两者指向同一个对象。

alex 绑定具有同样内容的另一个对象：

1
2
3
4
5
>>> alex = {'name': 'Charles L. Dodgson', 'born': 1832, 'balance': 950}
>>> alex == charles
True
>>> alex is charles
False

则 alex 指代的对象与赋值给 charles 的对象内容一样，但两者绑定的是不同的对象。

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

== 与 is 的选择

== 用于比较两个对象的值（对象中保存的数据），而 is 比较对象的标识。通常在比较时关注的是值而不是标识，因此 == 出现的几率比 is 要高。

但在变量和单例值之间比较时，应使用 is。比如用 is 检查变量绑定的值是不是 None：x is None 或 x is not None。
原因是 is 运算符比 == 速度更快。因为它不能重载，Python 不用寻找并调用特殊方法，而是直接比较两个整数 ID。而 a == b 是 a.__eq__(b) 的语法糖。多数内置类型使用更有意义的方式覆盖了 __eq__ 方法，因此相等性测试可能涉及大量处理工作。

元组的相对不可变性

元组中保存的是对象的引用。即便元组本身不可变，若元素引用的对象是可变的，则该元素依然可变。即元组的不可变性指的是 tuple 数据结构的物理内容（即保存的引用）不可变，与引用指向的对象无关。

1
2
3
4
5
6
7
8
9
10
11
12
13
>>> t1 = (1, 2, [30, 40])
>>> t2 = (1, 2, [30, 40])
>>> t1 == t2
True
>>> id(t1[-1])
140497326641856
>>> t1[-1].append(99)
>>> t1
(1, 2, [30, 40, 99])
>>> id(t1[-1])
140497326641856
>>> t1 == t2
False

元组的值会随着其中元素引用的可变对象的变化而变化。元组中不可变的是元素的标识。

浅复制与深复制

赋值列表（或多数内置的其他可变集合）最简单的方式是使用类型构造方法。

1
2
3
4
5
6
7
8
>>> l1 = [3, [55, 44], (7, 8, 9)]
>>> l2 = list(l1)
>>> l2
[3, [55, 44], (7, 8, 9)]
>>> l2 == l1
True
>>> l2 is l1
False

list(l1) 会创建 l1 的副本。副本与源列表相等，但两者实际指向不同的对象。还可以使用同样效果的 l2 = l1[:] 语句。

但是，list 构造方法和 [:] 做的都是浅复制，即只复制最外层的容器，副本中的元素是源容器中元素的引用。若所有元素都是不可变的，则没有任何问题，还可以节省内存；若容器中存在可变的元素，则有可能导致意想不到的问题。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
>>> l1 = [3, [66, 55, 44], (7, 8, 9)]
>>> l2 = list(l1)
>>> l1.append(100)
>>> l1
[3, [66, 55, 44], (7, 8, 9), 100]
>>> l2
[3, [66, 55, 44], (7, 8, 9)]
>>> l1[1].remove(55)
>>> l1
[3, [66, 44], (7, 8, 9), 100]
>>> l2
[3, [66, 44], (7, 8, 9)]
>>> l2[1] += [33, 22]
>>> l1
[3, [66, 44, 33, 22], (7, 8, 9), 100]
>>> l2
[3, [66, 44, 33, 22], (7, 8, 9)]
>>> l2[2] += (10, 11)
>>> l2
[3, [66, 44, 33, 22], (7, 8, 9, 10, 11)]
>>> l1
[3, [66, 44, 33, 22], (7, 8, 9), 100]

  • l2 是 l1 的浅复制副本，但是二者引用同一个列表 [66, 55, 44] 和同一个元组 (7, 8, 9)
  • 把 100 追加到 l1 中，对 l2 没有任何影响
  • 把内部列表 l1[1] 中的 55 移除，l2 也会出现同样的改动。原因是 l2[1] 与 l1[1] 绑定的是同一个列表
  • 同样的，l2[1] 引用的列表通过 += 运算符就地修改列表，这样的修改也会在 l1[1] 中体现
  • 对元组来说，+= 运算符会创建一个新元组重新绑定给变量 l2[2]，等同于 l2[2] = l2[2] + (10, 11)，因此最终状态下 l1 和 l2 中的元组不再是同一个对象
对自定义对象做深复制和浅复制
1
2
3
4
5
6
7
8
9
10
11
12
13
# bus.py
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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> from bus import Bus
>>> import copy
>>> bus1 = Bus(['Alice', 'Bill', 'Claire', 'David'])
>>> bus2 = copy.copy(bus1)
>>> bus3 = copy.deepcopy(bus1)
>>> id(bus1), id(bus2), id(bus3)
(140247402065344, 140247402153680, 140247380561296)
>>> bus1.drop('Bill')
>>> bus2.passengers
['Alice', 'Claire', 'David']
>>> id(bus1.passengers), id(bus2.passengers), id(bus3.passengers)
(140247380615936, 140247380615936, 140247401717056)
>>> bus3.passengers
['Alice', 'Bill', 'Claire', 'David']

使用 copy 和 deepcopy 创建 3 个不同的 Bus 实例。
bus1 中的 Bill 下车后，bus2 中也没有他了。原因是 bus2 是 bus1 的浅复制副本，他们共享同一个列表对象。
bus3 是 bus1 的深复制副本，其 passengers 属性指向另一个不同的列表对象。

函数参数作为引用

Python 唯一支持的参数传递模式是共享传参，多数面向对象语言都采用这一模式。在该模式中，函数内部的形参是实参的别名。
上述方案导致函数可能会修改作为参数传入的可变对象，虽然无法修改那些对象的标识（即不能把一个对象替换为另一个对象）。

如下面这个简单的函数，在参数上调用 +=，分别将数字、列表、元组作为参数传入，效果如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
>>> def f(a, b):
...     a += b
...     return a
...
>>> x = 1
>>> y = 2
>>> f(x, y)
3
>>> a = [1, 2]
>>> b = [3, 4]
>>> f(a, b)
[1, 2, 3, 4]
>>> a, b
([1, 2, 3, 4], [3, 4])
>>> t = (10, 20)
>>> u = (30, 40)
>>> f(t, u)
(10, 20, 30, 40)
>>> t, u
((10, 20), (30, 40))

不可变的数字 x 和元组 t 都没变，而可变对象列表 a 变了。

可变类型作为参数默认值

函数的可选参数可以有默认值，但是应尽量避免使用可变对象作为参数的默认值。

1
2
3
4
5
6
7
8
9
class HauntedBus:
    def __init__(self, passengers=[]):
        self.passengers = passengers

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

    def drop(self, name):
        self.passengers.remove(name)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
>>> from hauntedbus import HauntedBus
>>> bus1 = HauntedBus(['Alice', 'Bill'])
>>> bus1.passengers
['Alice', 'Bill']
>>> bus2 = HauntedBus()
>>> bus2.pick('Carrie')
>>> bus2.passengers
['Carrie']
>>> bus3 = HauntedBus()
>>> bus3.passengers
['Carrie']
>>> bus3.pick('Dave')
>>> bus2.passengers
['Carrie', 'Dave']
>>> bus2.passengers is bus3.passengers
True
>>> bus1.passengers
['Alice', 'Bill']

上述的代码表明，bus2.passengers 和 bus3.passengers 指向同一个列表，而 bus1.passengers 是不同的列表。即没有指定初始乘客的 HauntedBus 实例会共享同一个乘客列表。
这个问题的根源在于，函数参数的默认值是在定义函数时计算的，因此该默认值成为了函数对象的属性。因此 self.passengers 变成了 passengers 参数默认值（可变的列表对象）的别名，导致后续的函数调用都会受到影响。

1
2
3
4
>>> HauntedBus.__init__.__defaults__
(['Carrie', 'Dave'],)
>>> HauntedBus.__init__.__defaults__[0] is bus2.passengers
True

函数对可变参数的修改

如果定义的函数接收可变参数，应谨慎考虑调用方是否期望修改传入的参数。比如函数接收一个字典，且在处理过程中要修改它，则该副作用是否要体现到函数外部？

如下面的 TwilightBus 实例：

1
2
3
4
5
6
7
8
9
10
11
12
class TwilightBus:
    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)

1
2
3
4
5
6
7
>>> from twilightbus import TwilightBus
>>> basketball_team = ['Sue', 'Tina', 'Maya', 'Diana', 'Pat']
>>> bus = TwilightBus(basketball_team)
>>> bus.drop('Tina')
>>> bus.drop('Pat')
>>> basketball_team
['Sue', 'Maya', 'Diana']

basketball_team 中有 5 名学生，使用这队学生实例化 TwilightBus。两个学生从 bus 下车后，这两人就从篮球队（basketball_team）中消失了。

代码中 self.passengers = passengers 赋值语句把 self.passengers 变成 passengers 的别名，而后者是传给 __init__ 方法的实参（即 basketball_team）的别名。导致在 self.passengers 上调用 .remove() 和 .append() 方法实际上会修改传给构造方法的列表（basketball_team）。
正确的做事是，校车维护自己的乘客列表。即在 __init__ 中，应该把 passengers 参数值的副本赋值给 self.passengers。

1
2
3
4
5
def __init__(self, passengers=None):
    if passengers is None:
        self.passengers = []
    else:
        self.passengers = list(passengers)

小结

变量保存的是引用，此种行为对 Python 编程有很多实际影响：

  • 简单的赋值操作不会创建副本
  • 对于 += 或 *= 的增量赋值，若左边变量绑定的是不可变对象，则会创建新对象；若左边是可变对象，则就地修改该可变对象
  • 为现有变量赋予新值，不会直接修改之前绑定的变量值。而是创建新的对象并绑定给变量（重新绑定）
  • 函数参数以别名的形式传递，意味着函数可能会修改通过参数传入的可变对象。除非在本地创建可变对象的副本
  • 使用可变类型作用函数参数的默认值有一定风险。若就地修改了参数，则默认值也会改变，进而影响以后使用默认值的调用

参考资料

Fluent Python