Python 中的深拷贝、浅拷贝与等号赋值：理解对象复制的本质

目录

1. 等号赋值（=）

2. 浅拷贝（copy.copy()）

3. 深拷贝（copy.deepcopy()）

4. 不可变对象与可变对象

5. 性能对比

6. 实际应用场景

7. 总结

---

前言

在 Python 中，对象的复制是一个常见的操作，但很多人对深拷贝、浅拷贝和等号赋值之间的区别感到困惑。本文将通过详细的示例和解释，帮助你深入理解这三种操作的本质和应用场景。

1. 等号赋值（=）

在 Python 中，等号赋值是最基本的对象操作之一。它将一个变量名绑定到一个对象上。但需要注意的是，等号赋值并不创建新的对象，而是让两个变量名指向同一个对象。

示例代码

a = [1, 2, 3]
b = a  # 等号赋值
print(a)  # 输出: [1, 2, 3]
print(b)  # 输出: [1, 2, 3]

# 修改 a 的内容
a.append(4)
print(a)  # 输出: [1, 2, 3, 4]
print(b)  # 输出: [1, 2, 3, 4]

解释

在上述代码中，a 和 b 都指向同一个列表对象 [1, 2, 3]。当我们通过 a.append(4) 修改列表时，b 也会受到影响，因为它们指向的是同一个对象。

内存地址

我们可以通过 id() 函数查看变量的内存地址，进一步确认这一点：

print(id(a))  # 输出: 140253845282304
print(id(b))  # 输出: 140253845282304

可以看到，a 和 b 的内存地址是相同的，说明它们指向的是同一个对象。

2. 浅拷贝（copy.copy()）

浅拷贝是 Python 中的一种对象复制方式，它会创建一个新的对象，但只复制对象的第一层内容。对于可变对象（如列表、字典等），浅拷贝会创建一个新的容器，但容器中的元素仍然是原对象的引用。

示例代码

import copy

a = [1, 2, 3]
b = copy.copy(a)  # 浅拷贝
print(a)  # 输出: [1, 2, 3]
print(b)  # 输出: [1, 2, 3]

# 修改 a 的内容
a.append(4)
print(a)  # 输出: [1, 2, 3, 4]
print(b)  # 输出: [1, 2, 3]

解释

在上述代码中，b 是 a 的浅拷贝。虽然 a 和 b 是两个不同的列表对象，但它们的内存地址不同：

print(id(a))  # 输出: 140253845282304
print(id(b))  # 输出: 140253845282464

可以看到，a 和 b 的内存地址不同，说明它们是两个不同的对象。因此，当我们修改 a 时，b 不会受到影响。

浅拷贝的局限性

浅拷贝只复制对象的第一层内容。如果对象中包含嵌套的可变对象（如列表中的列表），浅拷贝不会递归复制嵌套对象，而是复制嵌套对象的引用。

a = [1, 2, [3, 4]]
b = copy.copy(a)  # 浅拷贝
print(a)  # 输出: [1, 2, [3, 4]]
print(b)  # 输出: [1, 2, [3, 4]]

# 修改 a 中嵌套列表的内容
a[2].append(5)
print(a)  # 输出: [1, 2, [3, 4, 5]]
print(b)  # 输出: [1, 2, [3, 4, 5]]

可以看到，虽然 a 和 b 是两个不同的列表对象，但它们的嵌套列表 [3, 4] 是同一个对象。因此，当我们修改嵌套列表时，a 和 b 都会受到影响。

3. 深拷贝（copy.deepcopy()）

深拷贝是 Python 中的一种对象复制方式，它会递归地复制对象的所有内容，包括嵌套的对象。深拷贝会创建一个全新的对象，且对象中的所有嵌套对象也会被递归复制。

示例代码

import copy

a = [1, 2, [3, 4]]
b = copy.deepcopy(a)  # 深拷贝
print(a)  # 输出: [1, 2, [3, 4]]
print(b)  # 输出: [1, 2, [3, 4]]

# 修改 a 的内容
a.append(5)
print(a)  # 输出: [1, 2, [3, 4], 5]
print(b)  # 输出: [1, 2, [3, 4]]

# 修改 a 中嵌套列表的内容
a[2].append(6)
print(a)  # 输出: [1, 2, [3, 4, 6], 5]
print(b)  # 输出: [1, 2, [3, 4]]

解释

在上述代码中，b 是 a 的深拷贝。a 和 b 是两个完全独立的对象，它们的内存地址不同：

print(id(a))  # 输出: 140253845282304
print(id(b))  # 输出: 140253845282464

同时，a 和 b 中的嵌套列表也是两个独立的对象：

print(id(a[2]))  # 输出: 140253845282528
print(id(b[2]))  # 输出: 140253845282688

可以看到，a[2] 和 b[2] 的内存地址不同，说明它们是两个不同的对象。因此，当我们修改 a 或其嵌套对象时，b 不会受到影响。

4. 不可变对象与可变对象

在 Python 中，对象可以分为不可变对象和可变对象：

• 不可变对象：如整数、浮点数、字符串、元组等。这些对象一旦创建，其内容就不能被修改。

• 可变对象：如列表、字典、集合等。这些对象的内容可以被修改。

不可变对象的赋值

对于不可变对象，等号赋值和浅拷贝的效果是一样的，因为不可变对象的内容不能被修改。

a = (1, 2, 3)
b = a  # 等号赋值
c = copy.copy(a)  # 浅拷贝
print(a)  # 输出: (1, 2, 3)
print(b)  # 输出: (1, 2, 3)
print(c)  # 输出: (1, 2, 3)

# 修改 a 的内容
a = (1, 2, 3, 4)
print(a)  # 输出: (1, 2, 3, 4)
print(b)  # 输出: (1, 2, 3)
print(c)  # 输出: (1, 2, 3)

可以看到，a、b 和 c 的内容是独立的，因为元组是不可变对象。

可变对象的赋值

对于可变对象，等号赋值、浅拷贝和深拷贝的效果是不同的，因为可变对象的内容可以被修改。

5. 性能对比

虽然深拷贝可以完全复制对象的所有内容，但它需要更多的内存和时间，尤其是对于复杂的嵌套对象。浅拷贝则相对高效，但需要注意嵌套对象的引用问题。

性能测试代码

import copy
import time

# 创建一个复杂的嵌套对象
a = [1, 2, [3, 4, [5, 6]]]

# 测试等号赋值
start_time = time.time()
b = a
end_time = time.time()
print(f"等号赋值时间: {end_time - start_time:.6f} 秒")

# 测试浅拷贝
start_time = time.time()
c = copy.copy(a)
end_time = time.time()
print(f"浅拷贝时间: {end_time - start_time:.6f} 秒")

# 测试深拷贝
start_time = time.time()
d = copy.deepcopy(a)
end_time = time.time()
print(f"深拷贝时间: {end_time - start_time:.6f} 秒")

输出结果

运行上述代码，输出结果如下：

等号赋值时间: 0.000001 秒
浅拷贝时间: 0.000002 秒
深拷贝时间: 0.000010 秒

可以看到，等号赋值和浅拷贝的性能非常接近，而深拷贝的性能相对较慢。

6. 实际应用场景

等号赋值

等号赋值适用于不需要复制对象的场景。例如，当你只需要一个对象的引用时，使用等号赋值即可。

浅拷贝

浅拷贝适用于需要复制对象的第一层内容，但嵌套对象不需要复制的场景。例如，当你有一个包含多个子对象的列表，但子对象不需要复制时，可以使用浅拷贝。

深拷贝

深拷贝适用于需要完全复制对象的所有内容，包括嵌套对象的场景。例如，当你需要一个对象的完全独立副本时，使用深拷贝。

7. 总结

在 Python 中，等号赋值、浅拷贝和深拷贝是三种常见的对象复制方式。等号赋值只是创建了一个新的引用，浅拷贝复制了对象的第一层内容，而深拷贝递归地复制了对象的所有内容。选择合适的复制方式取决于你的具体需求和性能考虑。

通过本文的示例和解释，你应该能够清楚地理解这三种操作的区别，并在实际开发中正确使用它们。