「Python 进阶之路」系列 Day02
写在前面
上一篇讲了可变默认参数的坑，本质是"该新建对象却没新建，所有调用共享同一份数据"。今天这篇更进一步：就算你主动写了"拷贝"代码，如果没搞清楚拷贝的层级，一样会踩到几乎一模一样的坑。
最典型的场景：你想复制一份配置字典留着自己改，用了 config.copy()，结果改着改着发现，线上那份"原始配置"也被你悄悄改了。这不是 bug，是你对 copy() 到底复制了什么层级，理解错了。
一、是什么：赋值 vs 浅拷贝 vs 深拷贝
Python 里"复制一个对象"其实有三种完全不同的行为，很多人默认它们是一回事：
| 操作 | 复制了什么 | 典型写法 |
|---|---|---|
| 赋值 | 什么都没复制，只是给同一个对象多贴了一个标签 | b = a |
| 浅拷贝（Shallow Copy） | 只复制最外层容器，内部嵌套的可变对象仍然共享引用 | copy.copy(a)、a[:]、list(a)、a.copy() |
| 深拷贝（Deep Copy） | 递归复制所有能访问到的层级，新旧对象彻底独立 | copy.deepcopy(a) |
用一张图看三者在引用关系上的差异会更直观：
直接用 id() / is 实锤这三种关系：
python
import copy
a = [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() → 已经拷贝出来的新对象"，每次准备拷贝一个对象前先查这个字典，如果已经拷贝过就直接复用，不会重复递归：
python
a = [1, 2]
a.append(a) # 让 a 自己引用自己
b = copy.deepcopy(a)
print(b) # [1, 2, [...]] ------ 没有死循环，打印时用 [...] 表示自引用
print(b[2] is b) # True ------ b 内部的"自引用"被正确指向了新对象 b 自己三、怎么用：常见写法与最容易踩的坑
1. 这几种写法都是浅拷贝，效果完全等价
python
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. 浅拷贝的坑：原地修改嵌套对象会"牵一发动全身"
python
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]]但如果只是替换外层元素（重新赋值，不是原地修改），两边是互不影响的：
python
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. 深拷贝：彻底独立
python
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__：
python
class Person:
def __init__(self, name, pets):
self.name = name
self.pets = pets
p1 = 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 也是新的 list
p2.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 灵活参数设计的核心机制，包括它们的底层类型、参数收集/解包的各种写法，以及和位置参数、关键字参数混用时的顺序规则。