深度拷贝通过copy.deepcopy()递归复制对象及其所有嵌套对象，确保新旧对象完全独立；浅拷贝通过copy.copy()或切片仅复制对象本身和直接引用，共享嵌套的可变对象。选择深拷贝可避免修改副本影响原始数据，尤其在处理复杂结构、循环引用或需数据隔离时至关重要；浅拷贝适用于性能敏感且无需修改嵌套对象的场景。自定义类可通过__copy__和__deepcopy__方法控制拷贝行为。
在Python中，深度拷贝一个对象意味着创建一个全新的对象，并且递归地复制其内部所有嵌套的、可变的对象，确保新对象与原对象完全独立。而浅拷贝则只复制对象本身及其直接包含的引用，如果原对象包含可变嵌套对象，那么新旧对象会共享这些嵌套对象，导致修改其中一个会影响另一个。实现深度拷贝主要通过Python标准库
copy
模块中的
copy.deepcopy()
函数。
解决方案
理解Python中对象的复制行为，是避免在数据操作中踩坑的关键一步。我们通常说的“复制”，在Python里其实分为“浅拷贝”和“深拷贝”两种模式，它们处理嵌套对象的方式大相径庭。
浅拷贝（Shallow Copy）
当你使用
copy.copy()
函数或者通过切片操作（如
list[:]
）进行拷贝时，你得到的是一个浅拷贝。浅拷贝会创建一个新的复合对象，但它并不会递归地复制所有嵌套对象。相反，它会插入对原始对象中找到的子对象的引用。这意味着，如果你的原始对象中包含了可变的子对象（比如列表中的列表，或者字典中的列表），那么浅拷贝后的新对象和原始对象会共享这些子对象。一旦你修改了其中一个的子对象，另一个也会受到影响。
立即学习“Python免费学习笔记（深入）”；
举个例子，想象你有一个购物清单，里面有几类商品。如果你浅拷贝了这个清单，并修改了其中一类商品的内容，那么原清单里的这部分内容也会变。这就像你复印了一份文件，但文件里有个链接，你点开链接修改了内容，那么原文件里的链接指向的内容也变了。
import copy# 示例1：列表的浅拷贝original_list = [1, [2, 3], 4]shallow_copied_list = copy.copy(original_list)print(f"Original List: {original_list}, ID: {id(original_list)}")print(f"Shallow Copied List: {shallow_copied_list}, ID: {id(shallow_copied_list)}")print(f"ID of original_list[1]: {id(original_list[1])}")print(f"ID of shallow_copied_list[1]: {id(shallow_copied_list[1])}")# 修改浅拷贝列表中的嵌套可变对象shallow_copied_list[1].append(5)print(f"nAfter modifying shallow_copied_list[1]:")print(f"Original List: {original_list}") # 原始列表的嵌套列表也变了print(f"Shallow Copied List: {shallow_copied_list}")# 示例2：字典的浅拷贝original_dict = {'a': 1, 'b': [2, 3]}shallow_copied_dict = copy.copy(original_dict)print(f"nOriginal Dict: {original_dict}")print(f"Shallow Copied Dict: {shallow_copied_dict}")shallow_copied_dict['b'].append(4)print(f"nAfter modifying shallow_copied_dict['b']:")print(f"Original Dict: {original_dict}") # 原始字典的嵌套列表也变了print(f"Shallow Copied Dict: {shallow_copied_dict}")
深拷贝（Deep Copy）
而深拷贝，通过
copy.deepcopy()
函数实现，则完全是另一回事。它会创建一个全新的复合对象，并且会递归地复制原始对象中所有找到的子对象。这意味着，无论原始对象有多么复杂的嵌套结构，深拷贝都会确保所有层级的对象都被独立地复制出来。新对象与原对象之间没有任何共享的引用，它们是彻彻底底的独立个体。
继续用购物清单的比喻，深拷贝就像你把整份清单，包括清单里的所有商品描述、图片、价格，都重新手写了一遍，并且把所有引用的图片也重新画了一遍。这样，你修改了新清单里的任何内容，都不会影响到原清单。这在很多场景下至关重要，比如当你需要一个对象的完全独立副本进行模拟、修改而不影响原始数据时。
import copy# 示例：列表的深拷贝original_list = [1, [2, 3], 4]deep_copied_list = copy.deepcopy(original_list)print(f"nOriginal List: {original_list}, ID: {id(original_list)}")print(f"Deep Copied List: {deep_copied_list}, ID: {id(deep_copied_list)}")print(f"ID of original_list[1]: {id(original_list[1])}")print(f"ID of deep_copied_list[1]: {id(deep_copied_list[1])}") # ID不同，说明是不同的对象# 修改深拷贝列表中的嵌套可变对象deep_copied_list[1].append(5)print(f"nAfter modifying deep_copied_list[1]:")print(f"Original List: {original_list}") # 原始列表保持不变print(f"Deep Copied List: {deep_copied_list}")# 示例：字典的深拷贝original_dict = {'a': 1, 'b': [2, 3], 'c': {'x': 10}}deep_copied_dict = copy.deepcopy(original_dict)print(f"nOriginal Dict: {original_dict}")print(f"Deep Copied Dict: {deep_copied_dict}")deep_copied_dict['b'].append(4)deep_copied_dict['c']['y'] = 20 # 修改深层嵌套对象print(f"nAfter modifying deep_copied_dict['b'] and ['c']:")print(f"Original Dict: {original_dict}") # 原始字典保持不变print(f"Deep Copied Dict: {deep_copied_dict}")
Python深拷贝和浅拷贝，究竟何时该选哪个？
在我的开发经验里，这几乎是一个月经式的问题，尤其是在处理复杂数据结构时。选择浅拷贝还是深拷贝，并非简单的“哪个更好”，而是取决于你的具体需求和对数据独立性的要求。
何时选择浅拷贝？
性能考量： 深拷贝操作通常比浅拷贝更耗时，因为它需要递归遍历并复制所有嵌套对象。如果你的对象结构非常庞大且嵌套层级深，但你又不需要完全独立的副本，那么浅拷贝无疑是更优的选择。比如，你只是想快速创建一个列表的副本，并且知道列表里只包含不可变类型（如数字、字符串、元组），或者你明确知道不需要修改嵌套的可变对象，浅拷贝就足够了。共享引用是预期行为： 有时候，你可能就是希望新旧对象共享某些内部组件。例如，一个配置对象可能包含一些共享的资源句柄，你希望所有使用这个配置副本的地方都指向同一个句柄。在这种情况下，浅拷贝恰好符合你的设计意图。对象只包含不可变类型： 如果你的对象（或其所有嵌套对象）都只包含不可变类型（如数字、字符串、元组），那么浅拷贝和深拷贝的效果其实是一样的。因为不可变对象一旦创建就不能修改，所以共享引用不会带来任何副作用。
何时必须使用深拷贝？
数据独立性至关重要： 这是最核心的理由。当你需要一个对象副本，并且希望对这个副本的任何修改都不会影响到原始对象，反之亦然，那么深拷贝是唯一的选择。我个人就遇到过这样的场景：从一个模板数据结构生成多个实例，每个实例都需要独立地进行修改和处理。如果使用了浅拷贝，修改其中一个实例，就会不小心污染了模板或者其他实例的数据，导致难以追踪的bug。处理包含可变嵌套对象的复杂结构： 列表、字典、自定义类实例等，如果它们内部还包含其他可变对象，那么浅拷贝的局限性就会凸显。当你需要确保所有层级的数据都是独立的，比如在进行状态快照、历史版本管理或者多线程/协程中避免数据竞争时，深拷贝是不可或缺的。避免意外的副作用： 浅拷贝带来的共享引用，往往是程序中难以预料的副作用的根源。尤其是在大型项目或团队协作中，如果不对拷贝行为有清晰的认识，很容易因为一个地方的修改影响到另一个看似不相关的部分。深拷贝提供了一种“安全网”，确保你正在操作的数据是完全隔离的。
总的来说，如果你不确定，或者对象结构复杂且包含可变嵌套，那么倾向于使用深拷贝通常是更安全的做法，尽管可能会有轻微的性能开销。
理解Python对象复制的“陷阱”：浅拷贝的局限性
浅拷贝的“陷阱”在于它给人的错觉。初学者往往认为“复制”就是创建一个一模一样、完全独立的新东西，但Python的浅拷贝并非如此。它在处理嵌套的可变对象时，会暴露出其固有的局限性，这常常是导致程序行为异常的隐蔽原因。
浅拷贝的核心问题在于它只复制了“引用”，而非引用指向的“内容”。对于不可变对象（如整数、字符串、元组），这没有问题，因为它们不能被修改，共享引用不会有副作用。但对于列表、字典、集合等可变对象，共享引用就意味着共享了修改的权力。
想象一下，你有一个用户列表，每个用户是一个字典，字典里包含用户的名字和他们的兴趣爱好列表。
users = [ {'name': 'Alice', 'interests': ['reading', 'hiking']}, {'name': 'Bob', 'interests': ['coding', 'gaming']}]# 浅拷贝用户列表copied_users = copy.copy(users)# 尝试修改拷贝后的用户列表中的一个用户的兴趣copied_users[0]['interests'].append('traveling')print("Original Users:", users)print("Copied Users:", copied_users)
你会发现，
copied_users[0]['interests']
的修改，也同时反映到了
users[0]['interests']
上。这并非我们想要的，我们可能只是想在拷贝的用户列表中给Alice添加一个新兴趣，而不影响原始用户列表。这种“牵一发而动全身”的现象，正是浅拷贝的局限性所在，也是它最常见的“陷阱”。它让数据独立性变得脆弱，稍不注意就可能导致数据污染，尤其是在函数间传递数据、或者在多线程环境中操作共享数据时，这种问题会变得尤为棘手且难以调试。
Python深拷贝的“智慧”：如何应对复杂数据结构和循环引用？
深拷贝的“智慧”在于它能够彻底斩断新旧对象之间的所有联系，即使面对最复杂的嵌套结构和令人头疼的循环引用，也能游刃有余。这使得它成为处理复杂数据结构的理想选择，尤其是在需要确保数据完全隔离的场景下。
应对复杂数据结构
当你的数据结构不仅仅是列表套列表，而是字典里嵌套着自定义类的实例，类实例里又包含着列表和字典，层层叠叠时，浅拷贝几乎是无能为力的。任何对拷贝对象深层数据的修改，都可能不经意间影响到原始对象。深拷贝则能一层层地剥开这些结构，为每个可变对象都创建一个全新的副本。
例如，你有一个表示公司组织结构的类，每个员工对象包含一个下属列表，下属又是员工对象。
class Employee: def __init__(self, name, subordinates=None): self.name = name self.subordinates = subordinates if subordinates is not None else [] def __repr__(self): return f"Employee({self.name}, {len(self.subordinates)} subordinates)"# 创建一个复杂的组织结构ceo = Employee("CEO")manager1 = Employee("Manager A")manager2 = Employee("Manager B")employee1 = Employee("Employee X")employee2 = Employee("Employee Y")ceo.subordinates.extend([manager1, manager2])manager1.subordinates.append(employee1)manager2.subordinates.append(employee2)# 深拷贝CEO对象import copycopied_ceo = copy.deepcopy(ceo)# 修改拷贝对象的下属结构copied_ceo.subordinates[0].subordinates.append(Employee("New Employee Z"))print("Original CEO structure:")print(ceo)print(ceo.subordinates[0])print(ceo.subordinates[0].subordinates)print("nCopied CEO structure:")print(copied_ceo)print(copied_ceo.subordinates[0])print(copied_ceo.subordinates[0].subordinates) # 新增的员工只在拷贝结构中
你会发现，原始的
ceo
对象及其下属结构保持不变，
copied_ceo
则拥有了独立的修改。
处理循环引用（Circular References）
循环引用是深拷贝面临的一个特殊挑战。如果对象A引用了对象B，同时对象B又引用了对象A，那么简单的递归拷贝会陷入无限循环，最终导致栈溢出。
copy.deepcopy()
的“智慧”之处在于它内置了一个机制来优雅地处理这种情况。
它通过维护一个内部字典（memoization table），记录在当前深拷贝过程中已经复制过的对象及其对应的副本。当
deepcopy
遇到一个它已经处理过的对象时，它不会再次尝试复制，而是直接返回之前创建的副本，从而打破循环，避免无限递归。
class Node: def __init__(self, value): self.value = value self.next = None self.prev = None # 假设是一个双向链表 def __repr__(self): return f"Node({self.value})"# 创建一个循环引用的结构node1 = Node(1)node2 = Node(2)node3 = Node(3)node1.next = node2node2.prev = node1node2.next = node3node3.prev = node2node3.next = node1 # 循环引用：node3指向node1node1.prev = node3# 尝试深拷贝node1import copytry: deep_copied_node1 = copy.deepcopy(node1) print("nDeep copy successful for circular reference.") print(f"Original node1: {node1}, next: {node1.next}, prev: {node1.prev}") print(f"Copied node1: {deep_copied_node1}, next: {deep_copied_node1.next}, prev: {deep_copied_node1.prev}") # 验证循环引用是否被正确复制 print(f"Copied node1.next.prev == Copied node1: {deep_copied_node1.next.prev == deep_copied_node1}") print(f"Copied node1.prev.next == Copied node1: {deep_copied_node1.prev.next == deep_copied_node1}")except RecursionError: print("Deep copy failed due to RecursionError (this should not happen with copy.deepcopy)")
在上面的例子中，
copy.deepcopy()
能够成功复制这个带有循环引用的链表结构，并且确保新链表中的
prev
和
next
指针正确地指向新链表中的对应节点，而不是原始链表中的节点。这种机制是
deepcopy
处理复杂对象图的关键能力，也是其“智慧”的体现。
自定义Python类，如何掌控其复制行为？
对于我们自己定义的类，Python的
copy
模块提供了两种特殊方法，允许我们精确控制深拷贝和浅拷贝的行为。这对于那些具有复杂内部状态或外部资源引用的自定义对象来说，是至关重要的。
__copy__(self)
方法：控制浅拷贝行为
当你对一个自定义类的实例调用
copy.copy()
时，Python会查找该类是否定义了
__copy__
方法。如果定义了，就会调用它来执行浅拷贝。通常情况下，我们希望浅拷贝创建一个新的实例，然后复制其属性。默认的
copy.copy()
行为对于大多数类来说已经足够，它会创建一个新实例，然后将原始实例的
__dict__
（存储实例属性的字典）浅拷贝到新实例的
__dict__
中。
但如果你的类有特殊的初始化逻辑，或者某些属性不应该被直接复制（比如文件句柄、数据库连接等），你可能就需要自定义
__copy__
。
class MyClass: def __init__(self, value, data): self.value = value self.data = data # 这是一个可变列表 def __repr__(self): return f"MyClass(value={self.value}, data={self.data})" def __copy__(self): # 默认的浅拷贝行为通常是创建一个新实例，然后复制属性 # 这里我们手动控制，比如只复制value，data保持引用 new_instance = type(self)(self.value, self.data) # 也可以使用 copy.copy(self.__dict__) 来复制属性字典 # new_instance.__dict__.update(copy.copy(self.__dict__)) return new_instanceimport copyobj = MyClass(1, [10, 20])shallow_obj = copy.copy(obj)print(f"Original: {obj}")print(f"Shallow Copy: {shallow_obj}")shallow_obj.data.append(30)print(f"After modifying shallow copy's data:")print(f"Original: {obj}") # Original's data also changedprint(f"Shallow Copy: {shallow_obj}")
在这个例子中，即使我们自定义了
__copy__
，但如果只是简单地将
self.data
赋给新实例，它仍然是浅拷贝的行为，因为
self.data
是一个可变对象，我们传递的是其引用。如果你想在
__copy__
中实现更深层次的复制（但通常不建议在
__copy__
中做深层复制，那是
__deepcopy__
的职责），你需要手动处理。
__deepcopy__(self, memo)
方法：控制深拷贝行为
当你对一个自定义类的实例调用
copy.deepcopy()
时，Python会查找该类是否定义了
__deepcopy__
方法。如果定义了，就会调用它。
memo
是一个字典，用于处理循环引用，它存储了原始对象到其已创建的副本的映射。
在
__deepcopy__
中，你需要手动创建新实例，并递归地对所有需要深拷贝的属性调用
copy.deepcopy()
。这是确保所有嵌套对象都独立的关键。
class MyDeepClass: def __init__(self, name, settings): self.name = name self.settings = settings # 这是一个可变字典 def __repr__(self): return f"MyDeepClass(name='{self.name}', settings={self.settings})" def __deepcopy__(self, memo): # 检查是否已经复制过，处理循环引用 if self in memo: return memo[self] # 创建新实例 new_instance = type(self)(self.name, {}) # 先创建一个空字典或默认值 memo[self] = new_instance # 将新实例加入memo，防止循环引用 # 递归深拷贝所有需要深拷贝的属性 new_instance.settings = copy.deepcopy(self.settings, memo) return new_instanceimport copyoriginal_deep_obj = MyDeepClass("ConfigA", {'theme': 'dark', 'options': [1, 2]})deep_copied_deep_obj = copy.deepcopy(original_deep_obj)print(f"nOriginal Deep Object: {original_deep_obj}")print(f"Deep Copied Deep Object: {deep_copied_deep_obj}")deep_copied_deep_obj.settings['theme'] = 'light'deep
以上就是python中如何深度拷贝一个对象_Python深拷贝与浅拷贝的区别与实现的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1371244.html
微信扫一扫 
支付宝扫一扫 
