深入理解 Python 中的引用与拷贝:别再让对象“分身”戏弄你

很多 Python 初学者都会写出这样的代码，然后盯着屏幕百思不得其解：

a = [1, 2, 3]
b = a
b.append(4)
print(a)   # 输出 [1, 2, 3, 4]  —— a 怎么也被改了？

更有经验的开发者，也可能在嵌套列表、默认参数或复杂的对象传递中踩进同样的陷阱。这一切的根源，都在于对 引用 和 拷贝 的混淆。

对于这个问题，在我的视频课程中（参见 B 站的免费视频课程：https://space.bilibili.com/157232748/lists/8219076）已经做了详细解释，但有的同学还没有看到该课程，所以，这篇文章再从底层机制出发，对“引用”和“拷贝”进行深入讲解，并给出让你远离 bug 的实践准则。

一、一切皆对象，变量只是标签

在 Python 中，数据存储在内存中的对象里。变量不是盒子，而是贴在对象上的名字标签。赋值语句 x = something，本质是把标签 x 贴到 something 这个对象上。

可以用内置函数 id() 查看对象的身份（内存地址）：

a = [1, 2, 3]
b = a
print(id(a))   # 例如 140244832000000
print(id(b))   # 与 a 完全相同

b = a 并没有创建新列表，它只是多贴了一张标签 b 在同一个列表对象上。此时 a 和 b 互为 别名，它们引用的是同一个对象。因此通过 b 修改列表，a 看到的内容自然也变了。

这就是 引用 的核心：多个名字指向同一个对象，一处修改，处处可见。

二、不可变对象制造的“安全错觉”

你可能会疑惑：为什么对整数、字符串这么做，好像就没事？

x = 10
y = x
y += 5
print(x)   # 10，x 没有变

原因不是整数赋值时拷贝了值，而是 整数是不可变对象。执行 y += 5 时，实际上创建了一个新的整数对象 15，并把标签 y 重新贴到 15 上，原对象 10 依然被 x 引用，因此 x 不受影响。这依然是引用规则，只是不可变性让你产生了“拷贝”的错觉。

一旦换成可变对象（如列表、字典、集合、自定义类实例），原地修改就会把共享引用的后果暴露无遗。

三、无处不在的引用传递

Python 的函数参数传递，本质也是赋标签。调用 func(arg) 时，形参被绑定到实参所引用的同一个对象上。于是，函数内部对可变对象的修改会直接影响外部：

defsurprise(lst):
    lst.append(999)

my_list = [1, 2]
surprise(my_list)
print(my_list)   # [1, 2, 999]

更有名的陷阱是可变默认参数：

defbuggy_func(data=[]):
    data.append(1)
return data

print(buggy_func())   # [1]
print(buggy_func())   # [1, 1]  —— 天哪，默认参数“记住”了上次的值

默认参数 [] 在函数定义时只被求值一次，之后每次调用共享同一个列表对象。这也是引用导致的经典 bug。

四、拷贝：切断共享的刀

如果你想得到一个“独立”的对象，就需要拷贝。

4.1 浅拷贝 (Shallow Copy)

浅拷贝会创建一个新的容器对象，但内部元素仍然是原对象中元素的引用。常用的浅拷贝方式有：

• 序列内置方法：new_list = old_list.copy() 或 new_list = old_list[:]
• copy 模块：import copy; new_list = copy.copy(old_list)
• 字典：new_dict = old_dict.copy()

浅拷贝对一维可变对象看起来完全独立：

a = [1, 2, 3]
b = a.copy()
b.append(4)
print(a)   # [1, 2, 3]  互不影响，很好
print(b)   # [1, 2, 3, 4]

然而，当容器内嵌套了可变对象，浅拷贝就不够用了。

4.2 浅拷贝在嵌套结构下的“不彻底”

a = [[1, 2], [3, 4]]
b = a.copy()        # 浅拷贝

b[0].append(99)     # 修改内层列表
print(a)            # [[1, 2, 99], [3, 4]]  —— a 也被改变了！
print(b)            # [[1, 2, 99], [3, 4]]

图示理解：

• 浅拷贝后，b 是一个全新的外层列表，但 b[0] 和 a[0] 指向同一个内层列表 [1, 2]。
• 所以修改 b[0]，a[0] 看到的还是那个被改过的列表。

浅拷贝只复制了“第一层”，深处的对象依然是共享引用。

4.3 深拷贝 (Deep Copy)

要得到完全独立的副本，必须使用 copy.deepcopy()。它会递归地复制对象以及对象内部嵌套的所有可变元素，保证新旧对象没有任何共享的引用。

import copy

a = [[1, 2], [3, 4]]
b = copy.deepcopy(a)

b[0].append(99)
print(a)   # [[1, 2], [3, 4]]  —— 完全不受影响
print(b)   # [[1, 2, 99], [3, 4]]

深拷贝会沿着对象图一直复制下去，哪怕嵌套层次极深，也会构建出一棵全新的对象树。

注意：对于不可变对象（如整数、字符串），深拷贝不会复制它们，因为不可变对象共享没有任何副作用，deepcopy 会直接返回原引用以节约内存。

五、更微妙的状况：元组里装着可变对象

元组是不可变的，但元组内如果包含列表，列表内容可变。浅拷贝元组时：

import copy
t1 = ([1, 2], [3, 4])
t2 = copy.copy(t1)      # 浅拷贝元组

t2[0].append(99)
print(t1)   # ([1, 2, 99], [3, 4]) —— 元组内的列表还是共享的！

因为元组不可变，浅拷贝甚至可以不创建新元组（对于完全由不可变元素组成的元组，copy.copy 通常直接返回它本身）。但若包含可变元素，copy.copy 依然只会复制容器，内部元素还是引用。而 copy.deepcopy(t1) 则会递归复制内层列表，实现完全独立。

六、引用 vs 拷贝：决策指南

七、避坑铁律与最佳实践

1. 理解赋值就是贴标签：a = b 让 a 和 b 站在同一条船上。
2. 优先使用不可变数据：函数返回不可变对象或使用元组代替列表，从源头减少副作用。
3. 警惕默认参数陷阱：默认参数绝不要使用可变对象，用 None 代替：

   defsafe_func(data=None):
   if data isNone:
           data = []
       data.append(1)
   return data
   

4. 拷贝前想清楚层次：是就一层可变？还是有嵌套？不确定时，用 copy.deepcopy() 虽可能有点性能损耗，但能保住正确性。
5. 显式胜于隐式：如果函数内部需要修改传入的列表，但不想影响调用者，应明确在文档中说明，或函数开头就执行拷贝。
6. 用 is 验证身份：如果怀疑两个变量是否共享引用，a is b 比 id(a) == id(b) 更优雅。

八、总结

Python 的引用和拷贝不是魔法，而是简单的“贴标签”与“建新对象”规则。一旦你脑中建立起 “变量 → 标签 → 对象” 的内存模型，并且清醒认识到：

• 引用：同船共济，一损俱损。
• 浅拷贝：换了船体，但船员还是同一批。
• 深拷贝：连船带人全部复制了一遍。

那些诡异的列表“自动”变长、默认参数“记忆”旧值、嵌套字典“串线”的问题，将再也困扰不了你。掌握了这一核心心智模型，你写的 Python 代码会更加可预测、健壮且易于维护。