Python的copy.deepcopy()函数在处理循环引用时通过内部的备忘录memo字典机制来打破无限递归确保复制过程能够正确终止。这个memo字典本身的设计就考虑了内存管理的安全性在正常情况下不会导致内存泄漏。其核心机制是备忘录字典的生命周期与单次深复制调用绑定在复制完成后该字典会被自动回收。一、memo字典的生命周期与作用域管理deepcopy()函数将memo字典作为参数在其内部递归调用链中传递。该字典仅在单次深复制操作期间存在操作结束后由于没有外部引用指向它它会被Python的垃圾回收器正常回收。import copy import sys def track_memory(obj_name, obj): 追踪对象引用计数和内存地址 print(f{obj_name}: id{id(obj):#x}, refcount{sys.getrefcount(obj)-1}) # 示例观察单次深复制过程中的memo original_list [1, 2, 3] original_list.append(original_list) # 创建对自己的循环引用 print(开始深复制过程追踪...) # 模拟一次深复制调用 result copy.deepcopy(original_list) # 深复制完成后尝试访问内部的memo是不可能的因为它是一个局部变量 # 以下代码会引发AttributeError证明memo已不可访问 try: # 尝试访问不存在的属性说明memo已随函数调用结束而销毁 _ result.__memo__ except AttributeError: print(深复制完成后内部的memo字典已不可访问说明其生命周期已结束。) # 验证复制结果保持了循环引用结构 print(f原对象自我引用: {original_list[-1] is original_list}) # True print(f副本对象自我引用: {result[-1] is result}) # True二、memo字典的键值设计弱引用与ID映射备忘录字典使用对象的id()即内存地址作为键而非对象本身。这避免了因将对象本身作为键而意外增加其引用计数。值则是该对象对应的副本。这种id-副本的映射关系是临时的且键整数id和值新创建的副本在复制结束后只要没有外部引用都会被妥善清理。import copy import gc class DataNode: def __init__(self, value): self.value value self.ref None # 创建循环引用 node1 DataNode(Node1) node2 DataNode(Node2) node1.ref node2 node2.ref node1 # 形成双向循环引用 print(深复制前对象状态:) print(fnode1 id: {id(node1):#x}, refcount: {sys.getrefcount(node1)-1}) print(fnode2 id: {id(node2):#x}, refcount: {sys.getrefcount(node2)-1}) # 执行深复制 copied_node copy.deepcopy(node1) print( 深复制后对象状态:) print(f原node1 id: {id(node1):#x}, refcount: {sys.getrefcount(node1)-1}) print(f原node2 id: {id(node2):#x}, refcount: {sys.getrefcount(node2)-1}) print(f副本node id: {id(copied_node):#x}) # 强制垃圾回收观察对象是否被正确清理模拟memo字典释放后的场景 print( 执行垃圾回收...) collected gc.collect() print(f回收的垃圾对象数量: {collected}) # 验证原对象和副本的独立性 print(f 原对象循环引用保持: {node1.ref.ref is node1}) # True print(f副本对象循环引用保持: {copied_node.ref.ref is copied_node}) # True print(f原对象与副本不同: {copied_node is not node1}) # True三、递归复制流程与memo的更新机制在递归复制过程中算法遵循“先注册后填充”的策略这是避免无限递归和正确处理循环引用的关键。遇到新对象将其id和新创建的空壳副本存入memo。递归填充属性再逐步递归地复制该对象的内部数据到空壳副本中。遇到已记录对象直接从memo中返回已创建的副本。这个流程确保了即使在复制对象的属性时又引回了对象自身也能通过查表找到“半成品”副本并返回从而打破循环链。import copy class TreeNode: def __init__(self, name): self.name name self.children [] self.parent None # 指向父节点的引用容易形成循环 def add_child(self, child): self.children.append(child) child.parent self # 构建一个树形结构子节点通过parent指回根节点形成循环 root TreeNode(root) child1 TreeNode(child1) child2 TreeNode(child2) root.add_child(child1) root.add_child(child2) # 此时结构为root - child1, root - child2 (通过parent指针) print(开始深复制树结构...) copied_tree copy.deepcopy(root) print(f原根节点: {root.name}, 父节点: {root.parent}) # None print(f原子节点child1的父节点: {child1.parent.name if child1.parent else None}) # root print(f副本根节点: {copied_tree.name}, 父节点: {copied_tree.parent}) # None print(f副本子节点child1的父节点: {copied_tree.children[0].parent.name if copied_tree.children[0].parent else None}) # root (副本) # 验证循环引用被正确复制且无泄漏 print(f 验证独立性:) print(f原root is 副本root? {root is copied_tree}) # False print(f原child1 is 副本child1? {child1 is copied_tree.children[0]}) # False print(f副本中child1的父节点是副本root? {copied_tree.children[0].parent is copied_tree}) # True四、与Python垃圾回收机制的协同Python的垃圾回收主要基于引用计数并辅以分代回收来处理循环引用。deepcopy的memo机制与GC协同工作引用计数memo字典对键id和值副本的持有是短暂的。复制完成后如果用户没有保存对副本的引用副本的引用计数会降为0并被立即销毁。memo字典本身的引用计数在deepcopy函数返回后也降为0。分代回收对于更复杂的循环引用例如副本对象之间因复制逻辑又形成了新的循环即使引用计数不为0分代垃圾回收器也能识别并回收这些不可达的循环引用组。memo字典本身如果因为某些极端情况如自定义__deepcopy__错误地持有了它的引用而未能释放也会被分代回收器处理。import copy import gc import weakref def check_memo_leak_simulation(): 模拟并检查在一次深复制后相关对象是否被正确释放 class ComplexCyclic: def __init__(self, tag): self.tag tag self.link None # 创建一个小型循环引用对象图 obj_a ComplexCyclic(A) obj_b ComplexCyclic(B) obj_c ComplexCyclic(C) obj_a.link obj_b obj_b.link obj_c obj_c.link obj_a # A-B-C-A 循环 # 使用弱引用来追踪原对象确保不影响其引用计数 weak_ref_to_a weakref.ref(obj_a) weak_ref_to_b weakref.ref(obj_b) weak_ref_to_c weakref.ref(obj_c) print(深复制前原对象通过弱引用可访问:) print(f obj_a: {weak_ref_to_a() is not None}) print(f obj_b: {weak_ref_to_b() is not None}) print(f obj_c: {weak_ref_to_c() is not None}) # 执行深复制 copied copy.deepcopy(obj_a) # 删除对原对象的所有强引用 del obj_a, obj_b, obj_c # 强制垃圾回收 gc.collect() print( 删除强引用并GC后原对象状态:) print(f obj_a: {weak_ref_to_a() is not None}) # 应变为False print(f obj_b: {weak_ref_to_b() is not None}) # 应变为False print(f obj_c: {weak_ref_to_c() is not None}) # 应变为False # 检查副本的循环结构是否完整 print(f 副本循环结构完整性检查:) print(f copied.tag {copied.tag}) print(f copied.link.tag {copied.link.tag}) print(f copied.link.link.tag {copied.link.link.tag}) print(f copied.link.link.link is copied? {copied.link.link.link is copied}) # 应为True check_memo_leak_simulation()五、潜在风险与最佳实践尽管copy.deepcopy()内部的memo机制本身是安全的但在自定义__deepcopy__()方法时如果实现不当可能会引入内存泄漏风险。风险场景错误示例正确做法在__deepcopy__外保存memo引用将memo赋值给实例属性或全局变量memo只作为参数使用不长期保存未调用父类或默认复制逻辑自定义方法中遗漏了对部分属性的深复制使用copy.deepcopy(obj, memo)处理属性创建不必要的强引用在副本中错误地引用原对象或memo确保副本仅引用其他副本或新对象安全实现__deepcopy__的模板import copy class SafeCustomClass: def __init__(self, data, childrenNone): self.data data self.children children if children is not None else [] self._transient_cache {} # 临时缓存不应复制 def __deepcopy__(self, memo): # 1. 检查备忘录避免重复复制和无限递归 obj_id id(self) if obj_id in memo: return memo[obj_id] # 2. 创建新实例的“空壳”并立即注册到memo中 # 这是处理循环引用的关键步骤 new_obj self.__class__(self.data) memo[obj_id] new_obj # 3. 递归地深复制所有需要复制的属性 # 注意跳过不应复制的属性如_transient_cache new_obj.children [copy.deepcopy(child, memo) for child in self.children] # 4. 返回构建好的副本 return new_obj # 使用示例 obj SafeCustomClass(root, [SafeCustomClass(child)]) obj.children[0].children.append(obj) # 创建循环引用 copied copy.deepcopy(obj) print(f循环引用保持: {copied.children[0].children[0] is copied}) # True print(f临时缓存未被复制: {not hasattr(copied, _transient_cache) or copied._transient_cache {}}) # 应为True结论Python标准库中copy.deepcopy()函数使用的memo字典机制是内存安全的。其设计保证了字典本身仅在单次复制操作的生命周期内存在通过以对象ID为键、避免增加原对象引用计数并在操作结束后及时释放有效避免了内存泄漏。对于开发者而言主要风险来自于错误地实现自定义类的__deepcopy__方法。遵循“先注册空壳再递归填充”的模式并确保不长期持有对memo的引用即可安全地处理包含循环引用的复杂对象的深复制。参考来源《流畅的Python》读书笔记07: 第一部分 数据结构 - 对象引用、可变性和垃圾回收