python

在Python中，使用“=”运算符创建对象的副本。初学者可能会认为这种方式会创建一个新对象，但其实并非如此，仅创建一个共享原始对象引用的新变量。例如，先创建一个名为old_list的列表，再使用“=”运算符将对象引用传递给新列表new_list：

1. >>> old_list = [[1, 2, 3], [4, 5, 6], [7, 8, 'a']]
2. >>> new_list = old_list # 创建对象的副本
3. >>> new_list[2][2] = 9 # 修改新列表
4. >>> print(old_list) # 打印旧列表，也改变了
5. [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
6. >>> id(old_list) # id()内建函数,用于获取对象的内存地址
7. 4425086088
8. >>> print(new_list) # 打印新列表
9. [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
10. >>> id(new_list)
11. 4425086088

由此可见，变量old_list和new_list共享相同的ID，即4425086088;new_list修改了，old_list也随之改变了。

在Python中，有两种创建副本的方法：copy模块中的深拷贝和浅拷贝。

(1)浅拷贝

浅拷贝创建一个新对象，该对象存储原始对象的引用。因此，浅拷贝不会创建嵌套对象的副本，而仅复制嵌套对象的引用。这意味着复制过程不会递归或创建嵌套对象本身的副本。下面是一个浅拷贝的示例：

1. >>> import copy # 导入copy模块
2. >>> old_list = [[1, 1, 1], [2, 2, 2], [3, 3, 3]]
3. >>> new_list = copy.copy(old_list) # 浅拷贝
4. >>> print(old_list)
5. [[1, 1, 1], [2, 2, 2], [3, 3, 3]]
6. >>> print(new_list)
7. [[1, 1, 1], [2, 2, 2], [3, 3, 3]]

在上述示例中，首先创建了一个嵌套列表old_list，然后使用copy()函数对old_list进行浅拷贝，这意味着它将创建具有相同内容的新的独立对象。new_list包含对存储在old_list中的原始嵌套对象的引用。为了确认new_list与old_list不同，尝试将新列表追加到old_list并进行检查：

1. >>> old_list.append([4, 4, 4]) # 向old_list中追加一个新列表
2. >>> print(old_list) # old_list中添加了新项
3. [[1, 1, 1], [2, 2, 2], [3, 3, 3], [4, 4, 4]]
4. >>> print(new_list) # new_list中没有添加新项
5. [[1, 1, 1], [2, 2, 2], [3, 3, 3]]

由此可知，将新列表(即[4，4，4])追加到old_list中，这个新的子列表未复制到new_list中。

但是，当更改old_list中的任何嵌套对象时，更改将显示在new_list中：

1. >>> old_list[1][1] = 'AA'
2. >>> print(old_list) # old_list进行更改
3. [[1, 1, 1], [2, 'AA', 2], [3, 3, 3], [4, 4, 4]]
4. >>> print(new_list) # new_list也随之更改
5. [[1, 1, 1], [2, 'AA', 2], [3, 3, 3]]

对old_list进行了更改(即old_list [1] [1] ='AA')，old_list和new_list的索引[1] [1]上的值均已更改，这是由于两个列表共享相同嵌套对象的引用。使用深拷贝可以解决这个“问题”。

(2)深拷贝

深层副本会创建一个新对象，然后递归地添加原始对象中存在的嵌套对象的副本。继续浅拷贝中的示例，这次将使用deepcopy()函数创建深拷贝。深拷贝创建原始对象及其所有嵌套对象的独立副本：

1. >>> import copy
2. >>> old_list = [[1, 1, 1], [2, 2, 2], [3, 3, 3]]
3. >>> new_list = copy.deepcopy(old_list) # 深拷贝
4. >>> print(old_list)
5. [[1, 1, 1], [2, 2, 2], [3, 3, 3]]
6. >>> print(new_list)
7. [[1, 1, 1], [2, 2, 2], [3, 3, 3]]

使用deepcopy()函数创建外观相似的副本，这和浅拷贝一样。但是如果对原始对象old_list中的任何嵌套对象进行更改，并不会对副本new_list进行相应更改：

1. >>> old_list[1][0] = 'BB'
2. >>> print(old_list)
3. [[1, 1, 1], ['BB', 2, 2], [3, 3, 3]]
4. >>> print(new_list)
5. [[1, 1, 1], [2, 2, 2], [3, 3, 3]]

为old_list分配新值时，只有old_list被更改了，这意味着old_list和new_list都是独立的。这是由于对old_list进行的是递归复制，所有嵌套对象都适用。