Python教程：一文了解Python的深拷贝与浅拷贝_python 深拷贝

一.深拷贝与浅拷贝

---

理解 Python 中的深拷贝（deep copy）和浅拷贝（shallow copy）是非常重要的，特别是在处理嵌套结构的数据时。让我们深入探讨这两个概念，并通过代码示例进行说明。

1. 浅拷贝（Shallow Copy）：

浅拷贝创建一个新的对象，但是这个新对象中的子对象是原始对象中子对象的引用。换句话说，只拷贝了对象的第一层结构，而深层嵌套的对象则共享引用。

import copy
 
# 原始列表
original_list = [[1, 2, 3], [4, 5, 6]]
 
# 浅拷贝
shallow_copy = copy.copy(original_list)
 
# 修改原始列表的子列表
original_list[0][0] = 100
 
print("Original List:", original_list)
print("Shallow Copy:", shallow_copy)
'
运行
运行

输出结果为：

Original List: [[100, 2, 3], [4, 5, 6]]
Shallow Copy: [[100, 2, 3], [4, 5, 6]]

在这个例子中，虽然我们只修改了原始列表的子列表，但是浅拷贝的结果也受到了影响，因为浅拷贝只复制了第一层结构，而子列表仍然是原始对象中子列表的引用。

2. 深拷贝（Deep Copy）：

深拷贝创建一个完全独立的新对象，包括对象中的所有子对象。无论有多少层嵌套，都会被完整复制，而不是共享引用。

import copy
 
# 原始列表
original_list = [[1, 2, 3], [4, 5, 6]]
 
# 深拷贝
deep_copy = copy.deepcopy(original_list)
 
# 修改原始列表的子列表
original_list[0][0] = 100
 
print("Original List:", original_list)
print("Deep Copy:", deep_copy)
'
运行
运行

输出结果为：

Original List: [[100, 2, 3], [4, 5, 6]]
Deep Copy: [[1, 2, 3], [4, 5, 6]]

在这个例子中，深拷贝创建了一个独立的新对象，即使修改了原始列表的子列表，深拷贝的结果也不受影响。

总结：

• 浅拷贝只复制对象的第一层结构，深拷贝复制了对象的所有层级结构。
• 浅拷贝会共享引用，而深拷贝则创建完全独立的新对象。
• 使用 copy 模块的 copy() 函数进行浅拷贝，使用 copy.deepcopy() 函数进行深拷贝。

何时使用浅拷贝和深拷贝？

• 使用浅拷贝当你只关心顶层结构，而不关心嵌套对象的修改是否会影响原始对象。
• 使用深拷贝当你需要创建一个原始对象的完整独立副本，以便修改副本不影响原始对象。

二.可变对象与不可变对象

---

在Python中，对象可以分为可变对象（mutable objects）和不可变对象（immutable objects）。这两种对象类型在内存中的行为有着重要的差异，理解它们对于编写高效的Python代码至关重要。

不可变对象（Immutable Objects）：

不可变对象指的是在创建后无法修改其值或状态的对象。每次对不可变对象进行修改时，实际上是创建了一个新的对象。Python中的不可变对象包括但不限于以下几种：

• 整数（int）
• 浮点数（float）
• 复数（complex）
• 字符串（str）
• 元组（tuple）

特点：

1. 不可变对象的值或状态在创建后不可修改。
2. 每次对不可变对象进行修改时，都会创建一个新的对象。

# 示例：不可变对象
a = 10  # 整数是不可变对象
b = a   # b指向a所指向的对象（10）
a = 20  # 创建新的对象20，并让a指向新对象
print(a)  # 输出 20
print(b)  # 输出 10，b仍然指向原始对象10
'
运行
运行

可变对象（Mutable Objects）：

可变对象是在创建后可以修改其值或状态的对象。对可变对象的修改不会创建新的对象，而是直接在原始对象上进行操作。Python中的可变对象包括但不限于以下几种：

• 列表（list）
• 字典（dict）
• 集合（set）
• 用户自定义的类（class）

特点：

1. 可变对象的值或状态可以在创建后被修改。
2. 对可变对象的修改会直接影响原始对象，不会创建新的对象。

# 示例：可变对象
list_a = [1, 2, 3]  # 列表是可变对象
list_b = list_a     # list_b指向list_a所指向的对象（[1, 2, 3]）
list_a.append(4)    # 直接修改list_a所指向的对象，不创建新的对象
print(list_a)       # 输出 [1, 2, 3, 4]
print(list_b)       # 输出 [1, 2, 3, 4]，list_b指向的对象也被修改了
'
运行
运行

三.字典深拷贝示例

---

下面是一个完整的示例，演示了如何进行深拷贝一个包含复杂结构的Python字典

import copy
 
# 原始字典
original_dict = {
    'name': 'John',
    'age': 30,
    'address': {
        'city': 'New York',
        'zipcode': '10001'
    },
    'emails': ['john@example.com', 'john.doe@example.com']
}
 
# 执行深拷贝
deep_copy_dict = copy.deepcopy(original_dict)
 
# 修改原始字典中的某些值
original_dict['name'] = 'Jane'
original_dict['address']['city'] = 'Los Angeles'
original_dict['emails'].append('jane@example.com')
 
# 打印原始字典和深拷贝后的字典
print("Original Dictionary:")
print(original_dict)
print("\nDeep Copied Dictionary:")
print(deep_copy_dict)
'
运行
运行

输出结果：

Original Dictionary:
{'name': 'Jane', 'age': 30, 'address': {'city': 'Los Angeles', 'zipcode': '10001'}, 'emails': ['john@example.com', 'john.doe@example.com', 'jane@example.com']}
 
Deep Copied Dictionary:
{'name': 'John', 'age': 30, 'address': {'city': 'New York', 'zipcode': '10001'}, 'emails': ['john@example.com', 'john.doe@example.com']}

解释：

1. 我们首先定义了一个包含复杂结构的原始字典 original_dict，其中包括字符串、整数、嵌套字典和列表。
2. 使用 copy.deepcopy() 函数对原始字典进行深拷贝，得到了一个完全独立的新字典 deep_copy_dict。
3. 修改原始字典中的一些值，包括姓名、地址和电子邮件列表。
4. 打印原始字典和深拷贝后的字典，可以看到原始字典的修改不会影响深拷贝后的字典。