copy 和 deepcopy 到底在拷贝什么？一文讲清赋值、浅拷贝、深拷贝的引用关系

写在前面

上一篇聊了可变默认参数的坑，本质是"该新建对象却没新建，所有调用共享同一份数据"。今天这篇，咱们把话题再往前推一步：就算你主动写了"拷贝"代码，如果没搞清楚拷贝的层级，一样会踩到几乎一模一样的坑。

最典型的场景：你想复制一份配置字典留着自己改，顺手用了 config.copy()，结果改着改着发现，线上那份"原始配置"也被你悄悄改了。这不是 bug，是你对 copy() 到底复制了什么层级，理解错了。

一、是什么：赋值 vs 浅拷贝 vs 深拷贝

Python 里"复制一个对象"其实有三种完全不同的行为，很多人默认它们是一回事：

用一张图看三者在引用关系上的差异会更直观：

直接用 id() / is 实锤这三种关系：

 复制代码import copya = [1, 2, [3, 4]]b_assign  = a                  # 赋值
b_shallow = copy.copy(a)       # 浅拷贝
b_deep    = copy.deepcopy(a)   # 深拷贝print(a is b_assign)           # True  —— 同一个对象
print(a is b_shallow)          # False —— 外层是新对象了
print(a[2] is b_shallow[2])    # True  —— 但内层嵌套的 list 还是原来那个
print(a[2] is b_deep[2])       # False —— 深拷贝连内层也是新对象

二、为什么：Python 要区分浅拷贝和深拷贝

如果每次拷贝都直接深拷贝，行为是最"安全"的，为什么 Python 还要保留浅拷贝这种"不彻底"的复制方式？答案是性能和语义的取舍：

• 浅拷贝只做一层复制，代价很小，适合"我只想要一个新的容器，但内部元素本来就打算共享"的场景，比如函数入参只想保护调用方的顶层列表不被 append/pop，并不关心内部元素是否共享。
• 深拷贝要递归遍历整个对象图，代价随嵌套深度和数据量线性增长，只有在你明确需要"两份数据从此互不相干"时才值得付出这个开销。

另外深拷贝还要解决一个浅拷贝完全不用管的问题：循环引用。如果一个对象直接或间接引用了自己，朴素的"递归复制"逻辑会陷入死循环。copy.deepcopy 内部维护了一个 memo 字典，记录"原对象 id() → 已经拷贝出来的新对象"，每次准备拷贝一个对象前先查这个字典，如果已经拷贝过就直接复用，不会重复递归：

 复制代码a = [1, 2]
a.append(a)            # 让 a 自己引用自己b = copy.deepcopy(a)
print(b)                # [1, 2, [...]]  —— 没有死循环，打印时用 [...] 表示自引用
print(b[2] is b)         # True —— b 内部的"自引用"被正确指向了新对象 b 自己

三、怎么用：常见写法与最容易踩的坑

1. 这几种写法都是浅拷贝，效果完全等价

 复制代码a = [1, [2, 3]]b1 = a[:]           # 切片
b2 = list(a)         # 构造函数
b3 = a.copy()        # list 自带的 copy 方法
b4 = copy.copy(a)    # copy 模块print(a[1] is b1[1], a[1] is b2[1], a[1] is b3[1], a[1] is b4[1])
# True True True True —— 内层嵌套对象全部还是同一个d = {"x": [1, 2]}
print(d["x"] is d.copy()["x"])   # True —— dict.copy() 同理

2. 浅拷贝的坑：原地修改嵌套对象会"牵一发动全身"

 复制代码a = [1, 2, [3, 4]]
b = copy.copy(a)b[2].append(99)      # 原地修改 b 里嵌套的 list
print(a)               # [1, 2, [3, 4, 99]]  ← a 也被改了！
print(b)               # [1, 2, [3, 4, 99]]

但如果只是替换外层元素（重新赋值，不是原地修改），两边是互不影响的：

 复制代码a = [1, 2, [3, 4]]
b = copy.copy(a)b[0] = 100            # 替换外层元素
print(a)               # [1, 2, [3, 4]] —— a 不受影响
print(b)               # [100, 2, [3, 4]]

规律和上一篇的可变/不可变对象完全一致：浅拷贝之后，外层"替换"操作互不影响（本质是重新绑定引用）；但内层如果是可变对象，对它的原地修改（append/update/下标赋值）会同时影响两边——因为两边内层实际上是同一个对象。

3. 深拷贝：彻底独立

 复制代码a = [1, 2, [3, 4]]
b = copy.deepcopy(a)b[2].append(99)
print(a)   # [1, 2, [3, 4]]         —— a 完全不受影响
print(b)   # [1, 2, [3, 4, 99]]

4. 自定义对象同样适用

copy.copy() / copy.deepcopy() 对自定义类实例同样有效，默认拷贝的是实例的属性字典 __dict__：

 复制代码class Person:
    def __init__(self, name, pets):
        self.name = name
        self.pets = petsp1 = Person("Tom", ["cat", "dog"])
p2 = copy.copy(p1)       # 浅拷贝
p3 = copy.deepcopy(p1)    # 深拷贝print(p1.pets is p2.pets)   # True  —— 浅拷贝：pets 还是同一个 list
print(p1.pets is p3.pets)   # False —— 深拷贝：pets 也是新的 listp2.pets.append("bird")
print(p1.pets)   # ['cat', 'dog', 'bird'] —— p1 被 p2 的修改连累了

如果某个类想自定义拷贝逻辑（比如某些属性不该被拷贝），可以实现 __copy__ / __deepcopy__ 方法，copy 模块会优先调用它们，这里先知道有这个扩展点即可。

四、面试追问

Q1：赋值、浅拷贝、深拷贝三者的核心区别是什么？

赋值只是让新变量指向同一个对象，没有任何复制；浅拷贝会创建一个新的最外层容器，但容器内部的可变子对象仍然是同一个引用，没有被复制；深拷贝会递归复制能访问到的所有层级，新旧对象从里到外完全独立，互不影响。

Q2：为什么浅拷贝之后，修改嵌套的可变对象会同时影响原对象？

因为浅拷贝只新建了最外层的容器对象，容器里存的还是原来那些子对象的引用，并没有为它们创建新副本。如果对某个内层可变子对象做原地修改（append、update、下标赋值等），两个外层容器实际上共享着同一个内层对象，所以两边都会看到修改结果。这和上一篇讲的默认参数陷阱是同一类问题的不同表现——本质都是"以为独立了，其实还共享着引用"。

Q3：copy.deepcopy 是怎么处理循环引用的，为什么不会死循环？

deepcopy 内部维护一个 memo 字典，记录"原对象的 id() → 已经拷贝出来的新对象"。每次准备递归拷贝一个对象前，会先查一下这个对象是不是已经在 memo 里出现过，如果出现过就直接复用那个已经生成的新对象，不会再重复递归下去，从而避免了自引用或相互引用导致的无限递归。

Q4：为什么一个全部由不可变元素组成的 tuple，深拷贝之后 is 判断反而是 True？

因为 deepcopy 会判断一个容器和它内部的元素是否全部不可变——如果确定不可变，那这个对象永远不可能被修改，复制它没有任何意义，deepcopy 会直接复用原对象来节省开销。但只要 tuple 内部混入了哪怕一个可变对象（比如 list），这个优化就不再成立，deepcopy 必须老老实实创建新的 tuple 并递归拷贝内部元素。这也提醒我们：容器本身不可变，不代表它装的东西也不可变。

下一篇预告

Day03 讲 *args 和 **kwargs——Python 灵活参数设计的核心机制，包括它们的底层类型、参数收集/解包的各种写法，以及和位置参数、关键字参数混用时的顺序规则。