Python深拷贝和浅拷贝

浅拷贝，指的是重新分配一块内存，创建一个新的对象，但里面的元素是原对象中各个子对象的引用。

深拷贝，是指重新分配一块内存，创建一个新的对象，并且将原对象中的元素，以递归的方式，通过创建新的子对象拷贝到新对象中。

浅拷贝（copy.copy()，append(),切片操作符“：”,类型本身的构造器）

常见的浅拷贝的方法，是使用数据类型本身的构造器

#列表--------------------------------
list1 = [1, 2, 3]
list2 = list(list1)

print(list2)
print("list1==list2 ?",list1==list2)
print("list1 is list2 ?",list1 is list2)

结果：
[1, 2, 3]
list1==list2 ? True
list1 is list2 ? False

#集合--------------------------------
set1= set([1, 2, 3])
set2 = set(set1)

print(set2)
print("set1==set2 ?",set1==set2)
print("set1 is set2 ?",set1 is set2)

结果：
{1, 2, 3}
set1==set2 ? True
set1 is set2 ? False

在上面程序中，list2 就是 list1 的浅拷贝，同理 set2 是 set1 的浅拷贝。

当然，对于可变的序列，还可以通过切片操作符“：”来完成浅拷贝

list1 = [1, 2, 3]
list2 = list1[:]

print(list2)
print("list1 == list2 ?",list1 == list2)
print("list1 is list2 ?",list1 is list2)

运行结果为：
[1, 2, 3]
list1 == list2 ? True
list1 is list2 ? False

除此之外，Python 还提供了对应的函数 copy.copy() 函数，适用于任何数据类型。

import copy

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

print(list2)
print("list1 == list2 ?",list1 == list2)
print("list1 is list2 ?",list1 is list2)

运行结果为：
[1, 2, 3]
list1 == list2 ? True
list1 is list2 ? False

对于元组，使用 tuple() 或者切片操作符 ':' 不会创建一份浅拷贝，相反它会返回一个指向相同元组的引用：

tuple1 = (1, 2, 3)
tuple2 = tuple(tuple1)

print(tuple2)
print("tuple1 == tuple2 ?",tuple1 == tuple2)
print("tuple1 is tuple2 ?",tuple1 is tuple2)

运行结果为：
(1, 2, 3)
tuple1 == tuple2 ? True
tuple1 is tuple2 ? True

此程序中，元组 (1, 2, 3) 只被创建一次，t1 和 t2 同时指向这个元组。

对数据采用浅拷贝的方式时，如果原对象中的元素不可变，那倒无所谓；但如果元素可变，浅拷贝通常会出现一些问题

list1 = [[1, 2], (30, 40)]
list2 = list(list1)

print("list1:",list1)
print("list2:",list2)

list1.append(100)

print("list1:",list1)
print("list2:",list2)

运行结果为：
list1: [[1, 2], (30, 40)]
list2: [[1, 2], (30, 40)]
list1: [[1, 2], (30, 40), 100]
list2: [[1, 2], (30, 40)]

#-----------------------------
list1[0].append(3)
print("list1:",list1)
print("list2:",list2)

运行结果为：
list1: [[1, 2, 3], (30, 40), 100]
list2: [[1, 2, 3], (30, 40)]

#-----------------------------
list1[1] += (50, 60)
print("list1:",list1)
print("list2:",list2)

运行结果为：
list1: [[1, 2, 3], (30, 40, 50, 60), 100]
list2: [[1, 2, 3], (30, 40)]

深拷贝copy.deepcopy()

如果想避免这种副作用，完整地拷贝一个对象，就需要使用深拷贝。所谓深拷贝，是指重新分配一块内存，创建一个新的对象，并且将原对象中的元素，以递归的方式，通过创建新的子对象拷贝到新对象中。因此，新对象和原对象没有任何关联。

import copy

list1 = [[1, 2], (30, 40)]
list2 = copy.deepcopy(list1)
list1.append(100)
print("list1:",list1)
print("list2:",list2)

 结果：
list1: [[1, 2], (30, 40), 100]
list2: [[1, 2], (30, 40)]

list1[0].append(3)
print("list1:",list1)
print("list2:",list2)

结果：
list1: [[1, 2, 3], (30, 40), 100]
list2: [[1, 2], (30, 40)]

list1[1] += (50, 60)
print("list1:",list1)
print("list2:",list2)

运行结果为：
list1: [[1, 2, 3], (30, 40, 50, 60), 100]
list2: [[1, 2], (30, 40)]

无论 list1 如何变化，list2 都不变。因为此时的 list1 和 list2 完全独立，没有任何联系。

深度拷贝也不是完美的，往往也会带来一系列问题。如果被拷贝对象中存在指向自身的引用，那么程序很容易陷入无限循环。

import copy

list1 = [1]
list1.append(list1)

print(list1)

list2 = copy.deepcopy(list1)

print(list2)

运行结果为：
[1, [...]]
[1, [...]]