一文带你掌握Python中的深浅拷贝

Python 深浅拷贝完全指南

一、核心概念

1.1 什么是拷贝？

拷贝（Copy）是指创建对象的副本，而非原始对象的引用。

1.2 为什么需要拷贝？

当我们需要修改数据而不影响原始数据时，拷贝就变得至关重要。

二、三种拷贝方式对比

特性	赋值	浅拷贝	深拷贝
创建新对象	❌	✅（顶层）	✅（递归）
复制嵌套对象	❌	❌	✅
内存使用	最少	中等	最多
性能	最快	中等	最慢

三、赋值（Assignment） - 不是拷贝

# 示例1：简单变量的赋值
a = 10
b = a  # b只是a的引用
b = 20
print(a)  # 10 - 不影响a

# 示例2：可变对象的赋值
list1 = [1, 2, 3]
list2 = list1  # list2是list1的引用
list2.append(4)
print(list1)  # [1, 2, 3, 4] - 也被修改了！
print(id(list1) == id(list2))  # True - 内存地址相同

四、浅拷贝（Shallow Copy）

4.1 创建浅拷贝的方法

import copy

# 方法1：使用copy模块
original = [1, 2, [3, 4]]
shallow = copy.copy(original)

# 方法2：列表的copy()方法（Python 3.3+）
shallow = original.copy()

# 方法3：切片操作
shallow = original[:]

# 方法4：list()构造函数
shallow = list(original)

# 方法5：字典的copy()方法
dict_original = {'a': 1, 'b': [2, 3]}
dict_shallow = dict_original.copy()

4.2 浅拷贝的局限性

import copy

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

# 修改顶层元素 - 不影响原列表
shallow[0] = 100
print("修改顶层元素后：")
print("original:", original)  # [1, 2, [3, 4]]
print("shallow:", shallow)    # [100, 2, [3, 4]]

# 修改嵌套元素 - 两者都会被影响！
shallow[2].append(5)
print("\n修改嵌套元素后：")
print("original:", original)  # [1, 2, [3, 4, 5]]
print("shallow:", shallow)    # [100, 2, [3, 4, 5]]

五、深拷贝（Deep Copy）

5.1 创建深拷贝的方法

import copy

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

# 现在修改任何层级都不会影响原对象
deep[2].append(5)
print("original:", original)  # [1, 2, [3, 4]]
print("deep:", deep)          # [1, 2, [3, 4, 5]]

5.2 深拷贝的工作原理

import copy

# 复杂嵌套结构的深拷贝
complex_data = {
    'name': 'Alice',
    'scores': [85, 92, 78],
    'friends': [
        {'name': 'Bob', 'age': 25},
        {'name': 'Charlie', 'age': 23}
    ]
}

deep_copy = copy.deepcopy(complex_data)

# 修改深拷贝的任何部分
deep_copy['scores'].append(95)
deep_copy['friends'][0]['age'] = 26

print("Original:", complex_data['scores'])  # [85, 92, 78]
print("Deep copy:", deep_copy['scores'])    # [85, 92, 78, 95]

六、实际应用场景

6.1 适合浅拷贝的场景

# 场景1：没有嵌套结构的简单对象
data = [1, 2, 3, 4, 5]
backup = data.copy()  # 浅拷贝足够

# 场景2：配置模板
config_template = {
    'timeout': 30,
    'retry': 3,
    'debug': False
}

def create_config(overrides):
    config = config_template.copy()  # 浅拷贝
    config.update(overrides)
    return config

6.2 适合深拷贝的场景

# 场景1：游戏状态保存
class GameState:
    def __init__(self):
        self.players = [{'name': 'P1', 'position': (0, 0)}]
        self.map = [[0, 1], [1, 0]]

def save_game(state):
    import copy
    return copy.deepcopy(state)  # 需要深拷贝保存完整状态

# 场景2：数据处理流水线
def process_data(data_pipeline):
    import copy
    # 在每个处理阶段使用深拷贝，避免数据污染
    stage1_input = copy.deepcopy(data_pipeline)
    # ... 处理逻辑

七、性能考虑

import copy
import time

# 测试不同拷贝方式的性能
large_list = [list(range(100)) for _ in range(1000)]

# 测试浅拷贝
start = time.time()
shallow_copy = copy.copy(large_list)
print(f"浅拷贝耗时: {time.time() - start:.6f}秒")

# 测试深拷贝
start = time.time()
deep_copy = copy.deepcopy(large_list)
print(f"深拷贝耗时: {time.time() - start:.6f}秒")

八、特殊情况处理

8.1 自定义对象的拷贝

import copy

class Person:
    def __init__(self, name, friends=None):
        self.name = name
        self.friends = friends if friends is not None else []

    # 自定义深拷贝行为
    def __deepcopy__(self, memo):
        # 避免循环引用
        if id(self) in memo:
            return memo[id(self)]

        # 创建新实例
        new_person = Person(copy.deepcopy(self.name, memo))
        memo[id(self)] = new_person

        # 深度拷贝friends列表
        new_person.friends = copy.deepcopy(self.friends, memo)
        return new_person

# 使用
p1 = Person("Alice")
p2 = Person("Bob", [p1])
p1.friends.append(p2)

p1_copy = copy.deepcopy(p1)  # 正确处理循环引用

8.2 不可变对象的拷贝

# 对于不可变对象，Python会优化
import copy

# 字符串、元组等不可变对象
t1 = (1, 2, 3)
t2 = copy.copy(t1)
t3 = copy.deepcopy(t1)

print(id(t1) == id(t2))  # True - Python优化，共享内存
print(id(t1) == id(t3))  # True - 同样优化