乐闻世界logo
搜索文章和话题

Python 中的深拷贝和浅拷贝有什么区别？

2月17日 21:48

拷贝的基本概念

在 Python 中，赋值操作不会创建新的对象，而是创建对同一对象的引用。拷贝操作则创建新的对象。

赋值 vs 拷贝

python
# 赋值操作
original = [1, 2, 3]
assigned = original
assigned[0] = 99
print(original)  # [99, 2, 3] - 原始列表被修改

# 拷贝操作
import copy
original = [1, 2, 3]
copied = copy.copy(original)
copied[0] = 99
print(original)  # [1, 2, 3] - 原始列表未被修改

浅拷贝（Shallow Copy）

什么是浅拷贝

浅拷贝创建一个新的对象，但不会递归地复制嵌套的对象。嵌套的对象仍然是共享的引用。

浅拷贝的实现方式

python
import copy

# 1. 使用 copy.copy()
original = [1, 2, [3, 4]]
shallow = copy.copy(original)

# 2. 使用列表的 copy() 方法
shallow = original.copy()

# 3. 使用切片
shallow = original[:]

# 4. 使用 list() 构造函数
shallow = list(original)

# 5. 使用字典的 copy() 方法
original_dict = {'a': 1, 'b': [2, 3]}
shallow_dict = original_dict.copy()

浅拷贝的问题

python
import copy

original = [1, 2, [3, 4]]
shallow = copy.copy(original)

# 修改顶层元素
shallow[0] = 99
print(original)  # [1, 2, [3, 4]] - 原始列表未被修改

# 修改嵌套对象
shallow[2][0] = 99
print(original)  # [1, 2, [99, 4]] - 原始列表被修改！

深拷贝（Deep Copy）

什么是深拷贝

深拷贝创建一个新的对象，并递归地复制所有嵌套的对象。修改拷贝不会影响原始对象。

深拷贝的实现方式

python
import copy

original = [1, 2, [3, 4]]
deep = copy.deepcopy(original)

# 修改顶层元素
deep[0] = 99
print(original)  # [1, 2, [3, 4]] - 原始列表未被修改

# 修改嵌套对象
deep[2][0] = 99
print(original)  # [1, 2, [3, 4]] - 原始列表未被修改

深拷贝与浅拷贝的对比

基本数据类型

python
import copy

# 不可变对象（整数、字符串、元组）
a = 42
b = copy.copy(a)
c = copy.deepcopy(a)
print(a is b)  # True - 不可变对象共享引用
print(a is c)  # True

# 可变对象（列表、字典、集合）
original = [1, 2, 3]
shallow = copy.copy(original)
deep = copy.deepcopy(original)

print(original is shallow)  # False - 创建了新对象
print(original is deep)  # False - 创建了新对象

嵌套结构

python
import copy

original = {
    'numbers': [1, 2, 3],
    'nested': {'a': [4, 5], 'b': [6, 7]},
    'tuple': (8, 9, [10, 11])
}

shallow = copy.copy(original)
deep = copy.deepcopy(original)

# 修改浅拷贝的嵌套列表
shallow['numbers'][0] = 99
print(original['numbers'][0])  # 99 - 原始对象被修改

# 修改深拷贝的嵌套列表
deep['numbers'][0] = 88
print(original['numbers'][0])  # 99 - 原始对象未被修改

自定义对象的拷贝

python
import copy

class MyClass:
    def __init__(self, value):
        self.value = value
        self.nested = [value * 2, value * 3]
    
    def __copy__(self):
        """实现浅拷贝"""
        new_obj = type(self)(self.value)
        new_obj.nested = self.nested
        return new_obj
    
    def __deepcopy__(self, memo):
        """实现深拷贝"""
        new_obj = type(self)(self.value)
        new_obj.nested = copy.deepcopy(self.nested, memo)
        return new_obj

original = MyClass(10)
shallow = copy.copy(original)
deep = copy.deepcopy(original)

shallow.nested[0] = 99
print(original.nested[0])  # 99 - 浅拷贝共享嵌套对象

deep.nested[0] = 88
print(original.nested[0])  # 99 - 深拷贝独立

实际应用场景

1. 处理配置对象

python
import copy

default_config = {
    'debug': False,
    'max_retries': 3,
    'timeout': 30,
    'endpoints': ['api1.example.com', 'api2.example.com']
}

# 使用深拷贝创建独立配置
config1 = copy.deepcopy(default_config)
config2 = copy.deepcopy(default_config)

config1['debug'] = True
config1['endpoints'].append('api3.example.com')

print(default_config['debug'])  # False
print(default_config['endpoints'])  # ['api1.example.com', 'api2.example.com']

2. 处理数据结构

python
import copy

# 处理嵌套数据
data = {
    'users': [
        {'name': 'Alice', 'scores': [85, 90, 78]},
        {'name': 'Bob', 'scores': [92, 88, 95]}
    ]
}

# 创建副本进行处理
processed_data = copy.deepcopy(data)

# 修改副本不影响原始数据
for user in processed_data['users']:
    user['average'] = sum(user['scores']) / len(user['scores'])

print(processed_data['users'][0]['average'])  # 84.333...
print('average' in data['users'][0])  # False

3. 实现撤销/重做功能

python
import copy

class TextEditor:
    def __init__(self):
        self.content = ""
        self.history = []
    
    def write(self, text):
        self.history.append(copy.deepcopy(self.content))
        self.content += text
    
    def undo(self):
        if self.history:
            self.content = self.history.pop()
    
    def get_content(self):
        return self.content

editor = TextEditor()
editor.write("Hello ")
editor.write("World!")
print(editor.get_content())  # Hello World!

editor.undo()
print(editor.get_content())  # Hello

4. 缓存数据

python
import copy

class DataCache:
    def __init__(self):
        self.cache = {}
    
    def get(self, key):
        if key in self.cache:
            return copy.deepcopy(self.cache[key])
        return None
    
    def set(self, key, value):
        self.cache[key] = value

cache = DataCache()
data = {'items': [1, 2, 3]}
cache.set('data', data)

# 获取缓存数据的副本
cached_data = cache.get('data')
cached_data['items'].append(4)

# 原始缓存数据未被修改
original_data = cache.get('data')
print(original_data['items'])  # [1, 2, 3]

性能考虑

深拷贝的性能开销

python
import copy
import time

# 大型数据结构
large_data = {'items': list(range(10000))}

# 浅拷贝
start = time.time()
shallow = copy.copy(large_data)
print(f"浅拷贝耗时: {time.time() - start:.6f} 秒")

# 深拷贝
start = time.time()
deep = copy.deepcopy(large_data)
print(f"深拷贝耗时: {time.time() - start:.6f} 秒")

选择合适的拷贝方式

python
import copy

# 简单数据结构 - 使用浅拷贝
simple_data = [1, 2, 3, 4, 5]
shallow_copy = copy.copy(simple_data)

# 嵌套数据结构 - 使用深拷贝
complex_data = [1, 2, [3, 4], {'a': 5}]
deep_copy = copy.deepcopy(complex_data)

# 只读数据 - 不需要拷贝
read_only_data = (1, 2, 3)  # 元组是不可变的

常见问题与解决方案

1. 循环引用

python
import copy

# 创建循环引用
a = [1, 2]
b = [3, 4]
a.append(b)
b.append(a)

# 深拷贝处理循环引用
try:
    deep_copy = copy.deepcopy(a)
    print("深拷贝成功处理循环引用")
except RecursionError:
    print("无法处理循环引用")

2. 自定义对象的拷贝

python
import copy

class Node:
    def __init__(self, value):
        self.value = value
        self.next = None
    
    def __deepcopy__(self, memo):
        new_node = Node(self.value)
        memo[id(self)] = new_node
        if self.next:
            new_node.next = copy.deepcopy(self.next, memo)
        return new_node

# 创建链表
node1 = Node(1)
node2 = Node(2)
node3 = Node(3)
node1.next = node2
node2.next = node3

# 深拷贝链表
copied_list = copy.deepcopy(node1)
print(copied_list.value)  # 1
print(copied_list.next.value)  # 2

3. 拷贝不可变对象

python
import copy

# 不可变对象不需要拷贝
immutable = (1, 2, 3)
shallow = copy.copy(immutable)
deep = copy.deepcopy(immutable)

print(immutable is shallow)  # True
print(immutable is deep)  # True

最佳实践

1. 明确拷贝需求

python
import copy

# 需要独立修改嵌套对象 - 使用深拷贝
data = {'config': {'timeout': 30}}
independent_copy = copy.deepcopy(data)

# 只需要修改顶层对象 - 使用浅拷贝
data = [1, 2, 3, 4, 5]
shallow_copy = copy.copy(data)

2. 避免不必要的拷贝

python
import copy

# 不好的做法 - 不必要的拷贝
def process_data(data):
    copied = copy.deepcopy(data)
    return sum(copied)

# 好的做法 - 直接使用原始数据
def process_data(data):
    return sum(data)

3. 使用上下文管理器

python
import copy
from contextlib import contextmanager

@contextmanager
def copy_context(data, deep=False):
    """创建拷贝上下文"""
    copied = copy.deepcopy(data) if deep else copy.copy(data)
    yield copied

# 使用上下文管理器
original = [1, 2, [3, 4]]

with copy_context(original, deep=True) as copied:
    copied[2][0] = 99

print(original)  # [1, 2, [3, 4]] - 原始数据未被修改

4. 文档化拷贝行为

python
import copy

class DataProcessor:
    """数据处理类
    
    注意：process_data 方法会修改输入数据，如需保留原始数据，
    请在调用前使用 copy.deepcopy() 创建副本。
    """
    
    def process_data(self, data):
        data[0] = 99
        return data

# 使用示例
processor = DataProcessor()
original = [1, 2, 3]
processed = processor.process_data(copy.deepcopy(original))

总结

深拷贝与浅拷贝的关键区别：

浅拷贝

  • 创建新对象，但嵌套对象共享引用
  • 使用 copy.copy() 或对象的 copy() 方法
  • 适用于简单数据结构或不需要修改嵌套对象的场景
  • 性能开销较小

深拷贝

  • 创建新对象，递归复制所有嵌套对象
  • 使用 copy.deepcopy()
  • 适用于复杂嵌套数据结构
  • 性能开销较大

选择建议

  1. 简单数据结构：使用浅拷贝
  2. 嵌套数据结构：使用深拷贝
  3. 只读数据：不需要拷贝
  4. 性能敏感：避免不必要的拷贝
  5. 自定义对象：实现 __copy__ 和 __deepcopy__ 方法

理解深拷贝与浅拷贝的区别，能够正确处理数据复制，避免意外的数据修改问题。

标签：Python
热门标签
更多
Git(114)C语言(23)C++(15)前端(148)React(32)JavaScript(56)Linux(20)Rust(10)Docker(65)Cypress(4)TypeScript(23)Tailwind CSS(29)Vue(13)CSS(19)网络(12)MySQL(7)TypeORM(31)Next.js(30)