深色模式
第 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)) # 2text
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 能执行的动作的?
各自做法:
| 问题 | Python | C++ |
|---|---|---|
| 内存谁申请 | 解释器自动申请 | 程序员: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 章的列表行为,就都串成了一条线。
动手实验
- 用
id()验证字符串是不可变的:s = "hi"; t = s,然后t = t + "!",打印前后id(s)和id(t)。 - 让
b = a不再"互相影响":改用b = a.copy(),验证b.append(4)之后a不变。 - 写一个函数
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 章参数传递背后的机制。
