Python 对象引用、可变性和垃圾 回收(标识、相等性和别名)

标识、相等性和别名

Lewis Carroll 是 Charles Lutwidge Dodgson 教授的笔名。Carroll 先生指
的就是 Dodgson 教授，二者是同一个人。示例 8-3 用 Python 表达了这个
概念。

示例 8-3　charles 和 lewis 指代同一个对象

>>> charles = {'name': 'Charles L. Dodgson', 'born': 1832}
>>> lewis = charles ➊
>>> lewis is charles
True
>>> id(charles), id(lewis) ➋
(4300473992, 4300473992)
>>> lewis['balance'] = 950 ➌
>>> charles
{'name': 'Charles L. Dodgson', 'balance': 950, 'born': 1832}

❶ lewis 是 charles 的别名。
❷ is 运算符和 id 函数确认了这一点。
❸ 向 lewis 中添加一个元素相当于向 charles 中添加一个元素。

然而，假如有冒充者（姑且叫他 Alexander Pedachenko 博士）生于 1832
年，声称他是 Charles L. Dodgson。这个冒充者的证件可能一样，但是
Pedachenko 博士不是 Dodgson 教授。这种情况如图 8-2 所示。

图 8-2：charles 和 lewis 绑定同一个对象，alex 绑定另一个具有
相同内容的对象
示例 8-4 实现并测试了图 8-2 中那个 alex 对象。
示例 8-4　alex 与 charles 比较的结果是相等，但 alex 不是
charles

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

❶ alex 指代的对象与赋值给 charles 的对象内容一样。
❷ 比较两个对象，结果相等，这是因为 dict 类的 eq 方法就是这
样实现的。
❸ 但它们是不同的对象。这是 Python 说明标识不同的方式：a is not
b。

示例 8-3 体现了别名。在那段代码中，lewis 和 charles 是别名，即
两个变量绑定同一个对象。而 alex 不是 charles 的别名，因为二者绑
定的是不同的对象。alex 和 charles 绑定的对象具有相同的值（== 比
较的就是值），但是它们的标识不同。

---

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

对象 ID 的真正意义在不同的实现中有所不同。在 CPython 中，id() 返
回对象的内存地址，但是在其他 Python 解释器中可能是别的值。关键
是，ID 一定是唯一的数值标注，而且在对象的生命周期中绝不会变。

其实，编程中很少使用 id() 函数。标识最常使用 is 运算符检查，而
不是直接比较 ID。接下来讨论 is 和 == 的异同。

在==和is之间选择

== 运算符比较两个对象的值（对象中保存的数据），而 is 比较对象的
标识。

通常，我们关注的是值，而不是标识，因此 Python 代码中 == 出现的频
率比 is 高。

然而，在变量和单例值之间比较时，应该使用 is。目前，最常使用 is
检查变量绑定的值是不是 None。下面是推荐的写法：

x is None

否定的正确写法是：

x is not None

is 运算符比 == 速度快，因为它不能重载，所以 Python 不用寻找并调用
特殊方法，而是直接比较两个整数 ID。而 a == b 是语法糖，等同于

a.__eq__(b)

。继承自 object 的__eq__ 方法比较两个对象的 ID，结
果与 is 一样。但是多数内置类型使用更有意义的方式覆盖了__eq__
方法，会考虑对象属性的值。相等性测试可能涉及大量处理工作，例
如，比较大型集合或嵌套层级深的结构时。

在结束对标识和相等性的讨论之前，我们来看看著名的不可变类型
tuple（元组），它没有你想象的那么一成不变。

元组的相对不可变性

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

示例 8-5 表明，元组的值会随着引用的可变对象的变化而变。元组中不
可变的是元素的标识。

示例 8-5　一开始，t1 和 t2 相等，但是修改 t1 中的一个可变元
素后，二者不相等了

>>> t1 = (1, 2, [30, 40]) ➊
>>> t2 = (1, 2, [30, 40]) ➋
>>> t1 == t2 ➌
True
>>> id(t1[-1]) ➍
4302515784
>>> t1[-1].append(99) ➎
>>> t1
(1, 2, [30, 40, 99])
>>> id(t1[-1]) ➏
4302515784
>>> t1 == t2 ➐
False

❶ t1 不可变，但是 t1[-1] 可变。
❷ 构建元组 t2，它的元素与 t1 一样。
❸ 虽然 t1 和 t2 是不同的对象，但是二者相等——与预期相符。
❹ 查看 t1[-1] 列表的标识。
❺ 就地修改 t1[-1] 列表。
❻ t1[-1] 的标识没变，只是值变了。
❼ 现在，t1 和 t2 不相等。

元组的相对不可变性解释了 2.6.1 节的谜题。这也是有些元组不可散列
（参见 3.1 节中的“什么是可散列的数据类型”附注栏）的原因。

复制对象时，相等性和标识之间的区别有更深入的影响。副本与源对象
相等，但是 ID 不同。可是，如果对象中包含其他对象，那么应该复制
内部对象吗？可以共享内部对象吗？这些问题没有唯一的答案。参见下
述讨论。