引言： 在 Python 编程中，赋值、浅拷贝、深拷贝是处理数据复制时的核心操作 ------ 很多新手会因混淆三者的区别，导致数据被意外修改，引发难以排查的 bug。本文聚焦深浅拷贝这一核心知识点，从底层原理、使用场景到实战避坑，带你彻底掌握不同拷贝方式的本质，精准控制数据的复制逻辑。
一、深浅拷贝的核心背景：Python 的对象引用机制
要理解深浅拷贝，首先要明确 Python 的核心规则：变量存储的不是数据本身，而是数据对象的引用（内存地址） 。
- 不可变对象（int、str、tuple）：修改时会创建新对象，原引用指向新地址；
- 可变对象（list、dict、set）：修改时不会创建新对象，而是直接修改原地址的数据，所有指向该地址的变量都会受影响。
python
# 示例：可变对象的引用特性
a = [1, 2, 3]
b = a # 赋值：b和a指向同一个列表对象
b.append(4)
print(a) # 输出：[1,2,3,4]（a也被修改）
print(id(a) == id(b)) # 输出：True（内存地址相同）赋值仅传递引用，而非复制数据 ------ 这也是深浅拷贝存在的核心原因：当需要 "真正复制" 数据，而非共享引用时，就需要用到拷贝操作。
二、浅拷贝（Shallow Copy）：仅复制表层结构
1. 浅拷贝的定义
浅拷贝会创建一个新的容器对象，但容器内的元素依然引用原对象的元素（即只拷贝 "第一层"，深层元素仍共享引用）。
2. 浅拷贝的实现方式
python
import copy
# 原数据：嵌套可变对象（列表包含列表）
original = [1, [2, 3], 4]
# 方式1：使用copy模块的copy()函数（推荐）
shallow1 = copy.copy(original)
# 方式2：列表切片（仅适用于序列类型）
shallow2 = original[:]
# 方式3：对象的copy方法（如list.copy()）
shallow3 = original.copy()
# 验证：新对象与原对象地址不同（表层已拷贝）
print(id(original) != id(shallow1)) # 输出：True
# 验证：深层元素仍共享引用
shallow1[1].append(5)
print(original[1]) # 输出：[2,3,5]（原数据的深层列表被修改）
print(shallow1[1] == original[1]) # 输出：True（地址相同）3. 浅拷贝的适用场景
- 数据为单层结构 的可变对象（如
[1,2,3]、{"a":1}）； - 无需修改深层元素，仅需独立操作表层结构的场景；
- 追求拷贝效率（浅拷贝比深拷贝更快，占用内存更少）。
三、深拷贝（Deep Copy）：完全复制所有层级
1. 深拷贝的定义
深拷贝会创建一个全新的独立对象，递归复制原对象的所有层级元素 ------ 新对象与原对象完全隔离，修改任意层级的元素都不会影响对方。
2. 深拷贝的实现方式
python
import copy
# 原数据：嵌套可变对象
original = [1, [2, 3], 4]
# 使用copy模块的deepcopy()函数
deep = copy.deepcopy(original)
# 验证：新对象与原对象地址不同
print(id(original) != id(deep)) # 输出：True
# 验证：深层元素也完全独立
deep[1].append(5)
print(original[1]) # 输出：[2,3]（原数据不受影响）
print(deep[1]) # 输出：[2,3,5]（仅深拷贝对象被修改）
print(id(original[1]) != id(deep[1])) # 输出：True（深层地址不同）3. 深拷贝的适用场景
- 数据包含嵌套可变对象 （如
[[1,2], [3,4]]、{"info": {"age": 20}}）； - 需要完全独立操作数据，避免修改相互影响的场景；
- 数据持久化、数据备份等需要 "纯净副本" 的场景。
四、赋值、浅拷贝、深拷贝对比
为了更清晰区分三者，我们用表格总结核心差异：
| 操作方式 | 是否创建新对象 | 表层元素是否独立 | 深层元素是否独立 | 适用场景 |
|---|---|---|---|---|
| 赋值 | ❌ 否 | ❌ 共享 | ❌ 共享 | 仅需引用数据，无需独立操作 |
| 浅拷贝 | ✅ 是 | ✅ 独立 | ❌ 共享 | 单层可变对象、追求拷贝效率 |
| 深拷贝 | ✅ 是 | ✅ 独立 | ✅ 独立 | 嵌套可变对象、需完全隔离数据 |
实战对比示例
python
import copy
# 原数据
data = {"name": "Alice", "scores": [80, 90]}
# 1. 赋值
assign = data
assign["scores"].append(95)
print(data["scores"]) # [80,90,95]（原数据被改）
# 重置原数据
data = {"name": "Alice", "scores": [80, 90]}
# 2. 浅拷贝
shallow = copy.copy(data)
shallow["scores"].append(95)
print(data["scores"]) # [80,90,95]（深层仍被改）
shallow["name"] = "Bob"
print(data["name"]) # Alice（表层独立）
# 重置原数据
data = {"name": "Alice", "scores": [80, 90]}
# 3. 深拷贝
deep = copy.deepcopy(data)
deep["scores"].append(95)
deep["name"] = "Bob"
print(data["scores"]) # [80,90]（完全不受影响）
print(data["name"]) # Alice五、深浅拷贝的避坑要点
1. 不可变对象的拷贝 "特例"
对不可变对象（int、str、tuple）执行深浅拷贝，结果等同于赋值 ------ 因为不可变对象无法修改，Python 会优化为共享引用，避免不必要的内存消耗：
python
import copy
a = (1, 2, 3) # 不可变元组
b = copy.copy(a)
c = copy.deepcopy(a)
print(id(a) == id(b) == id(c)) # 输出：True2. 循环引用的处理
深拷贝能自动处理循环引用（对象引用自身），而浅拷贝会保留循环引用，可能导致内存泄漏：
python
import copy
# 循环引用：列表引用自身
lst = [1, 2]
lst.append(lst)
# 深拷贝：正确处理循环引用
deep_lst = copy.deepcopy(lst)
print(deep_lst[-1] is deep_lst) # 输出：True（新的循环引用）
# 浅拷贝：保留原循环引用
shallow_lst = copy.copy(lst)
print(shallow_lst[-1] is lst) # 输出：True（引用原列表）3. 自定义对象的拷贝
自定义类的实例默认使用浅拷贝，若需深拷贝，需重写 __deepcopy__ 方法：
python
import copy
class Person:
def __init__(self, name, hobbies):
self.name = name
self.hobbies = hobbies # 可变对象（列表）
# 自定义对象的浅拷贝
p1 = Person("Alice", ["reading", "running"])
p2 = copy.copy(p1)
p2.hobbies.append("swimming")
print(p1.hobbies) # ['reading', 'running', 'swimming']（被修改）
# 自定义对象的深拷贝
p3 = copy.deepcopy(p1)
p3.hobbies.append("cooking")
print(p1.hobbies) # ['reading', 'running', 'swimming']（不受影响）总结
- Python 中变量存储的是对象引用，赋值仅传递引用，不会创建新对象；
- 浅拷贝（
copy.copy()）创建新的表层对象，深层元素仍共享引用，适用于单层可变对象； - 深拷贝（
copy.deepcopy()）递归复制所有层级元素，新对象与原对象完全隔离，适用于嵌套可变对象； - 不可变对象的深浅拷贝等同于赋值，深拷贝可处理循环引用，是数据完全隔离的首选方式