Skip to content

第 17 章:引用与对象机制 ​

本章承接第 1 章的变量与第 10 章的列表:第 1 章说变量有自己的类型和值,本章掀开盖子看 Python 的变量到底是什么。第 4 章讲了源代码怎么被解释器逐行执行,本章讲程序运行时数据放在哪里——两章一前一后,是理解"解释型 vs 编译型"的两根支柱,第 0 章埋下的伏笔到本章收掉。

本章能学到什么 ​

  • 变量不是盒子,是"贴在盒子上的标签"
  • 用 id() 亲眼看对象的地址
  • 可变对象与不可变对象:为什么列表会"互相影响",整数不会
  • is 与 == 的区别
  • 引用计数与垃圾回收:内存什么时候被自动收走

场景:改了一个列表,另一个跟着变了 ​

先看一段让人困惑的代码:

python
a = [1, 2, 3]
b = a          # 把 a "赋给" b
b.append(4)    # 改的是 b
print(a)       # 但 a 也变了!
text
[1, 2, 3, 4]

明明改的是 b,a 怎么也多了个 4?如果变量是"装数据的盒子",这件事解释不通——复制一个盒子,里面的东西不会互相影响。第 8 章还有一个一直没解释的疑点:为什么列表传进函数改了,外面跟着变;整数传进函数"改"了,外面不变?答案相同,都藏在 Python 的变量机制里。要解开这个谜,得先看看变量到底是什么。

变量是标签,不是盒子 ​

C++ 里变量是内存里的一块格子,变量名就钉在格子上。Python 不一样:

说法对不对
变量是一个盒子,值装在盒子里不对
值本身是一个盒子(对象),变量是贴在盒子上的标签对

a = [1, 2, 3] 做了两件事:先造一个装着 [1, 2, 3] 的盒子(对象),再把标签 a 贴上去。

b = a 不是复制盒子,而是又撕了一张标签 b,贴在同一个盒子上。所以盒子只有一个,标签有两张——改盒子里的东西,两张标签看到的结果自然一样:

text
a ──┐
    ├──> [1, 2, 3, 4]   ← 只有一个盒子
b ──┘

这也解释了第 8 章参数传递的现象:函数收到的不是盒子的复制品,而是同一个盒子的又一张标签。

id():亲眼看地址 ​

每个对象在内存里都有一个地址,id() 能把它读出来:

python
a = [1, 2, 3]
b = a              # 同一个盒子的第二张标签
c = [1, 2, 3]      # 内容相同的另一个盒子

print(id(a))
print(id(b))       # 和 a 一样:同一个盒子
print(id(c))       # 不一样:是另一个盒子
text
4308963584
4308963584
4309098048

这些大数字每次运行都不一样,属于正常现象——盒子这次放在内存的哪个位置是解释器安排的。重点是前两个相同、第三个不同:id 相同就是同一个盒子。

可变与不可变:两种盒子 ​

盒子分两种:内容能改的(可变对象)和内容不能改的(不可变对象)。

类型可变性例子
列表、字典可变[1, 2].append(3) 原地改
整数、浮点数、字符串、元组不可变"ab" 不能改成 "ac",只能换个新盒子

不可变对象上做"修改",实际是造一个新盒子、把标签挪过去。对比实验:

python
# 可变对象:改内容,所有标签都看到
x = [1, 2]
y = x
y.append(3)        # 原地改盒子
print(x, y)        # 两张标签看到的是同一个改过的盒子

# 不可变对象:"改"其实是换标签
m = 10
n = m
n = n + 1          # 造出 11 这个新盒子,n 改贴上去;m 还贴在 10 上
print(m, n)
text
[1, 2, 3] [1, 2, 3]
10 11

这就是第 8 章参数传递背后的机制:把列表传进函数,函数里改了,外面也跟着变——因为函数里那张标签贴在同一个盒子上;把整数传进函数,函数里"改"了,外面不变——因为函数里那张标签被挪到了新盒子上,外面那张没动。

想要一个真正独立的副本,就要明确说"复制一个盒子":

写法结果
b = a同一个盒子,两张标签,互相影响
b = a.copy()复制一个新盒子,互不干扰
b = list(a) 或 b = a[:]同上,也是复制

is 与 ==:同一个人,还是长得像 ​

运算符比较什么学校里的类比
==内容是否一样两份答案是否相同
is是不是同一个对象(id 相同)是不是同一张卷子
python
a = [1, 2, 3]
b = a              # 同一个盒子
c = [1, 2, 3]      # 内容相同的另一个盒子

print(a == c)      # True:内容一样
print(a is c)      # False:不是一个盒子
print(a is b)      # True:同一盒子的两张标签
text
True
False
True

判断相等一般用 ==;只有关心"是不是同一个对象"时才用 is,最常见的场合是判断 x is None。

引用计数与垃圾回收:内存谁收 ​

C++ 册的同一章里,内存要程序员自己申请、自己归还(new / delete)。Python 不用,因为解释器在背后记着账:

每个盒子身上都记着贴了几张标签,这个数字叫引用计数。标签被撕掉(del,或者变量改贴别的盒子),计数减一;计数归零,说明这个盒子谁也够不着了,解释器就把它收走,腾出内存。这套自动收盒子的机制叫垃圾回收。

python
import sys

a = [1, 2, 3]
b = a
print(sys.getrefcount(a))   # 3:a、b,加上 getrefcount 临时贴的一张
del b                        # 撕掉 b 这张标签
print(sys.getrefcount(a))   # 2
text
3
2

这就是为什么 Python 程序不用操心内存:只管贴标签,收盒子的事解释器包了。代价是解释器要一直盯着这些账——这也是解释型语言通常慢一些的原因之一。

+= 的两种命运 ​

同一个 +=,在可变对象和不可变对象身上走的是两条路:

python
# 不可变对象:+= 是换标签
n = 10
m = n
n += 1          # 等价于 n = n + 1,造新盒子,n 改贴
print(m, n)     # 10 11

# 可变对象:+= 是原地改盒子
a = [1, 2]
b = a
a += [3]        # 列表的 += 原地加长,盒子还是同一个
print(a, b)     # [1, 2, 3] [1, 2, 3]
text
10 11
[1, 2, 3] [1, 2, 3]

整数的 += 让 n 换了盒子,m 没动;列表的 += 原地改了盒子,两张标签一起看到。同一个符号,两种命运,分界线就是可变性。

小整数的特例 ​

做 id() 实验时可能撞见一个奇怪的现象:

python
x = 100
y = 100
print(x is y)    # True?两个变量怎么是同一个盒子
text
True

原因:-5 到 256 这些小整数太常用,Python 提前把它们各造了一个盒子放在那里,谁赋值就贴谁的标签——所以 x 和 y 贴的是同一个现成的盒子。这是解释器为省内存做的小优化,不影响 == 的判断。大整数不享受这个待遇,但要演示这一点,得让其中一个值在运行时才算出来(直接写两遍 1000,解释器有时会好心复用同一个盒子):

python
x = 1000
y = int("1000")   # 运行时才造出来的 1000,是另一个盒子
print(x == y)     # True:内容一样
print(x is y)     # False:不是一个盒子
text
True
False

这个实验的结论和前面一致:比内容用 ==,别用 is。

【跨语言对照】内存管理与两种执行方式 ​

本质问题:数据用完了,占的内存谁来收?程序又是怎么从源代码变成 CPU 能执行的动作的?

各自做法:

问题PythonC++
内存谁申请解释器自动申请程序员:new,或容器代劳
内存谁回收垃圾回收器自动收走程序员:delete,或 RAII 自动归还
变量是什么贴在对象上的一张标签一块有地址的内存格子
能不能看地址能用 id() 看,但不能拿地址操作能,& 直接看、直接用
源代码怎么跑起来解释器逐行翻译、逐行执行先编译成机器码,再直接执行

姊妹篇——《C++ 从入门到精通》第 17 章讲的是 C++ 侧的同一个主题:数据在内存里到底怎么放。那边的变量不是标签,而是格子本身,还有一种叫"指针"的工具能直接拿着地址操作。

为什么设计不一样:这就回到第 0 章埋的伏笔了。Python 是解释型语言:解释器陪在程序旁边,逐行翻译、逐行执行(第 4 章见过这个过程),顺手把申请内存、回收内存这些杂事全包了——所以省心,所以变量只是标签,所以地址看得见摸不着。C++ 是编译型语言:编译器把源代码整个翻译成机器码,程序运行时直接操作内存——所以快,所以能看地址,所以内存责任也在程序员肩上。

两种方式没有谁替代谁:数据分析、人工智能用前者,游戏引擎、操作系统用后者。学到这里,第 1 章的"类型"和第 4 章的"导入执行"再加上本章的"对象"合起来,"解释型 vs 编译型"这句话就不再是名词,而是亲眼见过的两种世界。

常见坑 ​

坑现象办法
b = a 当复制用改了 b,a 也跟着变要独立副本就 a.copy()
用 is 比内容有时碰巧正确,有时不对,结果飘忽比内容用 ==,is 只用于 None 等身份判断
函数里改列表函数返回后,外面的列表变了不想改就在函数里先 copy()
字符串原地改s[0] = "H" 直接报错字符串不可变,拼接造新的

标签模型回头看 ​

用标签模型回头重读前面的章节,许多"规定"都变成了顺理成章:

章节当时的规定标签模型的解释
第 1 章变量不用声明类型标签不挑盒子,贴到哪个盒子就是什么类型
第 8 章列表传进函数会互相影响传的是同一个盒子的标签
第 9 章字符串不能改某个字符字符串是不可变盒子
第 10 章列表能随时 append列表是可变盒子
第 15 章写文件要把数字转成文本文件装不下盒子,只装得下字符

学到这里,前面章节里零散的规定被同一条线串了起来——这条线就是"变量是标签,值是盒子"。

小结 ​

Python 的变量是贴在对象上的标签:赋值是贴标签,不是复制;id() 能看到盒子在哪;可变对象原地改、不可变对象换标签;== 比内容、is 比身份;标签撕光了的盒子,由垃圾回收自动收走。理解了标签模型,第 8 章的参数传递、第 10 章的列表行为,就都串成了一条线。

动手实验 ​

  1. 用 id() 验证字符串是不可变的:s = "hi"; t = s,然后 t = t + "!",打印前后 id(s) 和 id(t)。
  2. 让 b = a 不再"互相影响":改用 b = a.copy(),验证 b.append(4) 之后 a 不变。
  3. 写一个函数 try_change(x, lst),函数里执行 x = x + 1 和 lst.append(99)。调用后打印外面的整数和列表,解释观察到的现象。
💡 查看答案

第 1 题:

python
s = "hi"
t = s
print(id(s) == id(t))   # True:同一个盒子

t = t + "!"             # 造了新盒子 "hi!"
print(id(s) == id(t))   # False:t 已改贴新盒子
print(s)                # hi:s 那张标签没动

字符串不能原地改,t + "!" 只能造一个新盒子。

💡 查看答案

第 2 题:

python
a = [1, 2, 3]
b = a.copy()     # 复制一个新盒子再贴标签
b.append(4)
print(a)         # [1, 2, 3]
print(b)         # [1, 2, 3, 4]

copy() 先造一个内容相同的新盒子,再把 b 贴上去。两张标签各贴各的盒子,互不干扰。b = list(a) 或 b = a[:] 也能达到同样效果。

💡 查看答案

第 3 题:

python
def try_change(x, lst):
    x = x + 1          # x 这张标签改贴到新盒子上
    lst.append(99)     # 原地改 lst 贴的那个盒子

n = 10
nums = [1, 2]
try_change(n, nums)
print(n)      # 10:外面的标签没动
print(nums)   # [1, 2, 99]:同一个盒子被改了

整数是不可变对象,函数里的 x = x + 1 只是把函数内那张标签挪走;列表是可变对象,append 原地改盒子,外面的标签看到的是改过的盒子。这正是第 8 章参数传递背后的机制。