Python 中深拷贝和浅拷贝的区别

Python 中深拷贝（deep copy）和浅拷贝（shallow copy）的区别

在 Python 中，拷贝（复制对象） 主要分为 浅拷贝（shallow copy） 和 深拷贝（deep copy）。它们的区别在于是否递归复制嵌套对象。

1. 浅拷贝（Shallow Copy）

只复制对象本身，但不复制嵌套对象，嵌套对象仍然是原来的引用（即子对象未被复制）。
修改嵌套对象（如列表、字典）时，原对象和拷贝对象都会受到影响。

示例 1：浅拷贝

import copya = [1, 2, [3, 4]]
b = copy.copy(a)  # 浅拷贝print(a is b)      # False，不是同一个对象
print(a[2] is b[2])  # True，子对象引用相同# 修改嵌套列表
b[2].append(5)
print(a)  # [1, 2, [3, 4, 5]]，原列表也被修改
print(b)  # [1, 2, [3, 4, 5]]

结论：

copy.copy(a) 只复制了 a 本身，a[2] 仍然指向同一个列表，所以修改 b[2] 影响了 a[2]。

2. 深拷贝（Deep Copy）

递归复制对象，包括所有嵌套对象，创建全新的对象，二者完全独立。
修改拷贝后的对象不会影响原始对象。

示例 2：深拷贝

import copya = [1, 2, [3, 4]]
b = copy.deepcopy(a)  # 深拷贝print(a is b)      # False，不是同一个对象
print(a[2] is b[2])  # False，子对象也被复制了# 修改嵌套列表
b[2].append(5)
print(a)  # [1, 2, [3, 4]]，原列表不受影响
print(b)  # [1, 2, [3, 4, 5]]

结论：

copy.deepcopy(a) 复制了 a 及其嵌套对象，所以 b[2] 和 a[2] 是不同的对象，修改 b 不会影响 a。

3. 适用场景

类型	作用	影响
浅拷贝	复制对象，但共享嵌套对象	修改嵌套对象会影响原对象
深拷贝	递归复制所有对象	修改拷贝对象不会影响原对象

选择哪种拷贝？

浅拷贝：适用于数据结构简单，不包含嵌套对象的情况，或不需要修改嵌套对象。
深拷贝：适用于数据结构复杂（如多层嵌套列表、字典等），需要完全独立的副本。

4. 浅拷贝的其他方式

除了 copy.copy()，以下方式也会创建浅拷贝：

a = [1, 2, [3, 4]]b = a[:]         # 切片
c = list(a)      # list() 构造函数
d = a.copy()     # 列表的 copy() 方法print(b is a)    # False
print(c is a)    # False
print(d is a)    # False
print(b[2] is a[2])  # True，嵌套对象仍然共享

5. 深拷贝 vs. 浅拷贝在字典中的表现

import copya = {"x": 1, "y": [2, 3]}
b = copy.copy(a)   # 浅拷贝
c = copy.deepcopy(a)  # 深拷贝b["y"].append(4)  # 修改嵌套列表
print(a)  # {'x': 1, 'y': [2, 3, 4]}，原对象受到影响
print(c)  # {'x': 1, 'y': [2, 3]}，深拷贝不受影响

结论：

copy.copy(a) 共享 a["y"] 的引用，修改 b["y"] 影响 a["y"]。
copy.deepcopy(a) 复制了 a["y"]，所以 c["y"] 是新的对象，不受影响。

6. 深拷贝和浅拷贝的性能

深拷贝更耗时，因为它需要递归复制所有对象。
浅拷贝更快，因为它只复制顶层对象，而不会递归。

示例 6：性能对比

import copy
import timea = [list(range(10000)) for _ in range(100)]  # 100 个长度 10000 的列表start = time.time()
b = copy.copy(a)
end = time.time()
print(f"浅拷贝耗时: {end - start:.5f} 秒")start = time.time()
c = copy.deepcopy(a)
end = time.time()
print(f"深拷贝耗时: {end - start:.5f} 秒")

结果（大致）：

浅拷贝耗时: 0.00001 秒
深拷贝耗时: 0.02345 秒

深拷贝比浅拷贝慢很多，因为它需要复制所有嵌套对象。

7. 特殊情况：不可变对象

不可变对象（如 int、float、str、tuple）的拷贝其实无意义，因为它们不会被修改，拷贝只是返回原对象的引用。

a = (1, 2, (3, 4))  # 元组中的嵌套元组也是不可变的
b = copy.copy(a)
c = copy.deepcopy(a)print(a is b)  # True
print(a is c)  # True

结论：

对于不可变对象，无论是浅拷贝还是深拷贝，都是同一个对象。

但如果元组包含可变对象，深拷贝仍然有效：

a = (1, 2, [3, 4])
b = copy.deepcopy(a)b[2].append(5)
print(a)  # (1, 2, [3, 4])，未受影响
print(b)  # (1, 2, [3, 4, 5])

说明：

a[2] 是可变对象，深拷贝创建了新的 b[2]，修改 b 不会影响 a。

8. 结论

拷贝类型	作用	影响	适用场景
浅拷贝	复制对象本身，但嵌套对象仍指向原对象	修改嵌套对象会影响原对象	适用于不修改嵌套对象的情况
深拷贝	递归复制所有对象，包括嵌套对象	修改拷贝不会影响原对象	适用于数据结构复杂、需完全独立的副本