深拷贝 vs 浅拷贝：Python 数据复制的那些坑

本文链接：https://blog.youkuaiyun.com/tony2yy/article/details/147238039

在 Python 中，拷贝（Copy）操作是我们日常编程中非常常见的需求。我们经常会遇到需要复制对象的场景，尤其是在处理列表、字典等复杂数据结构时。虽然看似简单，浅拷贝与深拷贝的概念却常常让初学者和有经验的开发者产生困惑，且不小心就会陷入数据复制的“坑”中。

浅拷贝与深拷贝的差异可能看起来微不足道，但它们对程序的行为、性能以及内存管理的影响却深远。理解它们的细微差异，能帮助我们避免出现数据意外共享、修改原始数据等问题，从而编写更加高效且可靠的代码。

本文将深入探讨 Python 中浅拷贝与深拷贝的概念，通过详细的示例揭示这两者的区别，展示常见的陷阱，并总结最佳实践，帮助你在实际开发中避免这些坑。

一、浅拷贝与深拷贝的定义

1.1 浅拷贝（Shallow Copy）

浅拷贝是指创建一个新的对象，但该对象中的元素仍然引用原始对象中的元素。也就是说，浅拷贝仅复制对象的第一层结构，如果对象包含嵌套对象（如列表中的列表），那么嵌套对象的引用仍然指向原始对象。

简单来说，浅拷贝只复制对象本身，而不复制对象内部的可变对象。

示例：浅拷贝的行为

import copy

original = [[1, 2, 3], [4, 5, 6]]
shallow_copy = copy.copy(original)

shallow_copy[0][0] = 99  # 修改浅拷贝中的内部列表

print("Original:", original)  # Original: [[99, 2, 3], [4, 5, 6]]
print("Shallow Copy:", shallow_copy)  # Shallow Copy: [[99, 2, 3], [4, 5, 6]]

在这个示例中，修改 shallow_copy 内部列表的元素，导致原始对象 original 中的元素也被修改。这是因为浅拷贝只是复制了外层列表的引用，内部的子列表依然是共享的。

1.2 深拷贝（Deep Copy）

深拷贝则是创建一个新的对象，并且递归地复制原始对象中的所有嵌套对象。深拷贝会完全复制整个对象的结构，包括所有内部对象，因此即使内部嵌套对象发生变化，也不会影响原始对象。

示例：深拷贝的行为

import copy

original = [[1, 2, 3], [4, 5, 6]]
deep_copy = copy.deepcopy(original)

deep_copy[0][0] = 99  # 修改深拷贝中的内部列表

print("Original:", original)  # Original: [[1, 2, 3], [4, 5, 6]]
print("Deep Copy:", deep_copy)  # Deep Copy: [[99, 2, 3], [4, 5, 6]]

在这个示例中，修改 deep_copy 内部列表的元素并不会影响 original。因为 deepcopy 生成了一个完全独立的副本，所有的内部嵌套对象也被递归地复制。

二、浅拷贝与深拷贝的区别

2.1 内存管理的差异

浅拷贝只复制对象的第一层结构，而深拷贝会复制整个对象，包括所有嵌套的对象。因此，深拷贝会创建更多的内存副本，而浅拷贝则在某些情况下会造成内存的共享。

浅拷贝：新对象与原始对象共享嵌套对象的引用。
深拷贝：新对象及其内部对象是原始对象的完全副本。

内存占用的差异

import copy
import sys

original = [[1, 2, 3], [4, 5, 6]]
shallow_copy = copy.copy(original)
deep_copy = copy.deepcopy(original)

print("Original memory:", sys.getsizeof(original))  # 大小
print("Shallow Copy memory:", sys.getsizeof(shallow_copy))  # 大小
print("Deep Copy memory:", sys.getsizeof(deep_copy))  # 大小

深拷贝的内存占用通常会大于浅拷贝，因为它创建了多个新的对象，而浅拷贝仅复制了最外层对象。

2.2 性能差异

由于深拷贝需要递归地复制对象及其内部所有子对象，深拷贝的性能比浅拷贝差，特别是对于包含大量嵌套结构的复杂对象。浅拷贝只需复制外部结构，速度更快。

性能对比

import time
import copy

# 生成包含大量元素的列表
original = [[i] * 1000 for i in range(1000)]

start = time.time()
shallow_copy = copy.copy(original)
end = time.time()
print(f"浅拷贝耗时: {end - start:.6f}秒")

start = time.time()
deep_copy = copy.deepcopy(original)
end = time.time()
print(f"深拷贝耗时: {end - start:.6f}秒")

在大多数情况下，浅拷贝的性能明显优于深拷贝。

三、常见的坑与注意事项

3.1 误用浅拷贝

问题：在需要完全独立的对象时，误用浅拷贝可能导致对象间意外的共享。你修改一个对象的内部数据，另一个对象也会发生变化，从而引发难以追踪的错误。

解决方案：对于复杂的对象，尤其是包含嵌套数据结构的对象，建议使用深拷贝，而非浅拷贝，避免无意间修改原始数据。

3.2 对象类型和拷贝的兼容性

并非所有对象都能使用 copy.copy() 或 copy.deepcopy() 进行拷贝。例如，一些具有自定义的 __copy__ 或 __deepcopy__ 方法的对象会改变默认拷贝行为。

示例：自定义拷贝行为

import copy

class CustomObject:
    def __init__(self, data):
        self.data = data
    
    def __copy__(self):
        # 自定义浅拷贝行为
        new_obj = CustomObject(self.data)
        new_obj.data = self.data + "_copied"
        return new_obj

original = CustomObject("Hello")
shallow_copy = copy.copy(original)

print("Original:", original.data)  # Hello
print("Shallow Copy:", shallow_copy.data)  # Hello_copied

启发：如果你自定义了对象的拷贝行为，需要特别注意 __copy__ 和 __deepcopy__ 方法的实现，避免意外的行为。