copy.deepcopy() 效率不高，尤其是在处理大型或复杂对象时，它是一个“重量级”的操作，应该谨慎使用。
下面我们从几个方面来深入分析：
为什么 deepcopy 效率低？
deepcopy 的低效源于其实现机制，为了创建一个对象的完整独立副本，它必须执行以下步骤：
-
内存消耗高：
deepcopy会递归地遍历原始对象及其所有嵌套的对象，对于每个对象，它都会在内存中创建一个全新的副本，如果对象非常庞大（包含一个巨大的列表或字典），deepcopy需要分配两倍（甚至更多，取决于引用结构）的内存来存放原始对象和副本，这可能导致内存消耗急剧增加，甚至引发MemoryError。 -
CPU 计算密集：递归遍历和对象创建本身是计算密集型的，Python 需要检查每个对象的类型，然后调用相应的构造函数来创建新实例，对于自定义类，它会尝试复制其
__dict__属性，并递归地处理其中的所有值，这个过程非常耗时，特别是当对象层级很深时。 -
循环引用的处理：这是
deepcopy最复杂也最耗费性能的地方，Python 对象之间可能存在循环引用（A 指向 B，B 又指向 A）。deepcopy不加处理，它会陷入无限递归，为了解决这个问题，deepcopy内部维护了一个“备忘录”（memo）字典，用于记录已经复制过的对象，在复制新对象前，它会先检查这个备忘录，如果对象已经存在，就直接返回已创建的副本，从而打破循环，这个查找和记录的过程增加了额外的开销。
deepcopy vs. copy.copy (浅拷贝)
为了更好地理解 deepcopy 的效率，我们将其与浅拷贝 copy.copy() 进行对比。
| 特性 | copy.copy() (浅拷贝) |
copy.deepcopy() (深拷贝) |
|---|---|---|
| 拷贝层级 | 只拷贝最外层对象。 | 递归地拷贝对象及其所有嵌套的对象。 |
| 对可变对象的影响 | 创建一个新的容器对象（如列表、字典），但容器中的元素仍然是原始对象的引用。 | 创建一个新的容器对象，以及容器中所有元素的独立副本。 |
| 不可变对象 | 通常不进行拷贝，直接返回原对象的引用（因为没必要）。 | 通常不进行拷贝，直接返回原对象的引用（因为没必要）。 |
| 效率 | 非常高，速度极快，内存开销小。 | 非常低，速度慢，内存开销大。 |
| 适用场景 | 当你只需要一个新容器，但容器中的内容是不可变的（如数字、字符串、元组），或者你不介意共享内部可变对象时。 | 当你需要一个完全独立的副本，并且绝对不希望新对象与原对象共享任何可变子对象时。 |
示例代码：
import copy
# 原始列表，包含一个可变对象（字典）
original_list = [1, 2, {'a': 10, 'b': 20}]
# 浅拷贝
shallow_copied_list = copy.copy(original_list)
# 深拷贝
deep_copied_list = copy.deepcopy(original_list)
# 修改浅拷贝中的可变对象
shallow_copied_list[2]['a'] = 100
# 修改深拷贝中的可变对象
deep_copied_list[2]['b'] = 200
print("Original List:", original_list)
# 输出: Original List: [1, 2, {'a': 100, 'b': 20}]
# 浅拷贝修改了字典，因为它们共享同一个字典对象。
print("Shallow Copied List:", shallow_copied_list)
# 输出: Shallow Copied List: [1, 2, {'a': 100, 'b': 200}]
print("Deep Copied List:", deep_copied_list)
# 输出: Deep Copied List: [1, 2, {'a': 10, 'b': 200}]
# 深拷贝的修改不会影响原始列表，因为它的字典是独立的副本。
如何提高效率，避免使用 deepcopy？
在性能敏感的代码中,应尽量避免使用 deepcopy，以下是一些替代方案和优化策略：
使用 copy.copy + 手动拷贝（最常用）
如果对象结构不复杂,可以只对顶层进行浅拷贝，然后手动对需要独立的子对象进行深拷贝。
import copy
original_list = [1, 2, {'a': 10, 'b': 20}]
# 只拷贝列表本身，然后手动拷贝字典
new_list = copy.copy(original_list)
new_list[2] = copy.copy(original_list[2]) # 或者 original_list[2].copy()
new_list[2]['a'] = 100
print("Original List:", original_list)
# 输出: Original List: [1, 2, {'a': 10, 'b': 20}] # 原始数据未受影响
利用序列化和反序列化（如 pickle 或 json）
这是一种“曲线救国”的方法，通过将对象转换为字节流（序列化），然后再从字节流重建对象（反序列化）来获得一个深拷贝。
pickle：功能强大，可以处理几乎所有 Python 对象（包括自定义类实例），但可能存在安全风险（不要处理不可信的数据）。json：更安全、更通用，但只能处理基本数据类型（dict, list, str, int, float, bool, None），不能处理自定义类实例。
import pickle
class MyClass:
def __init__(self, value):
self.value = value
obj = MyClass([1, 2, 3])
# 使用 pickle 进行深拷贝
pickled_obj = pickle.dumps(obj)
deep_copied_obj = pickle.loads(pickled_obj)
deep_copied_obj.value.append(4)
print("Original object value:", obj.value)
# 输出: Original object value: [1, 2, 3]
print("Deep copied object value:", deep_copied_obj.value)
# 输出: Deep copied object value: [1, 2, 3, 4]
注意：pickle 的效率通常比 copy.deepcopy 更低，因为它涉及到更底层的序列化和 I/O 操作，它通常只在需要跨进程/网络传输对象或 deepcopy 无法处理某些特殊情况时使用。
使用第三方库（如 copyreg 或 dill）
copyreg：标准库模块，可以注册自定义类型的拷贝/pickle 行为，通过为你的类实现高效的__getnewargs_ex__或__reduce__方法，可以显著提升copy.deepcopy的性能，这需要你对类的实现进行修改。dill：一个强大的第三方库，是pickle的超集，能处理更多类型的对象，并且在某些情况下性能优于pickle。
重构代码，避免不必要的深拷贝
这是最根本、最有效的优化方法，问自己：
- 我真的需要一个完整的深拷贝吗？ 很多时候，浅拷贝就足够了。
- 我能否通过传递不可变对象来避免共享状态？ 使用元组代替列表，或者使用
frozenset代替set。 - 我能否改变数据结构，使其更容易复制？ 使用扁平化的数据结构代替复杂的嵌套结构。
总结与建议
| 方法 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|
copy.deepcopy |
简单、通用，能处理所有情况 | 效率低，内存消耗大，可能循环引用 | 快速原型、代码简单、对性能要求不高的场合 |
copy.copy + 手动 |
效率高，内存占用可控 | 需要手动操作，代码稍显繁琐 | 结构不复杂，需要精细控制拷贝层级的场合 |
pickle.loads(pickle.dumps()) |
通用，能处理复杂对象 | 效率极低，有安全风险 | 需要跨进程/网络，或 deepcopy 失败的场合 |
| 重构代码 | 从根本上解决问题，效率最高 | 需要重新设计数据结构和逻辑 | 对性能有极致要求，且可以掌控代码架构的场合 |
核心建议：
- 优先使用浅拷贝 (
copy.copy)：在绝大多数情况下，浅拷贝已经足够。 - 按需深拷贝：只在绝对需要隔离所有可变状态时才使用
deepcopy。 - 避免在性能热点使用：绝不要在循环、高频调用的函数或处理大数据时使用
deepcopy。 - 考虑替代方案：
deepcopy成为性能瓶颈，尝试手动拷贝、pickle或重构代码来解决问题。
