Python的浅拷贝把我坑惨了，原来copy()和deepcopy()的区别这么大

一个让我加了两天班的Bug

去年我接手了一个用户权限管理模块。每个用户登录时，系统会基于一个“默认权限模板”生成一份独立的权限配置。

代码大概长这样：

default_permission = {
    "admin": False,
    "modules": ["dashboard", "profile"],
    "settings": {"theme": "light", "notifications": True}
}

def create_user_permission(username):
    user_perm = default_permission.copy()
    user_perm["username"] = username
    return user_perm

alice = create_user_permission("alice")
bob = create_user_permission("bob")

逻辑看起来没问题，对吧？default_permission.copy()复制了一份，Alice和Bob各用各的。

直到测试同事跑来告诉我：“我给Alice关了通知提醒，Bob的通知提醒也跟着关了！”

我一脸懵：“怎么可能？Alice和Bob是两份独立的权限配置啊！”

查了半天才发现问题出在这行代码上：default_permission.copy()。

这个copy()，只复制了最外面那层字典。里面的settings字典还是同一个——Alice和Bob的settings指向的是同一块内存地址。我改了Alice的settings，Bob的settings也跟着变了。

那天下午，我把Python拷贝的三种方式彻底研究了一遍。今天把这些坑讲清楚，希望你别重蹈我的覆辙。

第一步：赋值不是拷贝

很多人搞不清楚“赋值”和“拷贝”的区别。

a = [1, 2, [3, 4]]
b = a          # 这不是拷贝，是贴标签
b.append(5)
print(a)       # [1, 2, [3, 4], 5] —— a也跟着变了

在Python里，b = a不是复制，而是把标签b也贴到a指向的那个对象上。a和b指向同一个对象，改b就是改a。

你可以用id()验证一下：

print(id(a))  # 比如 140234567890
print(id(b))  # 同样是 140234567890

两个变量指向同一个内存地址，本质上就是一个东西。

要得到一份“独立”的副本，需要用到拷贝操作——copy()或copy.deepcopy()。但要注意：不是所有拷贝都能得到完全独立的对象。

第二步：浅拷贝——只复制第一层

Python里的“拷贝”分两种：浅拷贝和深拷贝。

import copy

original = [[1, 2], [3, 4]]
shallow = original.copy()        # 浅拷贝
# 或者 shallow = copy.copy(original)

copy()只复制了最外面那层容器，里面的元素还是原来那些对象的引用。

画个图理解一下：

• original指向一个列表对象A
• shallow指向一个新列表对象B
• B里的两个元素，指向的依然是A里的那两个子列表

所以当你修改B的外层结构（比如shallow.append(5)），A不受影响。但当你修改B里的内层列表（比如shallow[0].append(99)），A里对应的内层列表也会变，因为它们是同一个对象。

original = [[1, 2], [3, 4]]
shallow = original.copy()

shallow[0].append(99)
print(original[0])  # [1, 2, 99] —— 原件被改了！
print(shallow[0])   # [1, 2, 99]

这就是我那个权限系统翻车的原因——default_permission.copy()只复制了最外层字典，里面的settings字典还是同一个。

default = {"settings": {"theme": "light"}}
copy = default.copy()
copy["settings"]["theme"] = "dark"
print(default["settings"]["theme"])  # "dark" —— 原件被改了！

浅拷贝和深拷贝的区别，只与复合对象有关——也就是包含其他对象的对象，比如列表、字典、类的实例。对于数字、字符串这类“原子”类型，没有拷贝一说，产生的都是原对象的引用。

第三步：深拷贝——彻底独立

深拷贝会递归地复制对象里的所有层级，每一层都是全新的独立对象。

import copy

original = [[1, 2], [3, 4]]
deep = copy.deepcopy(original)

deep[0].append(99)
print(original[0])  # [1, 2] —— 不受影响
print(deep[0])      # [1, 2, 99]

深拷贝的规则是：遇到一个对象就复制一个，遇到嵌套的对象就继续递归复制，直到所有东西都是全新的。

官方文档的解释更精准：浅拷贝构造一个新的复合对象，然后把原始对象中找到的对象的引用插进去；深拷贝构造一个新的复合对象，然后递归地把原始对象里找到的对象的副本插进去。

用我那个权限系统的例子：

import copy

default_permission = {
    "admin": False,
    "settings": {"theme": "light", "notifications": True}
}

# 用深拷贝代替浅拷贝
user_perm = copy.deepcopy(default_permission)
user_perm["settings"]["notifications"] = False

print(default_permission["settings"]["notifications"])  # True —— 不受影响

深拷贝出来的对象就是完完全全的新对象，不管是对象本身还是对象中包含的子对象，都和原始对象不一样。浅拷贝出来的对象则是“外新内旧”——对象本身是新的，但子对象还是原来的。

第四步：什么时候用哪个？

用浅拷贝的场景：

• 数据结构是单层的（没有嵌套），比如[1, 2, 3]
• 你明确知道嵌套对象不需要独立，共享反而更好
• 对性能敏感，浅拷贝比深拷贝快得多

用深拷贝的场景：

• 数据结构有嵌套（列表套列表、字典套字典）
• 你需要在副本上修改嵌套对象，但不想影响原始数据
• 多线程环境下传递数据，需要确保线程间数据隔离
• 用户配置、订单数据、模板生成这类场景

性能方面要注意： 深拷贝比浅拷贝慢得多。有测试显示，深拷贝比浅拷贝慢约15倍。对于深层嵌套的结构，甚至可能慢100倍。所以别盲目用深拷贝，该用浅拷贝的时候就用浅拷贝。

第五步：还有几个坑

坑一：循环引用

如果对象自己引用自己，深拷贝可能会出问题：

a = []
a.append(a)  # 自己引用自己
# copy.deepcopy(a)  # 可能报 RecursionError

不过Python的deepcopy()内部用了memo字典来记录已复制的对象，能处理大部分循环引用的情况。

坑二：不可变对象

对于不可变对象（数字、字符串、元组），浅拷贝和深拷贝没啥区别：

a = 5
b = copy.copy(a)
c = copy.deepcopy(a)
# b和c就是5，跟a没关系

坑三：自定义对象

如果你的类里有嵌套结构，记得实现__copy__和__deepcopy__方法来控制拷贝行为。

总结

一句话记住区别：浅拷贝只复制表面，里面的东西还是共享的；深拷贝从头到尾全部复制，完全独立。

用我翻车的那个权限系统打个比方：

• 赋值（b = a） ：给同一本书贴两个标签，撕掉一个另一个还在
• 浅拷贝（copy()） ：复印了书的封面，但里面的每一页还是原来那本
• 深拷贝（deepcopy()） ：把整本书从头到尾复印了一遍，崭新的一本

现在我写代码但凡遇到嵌套数据结构要复制，都会停下来想一想：我到底要的是“复印封面”还是“复印全书”？想清楚再动手，少加两天班。