14.Python深拷贝和浅拷贝详解

全栈若城

发布于 2025-04-12 11:13:48

148033

代码可运行

文章被收录于专栏：若城技术专栏若城技术专栏

运行总次数：33

代码可运行

基本概念

对象引用

在Python中，变量实际上是对象的引用。当我们将一个变量赋值给另一个变量时，实际上是创建了一个新的引用指向同一个对象。

# 简单的对象引用示例
x = [1, 2, 3]
y = x  # y引用了与x相同的列表对象

# 修改y会影响x
y.append(4)
print(f"x: {x}")  # 输出: x: [1, 2, 3, 4]
print(f"y: {y}")  # 输出: y: [1, 2, 3, 4]

# 验证x和y指向同一个对象
print(f"x和y是否是同一个对象: {x is y}")  # 输出: True

浅拷贝（Shallow Copy）

浅拷贝创建一个新对象，但它包含的是对原始对象中元素的引用。

import copy

# 创建浅拷贝的几种方法
original = [1, [2, 3], {'a': 4}]

# 1. 使用copy模块
shallow_copy1 = copy.copy(original)

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

# 3. 使用切片操作
shallow_copy3 = original[:]

# 验证浅拷贝的特性
print(f"原始对象: {original}")
print(f"浅拷贝1: {shallow_copy1}")
print(f"浅拷贝2: {shallow_copy2}")
print(f"浅拷贝3: {shallow_copy3}")

# 修改嵌套对象
original[1][0] = 'modified'
print(f"\n修改后的原始对象: {original}")
print(f"修改后的浅拷贝1: {shallow_copy1}")  # 嵌套列表也被修改

深拷贝（Deep Copy）

深拷贝创建一个新对象，并递归地复制原始对象中的所有嵌套对象。

# 创建深拷贝
original = [1, [2, 3], {'a': 4}]
deep_copy = copy.deepcopy(original)

# 修改原始对象的嵌套元素
original[1][0] = 'modified'
original[2]['a'] = 'changed'

print(f"原始对象: {original}")
print(f"深拷贝: {deep_copy}")  # 深拷贝不受影响

不同数据类型的拷贝行为

1. 列表（List）

def demonstrate_list_copy():
    # 简单列表
    simple_list = [1, 2, 3]
    shallow = copy.copy(simple_list)
    deep = copy.deepcopy(simple_list)
    
    print("=== 简单列表 ===")
    print(f"原始: {simple_list}")
    print(f"浅拷贝: {shallow}")
    print(f"深拷贝: {deep}")
    
    # 嵌套列表
    nested_list = [1, [2, 3], [4, [5, 6]]]
    shallow = copy.copy(nested_list)
    deep = copy.deepcopy(nested_list)
    
    print("\n=== 嵌套列表 ===")
    print(f"原始: {nested_list}")
    print(f"浅拷贝: {shallow}")
    print(f"深拷贝: {deep}")
    
    # 修改嵌套元素
    nested_list[1][0] = 'X'
    print("\n=== 修改后 ===")
    print(f"原始: {nested_list}")
    print(f"浅拷贝: {shallow}")  # 受影响
    print(f"深拷贝: {deep}")     # 不受影响

demonstrate_list_copy()

2. 字典（Dictionary）

def demonstrate_dict_copy():
    # 简单字典
    simple_dict = {'a': 1, 'b': 2}
    shallow = copy.copy(simple_dict)
    deep = copy.deepcopy(simple_dict)
    
    print("=== 简单字典 ===")
    print(f"原始: {simple_dict}")
    print(f"浅拷贝: {shallow}")
    print(f"深拷贝: {deep}")
    
    # 嵌套字典
    nested_dict = {
        'a': 1,
        'b': {'x': 2, 'y': 3},
        'c': {'p': {'q': 4}}
    }
    shallow = copy.copy(nested_dict)
    deep = copy.deepcopy(nested_dict)
    
    print("\n=== 嵌套字典 ===")
    print(f"原始: {nested_dict}")
    print(f"浅拷贝: {shallow}")
    print(f"深拷贝: {deep}")
    
    # 修改嵌套元素
    nested_dict['b']['x'] = 'modified'
    print("\n=== 修改后 ===")
    print(f"原始: {nested_dict}")
    print(f"浅拷贝: {shallow}")  # 受影响
    print(f"深拷贝: {deep}")     # 不受影响

demonstrate_dict_copy()

3. 自定义对象

class Person:
    def __init__(self, name, address):
        self.name = name
        self.address = address
    
    def __repr__(self):
        return f"Person(name='{self.name}', address={self.address})"

class Address:
    def __init__(self, street, city):
        self.street = street
        self.city = city
    
    def __repr__(self):
        return f"Address(street='{self.street}', city='{self.city}')"

def demonstrate_object_copy():
    # 创建对象
    addr = Address("123 Main St", "Boston")
    person = Person("John", addr)
    
    # 创建拷贝
    shallow = copy.copy(person)
    deep = copy.deepcopy(person)
    
    print("=== 原始状态 ===")
    print(f"原始: {person}")
    print(f"浅拷贝: {shallow}")
    print(f"深拷贝: {deep}")
    
    # 修改地址
    person.address.street = "456 Oak St"
    print("\n=== 修改后 ===")
    print(f"原始: {person}")
    print(f"浅拷贝: {shallow}")  # address被修改
    print(f"深拷贝: {deep}")     # 保持不变

demonstrate_object_copy()

特殊情况和注意事项

1. 循环引用

def demonstrate_circular_reference():
    class Node:
        def __init__(self):
            self.data = None
            self.next = None
        
        def __repr__(self):
            return f"Node(data={self.data})"
    
    # 创建循环引用
    node1 = Node()
    node2 = Node()
    node1.data = 1
    node2.data = 2
    node1.next = node2
    node2.next = node1
    
    # 深拷贝可以正确处理循环引用
    copied = copy.deepcopy(node1)
    print(f"原始节点: {node1}")
    print(f"拷贝的节点: {copied}")
    print(f"是否是同一个对象: {node1 is copied}")

demonstrate_circular_reference()

2. 不可变对象

def demonstrate_immutable_copy():
    # 数字
    num = 42
    num_copy = copy.copy(num)
    print(f"数字拷贝: {num is num_copy}")  # True
    
    # 字符串
    string = "Hello"
    string_copy = copy.copy(string)
    print(f"字符串拷贝: {string is string_copy}")  # True
    
    # 元组
    tuple_simple = (1, 2, 3)
    tuple_copy = copy.copy(tuple_simple)
    print(f"简单元组拷贝: {tuple_simple is tuple_copy}")  # True
    
    # 包含可变对象的元组
    nested_tuple = (1, [2, 3], 4)
    nested_copy = copy.deepcopy(nested_tuple)
    print(f"嵌套元组深拷贝: {nested_tuple is nested_copy}")  # False

demonstrate_immutable_copy()

性能考虑

1. 拷贝性能测试

import timeit

def compare_copy_performance():
    # 准备测试数据
    simple_list = list(range(1000))
    nested_list = [list(range(10)) for _ in range(100)]
    
    # 测试不同拷贝方法的性能
    def test_assignment():
        new_list = simple_list
    
    def test_shallow_copy():
        new_list = copy.copy(simple_list)
    
    def test_deep_copy():
        new_list = copy.deepcopy(simple_list)
    
    # 执行测试
    assignment_time = timeit.timeit(test_assignment, number=10000)
    shallow_time = timeit.timeit(test_shallow_copy, number=10000)
    deep_time = timeit.timeit(test_deep_copy, number=10000)
    
    print(f"简单赋值时间: {assignment_time:.6f} 秒")
    print(f"浅拷贝时间: {shallow_time:.6f} 秒")
    print(f"深拷贝时间: {deep_time:.6f} 秒")

compare_copy_performance()

实际应用场景

1. 配置对象的复制

class Configuration:
    def __init__(self):
        self.settings = {
            'database': {
                'host': 'localhost',
                'port': 5432
            },
            'cache': {
                'enabled': True,
                'timeout': 300
            }
        }
    
    def create_test_config(self):
        # 创建配置的深拷贝用于测试
        test_config = copy.deepcopy(self)
        test_config.settings['database']['host'] = 'test-db'
        return test_config

# 使用示例
config = Configuration()
test_config = config.create_test_config()
print(f"原始配置: {config.settings}")
print(f"测试配置: {test_config.settings}")

2. 游戏状态保存

class GameState:
    def __init__(self):
        self.player = {
            'health': 100,
            'inventory': ['sword', 'shield'],
            'position': {'x': 0, 'y': 0}
        }
        self.enemies = [
            {'type': 'goblin', 'health': 50},
            {'type': 'orc', 'health': 100}
        ]
    
    def save_checkpoint(self):
        # 创建游戏状态的深拷贝作为存档点
        return copy.deepcopy(self)

# 使用示例
game = GameState()
checkpoint = game.save_checkpoint()

# 修改当前游戏状态
game.player['health'] -= 30
game.player['inventory'].append('potion')

print("当前游戏状态:", game.player)
print("存档点状态:", checkpoint.player)

最佳实践

选择合适的拷贝方式：

def choose_copy_method(data):
    # 简单的不可变对象
    if isinstance(data, (int, float, str, bool)):
        return data
    
    # 只包含不可变对象的简单容器
    if isinstance(data, (list, dict)) and all(isinstance(x, (int, float, str, bool)) for x in data):
        return copy.copy(data)
    
    # 复杂的嵌套结构
    return copy.deepcopy(data)

优化深拷贝性能：

class OptimizedObject:
    def __init__(self):
        self.immutable_data = (1, 2, 3)
        self.mutable_data = [4, 5, 6]
    
    def __deepcopy__(self, memo):
        # 自定义深拷贝行为
        new_obj = OptimizedObject()
        memo[id(self)] = new_obj
        # 不可变数据直接引用
        new_obj.immutable_data = self.immutable_data
        # 可变数据需要深拷贝
        new_obj.mutable_data = copy.deepcopy(self.mutable_data, memo)
        return new_obj

处理特殊情况：

class SpecialObject:
    def __init__(self):
        self.data = []
        self.no_copy = None  # 不需要拷贝的属性
    
    def __copy__(self):
        # 自定义浅拷贝行为
        obj = type(self)()
        obj.__dict__.update(self.__dict__)
        obj.data = self.data.copy()
        return obj
    
    def __deepcopy__(self, memo):
        # 自定义深拷贝行为
        obj = type(self)()
        memo[id(self)] = obj
        for k, v in self.__dict__.items():
            if k == 'no_copy':
                obj.__dict__[k] = v  # 直接引用
            else:
                obj.__dict__[k] = copy.deepcopy(v, memo)
        return obj

常见陷阱和解决方案

1. 循环引用处理

class Node:
    def __init__(self, data):
        self.data = data
        self.references = []
    
    def add_reference(self, node):
        self.references.append(node)
    
    def __deepcopy__(self, memo):
        if id(self) in memo:
            return memo[id(self)]
        
        new_node = Node(copy.deepcopy(self.data, memo))
        memo[id(self)] = new_node
        new_node.references = copy.deepcopy(self.references, memo)
        return new_node

2. 资源处理

class ResourceHandler:
    def __init__(self):
        self.resource = open('temp.txt', 'w')
        self.data = []
    
    def __copy__(self):
        # 创建新的资源句柄
        new_obj = type(self)()
        new_obj.data = self.data.copy()
        return new_obj
    
    def __del__(self):
        self.resource.close()

3. 性能优化

class CacheAwareObject:
    def __init__(self):
        self.expensive_data = self._compute_expensive_data()
        self._cache = {}
    
    def _compute_expensive_data(self):
        # 假设这是一个耗时的计算
        return [i ** 2 for i in range(1000)]
    
    def __deepcopy__(self, memo):
        # 避免重新计算昂贵的数据
        new_obj = type(self)()
        memo[id(self)] = new_obj
        new_obj.expensive_data = self.expensive_data  # 直接共享不可变数据
        new_obj._cache = {}  # 创建新的缓存字典
        return new_obj