【1】浅拷贝#

• 浅拷贝仅复制对象的一层内容，如果对象中包含了可变数据类型（如列表、字典等），则拷贝的对象将与原对象共享这些可变数据类型的引用。
• 这意味着对于原对象中的可变数据类型进行修改操作时，拷贝的对象也会受到影响。

1
import copy
2

3
# 原对象
4
original_list = [1, 2, [3, 4]]
5
# 使用浅拷贝创建拷贝对象
6
copied_list = copy.copy(original_list)
7

8
# 修改原对象中的可变数据类型
9
original_list[2].append(5)
10

11
print("原对象：", original_list)
12
print("拷贝对象：", copied_list)

• 可以看到，尽管只修改了原对象中的可变数据类型（子列表），但拷贝对象也被修改了。
• 这是因为浅拷贝仅复制了列表的第一层，而对于内部的子列表，拷贝对象和原对象共享同一个引用。

1
from copy import copy
2

3
list_original = [1, 2, 3, [4, 5, 6, ]]
4

5
# 使用`copy()`函数进行浅拷贝时,创建了一个新的列表对象`list_copy_two`,并复制了原始列表`list_original`中的元素。
6
# 这意味着`list_copy_two`和`list_original`是两个独立的对象,分别指向不同的内存地址。
7
list_copy_two = copy(list_original)
8

9
# 对于嵌套的可变对象（如列表）,浅拷贝只会复制其引用，而不会创建新的内存空间。
10
print(list_copy_two is list_original)
11
# False
12

13
# 因此，`list_copy_two`中的嵌套列表仍然指向相同的地址
14
# 所以对`list_copy_two`中嵌套的列表进行修改 ， 也会影响到原始的列表`list_original`。
15
list_copy_two[3][1] = 999
16
print(list_original)
17
# [1, 2, 3, [4, 999, 6]]
18
print(list_copy_two)
19
# [1, 2, 3, [4, 999, 6]]

• 使用copy()函数进行浅拷贝时
  • 创建了一个新的列表对象list_copy_two,并复制了原始列表list_original中的元素。
  • 这意味着llist_copy_two和list_original是两个独立的对象,分别指向不同的内存地址。
• 然而，对于嵌套的可变对象（如列表）
  • 浅拷贝只会复制其引用
  • 而不会创建新的内存空间。
• 因此，list_copy_two中的嵌套列表仍然指向相同的地址
  • 所以对list_copy_two中嵌套的列表进行修改
  • 也会影响到原始的列表list_original。

（2）深拷贝#

• 深拷贝会创建一个完全独立的新对象，包括所有的嵌套对象。
• 无论原对象的数据类型是可变还是不可变，深拷贝都会创建出新的对象，以后对原对象的修改不会影响到拷贝对象。
• 以下是一个使用深拷贝的案例：

1
import copy
2

3
# 原对象
4
original_list = [1, 2, [3, 4]]
5
# 使用深拷贝创建拷贝对象
6
copied_list = copy.deepcopy(original_list)
7

8
# 修改原对象中的可变数据类型
9
original_list[2].append(5)
10

11
print("原对象：", original_list)
12
print("拷贝对象：", copied_list)

• 可以看到，尽管修改了原对象中的可变数据类型，但拷贝对象保持不变。
• 这是因为深拷贝创建了一个原对象完全独立的新对象，包括了所有嵌套对象的复制。

1
from copy import deepcopy
2

3
list_original = [1, 2, 3, [4, 5, 6, ]]
4
list_deep_copy = deepcopy(list_original)
5
list_deep_copy[3][1] = 888
6
print(list_original)
7
# [1, 2, 3, [4, 5, 6]]
8
print(list_deep_copy)
9
# [1, 2, 3, [4, 888, 6]]

• 通过使用deepcopy()函数进行深拷贝,会递归地复制嵌套对象，包括嵌套列表。
• 这意味着在深拷贝操作中不仅会创建一个新的顶层列表对象list_deep_copy,还会创建一个新的嵌套列表对象,并且其值与原始列表中的值相同。
• 因此在对list_deep_copy中的嵌套列表进行修改时，并不会影响到原始的列表list_original，它们指向不同的内存地址。

（3）小结#

• 综上所述
  • 浅拷贝只复制顶层对象
  • 而深拷贝会递归复制整个对象结构。
• 在涉及到可变对象嵌套的情况下
  • 深拷贝是一种更安全的选项
  • 因为它可以确保对新对象的修改不会影响原始对象。

（1）深拷贝：#

• 深拷贝是指创建一个新的对象，该对象与原始对象完全独立。
• 换句话说，它会递归地复制所有嵌套对象，包括它们的内容，以便我们在修改新对象时不会影响到原始对象。
• 下面是一个示例
  • 演示了如何使用copy模块中的deepcopy()函数进行深拷贝：

1
import copy
2

3
list1 = [1, 2, [3, 4]]
4
list2 = copy.deepcopy(list1)

• 在这个例子中，我们创建了一个列表list1，其中包含一个嵌套列表。
• 通过调用deepcopy()函数并将list1作为参数传递给它，我们可以创建一个名为list2的新对象，它是list1的深拷贝。
• 现在，我们来演示深拷贝是如何避免原始对象的修改的：

1
list2[0] = 999
2
print(list1)  # 输出: [1, 2, [3, 4]]
3
print(list2)  # 输出: [999, 2, [3, 4]]

• 可以看到，尽管我们修改了list2的第一个元素，但list1保持不变。
• 这是因为list1和list2是独立的对象，它们各自占用着不同的内存空间。

（2）浅拷贝：#

• c
• 下面是一个示例
  • 演示了如何使用copy模块中的copy()函数进行浅拷贝：

1
import copy
2

3
list1 = [1, 2, [3, 4]]
4
list2 = copy.copy(list1)

• 在这个例子中
  • 我们使用copy()函数创建了list1的浅拷贝list2。
• 让我们来看一下浅拷贝在修改可变对象时的行为：

1
list2[0] = 999
2
list2[2][0] = 777
3
print(list1)  # 输出: [1, 2, [777, 4]]
4
print(list2)  # 输出: [999, 2, [777, 4]]

• 可以看到
  • 当我们修改list2中的第一个元素时
  • 只有list2受到影响
  • 而list1保持不变。
• 但是
  • 当我们修改list2中嵌套列表的元素时
  • list1也会随之改变。
• 这是因为浅拷贝只复制了列表的引用
  • 而没有创建新的内存空间来存储嵌套列表。

（3）综上所述#

• 深拷贝和浅拷贝在处理对象和数据结构时有不同的行为：
  • 深拷贝创建一个完全独立的对象，递归地复制所有嵌套对象。
  • 浅拷贝创建一个新对象，但它共享原始对象中可变对象的引用。