如何复制Python中的对象：浅拷贝与深拷贝详解

最新推荐文章于 2025-04-07 10:23:57 发布

梦幻南瓜

最新推荐文章于 2025-04-07 10:23:57 发布

阅读量281

点赞数 5

分类专栏： python 文章标签： python 开发语言

本文链接：https://blog.youkuaiyun.com/ybg8912/article/details/146060909

版权

python 专栏收录该内容

31 篇文章

订阅专栏

在Python中，复制对象是一个常见的操作，但不同的复制方式会产生不同的结果。Python提供了两种主要的复制方式：浅拷贝（Shallow Copy）和深拷贝（Deep Copy）。本文将详细介绍这两种复制方式的区别、用法以及实际应用场景。

1. 浅拷贝与深拷贝的区别
浅拷贝（Shallow Copy）

定义：浅拷贝创建一个新对象，但新对象中的元素是对原对象中元素的引用。

特点：

如果原对象包含可变元素（如列表、字典），修改这些元素会影响拷贝对象。
如果原对象包含不可变元素（如整数、字符串），修改这些元素不会影响拷贝对象。
适用场景：适用于对象结构简单，且不包含嵌套可变对象的情况。

深拷贝（Deep Copy）

定义：深拷贝创建一个新对象，并递归地复制原对象中的所有元素。

特点：

无论原对象包含可变还是不可变元素，修改这些元素都不会影响拷贝对象。
适用场景：适用于对象结构复杂，且包含嵌套可变对象的情况。

2. 实现浅拷贝与深拷贝的方法
浅拷贝的实现方法
方法1：使用 copy 模块的 copy() 函数

import copy

original_list = [1, 2, [3, 4]]
shallow_copied_list = copy.copy(original_list)

# 修改原对象的嵌套列表
original_list[2][0] = 99
print(original_list)        # 输出: [1, 2, [99, 4]]
print(shallow_copied_list)  # 输出: [1, 2, [99, 4]]

方法2：使用对象的 copy() 方法（适用于列表、字典等）

original_list = [1, 2, [3, 4]]
shallow_copied_list = original_list.copy()

# 修改原对象的嵌套列表
original_list[2][0] = 99
print(original_list)        # 输出: [1, 2, [99, 4]]
print(shallow_copied_list)  # 输出: [1, 2, [99, 4]]

方法3：使用切片（适用于列表）

original_list = [1, 2, [3, 4]]
shallow_copied_list = original_list[:]

# 修改原对象的嵌套列表
original_list[2][0] = 99
print(original_list)        # 输出: [1, 2, [99, 4]]
print(shallow_copied_list)  # 输出: [1, 2, [99, 4]]

深拷贝的实现方法
方法1：使用 copy 模块的 deepcopy() 函数

import copy

original_list = [1, 2, [3, 4]]
deep_copied_list = copy.deepcopy(original_list)

# 修改原对象的嵌套列表
original_list[2][0] = 99
print(original_list)        # 输出: [1, 2, [99, 4]]
print(deep_copied_list)     # 输出: [1, 2, [3, 4]]

3. 浅拷贝与深拷贝的对比
以下是一个对比示例，展示了浅拷贝和深拷贝的区别：

import copy

# 原始对象
original_list = [1, 2, [3, 4]]

# 浅拷贝
shallow_copied_list = copy.copy(original_list)

# 深拷贝
deep_copied_list = copy.deepcopy(original_list)

# 修改原对象的嵌套列表
original_list[2][0] = 99

print("Original List:", original_list)        # 输出: [1, 2, [99, 4]]
print("Shallow Copied List:", shallow_copied_list)  # 输出: [1, 2, [99, 4]]
print("Deep Copied List:", deep_copied_list)   # 输出: [1, 2, [3, 4]]

4. 实际应用场景
1. 浅拷贝的应用场景

简单对象的复制：当对象结构简单，且不包含嵌套可变对象时，可以使用浅拷贝。
节省内存：浅拷贝比深拷贝更快且占用更少内存。

2. 深拷贝的应用场景

复杂对象的复制：当对象结构复杂，且包含嵌套可变对象时，必须使用深拷贝。
避免副作用：深拷贝可以确保原对象和拷贝对象完全独立，避免意外的修改。

5. 注意事项

不可变对象的复制：对于不可变对象（如整数、字符串、元组），浅拷贝和深拷贝的效果相同。
自定义对象的复制：如果自定义类需要支持深拷贝，可以实现 deepcopy 方法。
性能问题：深拷贝的递归操作可能会导致性能问题，尤其是在处理大型对象时。

6. 自定义对象的深拷贝
如果自定义类需要支持深拷贝，可以实现 deepcopy 方法：

import copy

class MyClass:
    def __init__(self, value):
        self.value = value

    def __deepcopy__(self, memo):
        new_instance = MyClass(copy.deepcopy(self.value, memo))
        return new_instance

# 测试
original_obj = MyClass([1, 2, 3])
deep_copied_obj = copy.deepcopy(original_obj)

original_obj.value[0] = 99
print(original_obj.value)    # 输出: [99, 2, 3]
print(deep_copied_obj.value)  # 输出: [1, 2, 3]