Python 中的深浅拷贝详解

Python 中的 浅拷贝（shallow copy） 和 深度拷贝（deep copy）。

一上来给出深、浅拷贝含义总是很迷惑的，这里会先从它们的操作方法说起，通过代码来理解两者的不同。

浅拷贝

Python 中实现浅拷贝的三种方法：

[1] >>>> 数据类型构造器

使用数据类型本身的构造器创建元素对象，是常见的浅拷贝的方法：

>>> list1 = [1, 2, 3]
>>> list2 = list(list1)
>>> print(list2)
[1, 2, 3]
>>> print("list1==list2 ?",list1==list2)
list1==list2 ? True
>>> print("list1 is list2 ?",list1 is list2)
list1 is list2 ? False
>>> set1= set([1, 2, 3])
>>> set2 = set(set1)
>>> print(set2)
{1, 2, 3}
>>> print("set1==set2 ?",set1==set2)
set1==set2 ? True
>>> print("set1 is set2 ?",set1 is set2)
set1 is set2 ? False

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

这里先不要深究浅拷贝的含义是什么，先观察其形式。

[2] >>>> 切片操作符 “：”

对于可变的序列（List），还可以通过切片操作符 “：” 来完成浅拷贝，例如：

>>> list1 = [1, 2, 3]
>>> list2 = list1[:]
>>> print(list2)
[1, 2, 3]
>>> print("list1 == list2 ?",list1 == list2)
list1 == list2 ? True
>>> print("list1 is list2 ?",list1 is list2)
list1 is list2 ? False

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

[3] >>>> Python 浅拷贝方法

Python 中提供了适用于任何数据类型的浅拷贝方法 –> copy.copy() 函数。其用法如下：

>>> import copy
>>> list1 = [1, 2, 3]
>>> list2 = copy.copy(list1)
>>> print(list2)
[1, 2, 3]
>>> print("list1 == list2 ?",list1 == list2)
list1 == list2 ? True
>>> print("list1 is list2 ?",list1 is list2)
list1 is list2 ? False

浅拷贝 >>>>

看到这里，你可能对浅拷贝有了初步的认识，这里引入浅拷贝的概念，可结合上述代码进行理解 >>>>

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

既然新对象元素是原对象子对象的引用，这意味着新对象中各个元素一一对应了原对象各子对象的引用，而原对象中各子对象数据类型是不定的，可以是可变的，也可以是不可变的，这就会产生一些问题。

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

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

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

>>> list1[0].append(3)
>>> print("list1:",list1)
list1: [[1, 2, 3], (30, 40), 100]
>>> print("list2:",list2)
list2: [[1, 2, 3], (30, 40)]

>>> list1[1] += (50, 60)
>>> print("list1:",list1)
list1: [[1, 2, 3], (30, 40, 50, 60), 100]
>>> print("list2:",list2)
list2: [[1, 2, 3], (30, 40)]

此程序中，首先初始化了 list1 列表，包含一个列表和一个元组；然后对 list1 执行浅拷贝，赋予 list2。因为浅拷贝里的元素是对原对象元素的引用，因此 list2 中的元素和 list1 指向同一个列表和元组对象。

接着往下看，list1.append(100) 表示对 list1 的列表新增元素 100。这个操作不会对 list2 产生任何影响，因为 list2 和 list1 作为整体是两个不同的对象，并不共享内存地址。操作过后 list2 不变，list1 会发生改变。

再来看，list1[0].append(3) 表示对 list1 中的第一个列表新增元素 3。因为 list2 是 list1 的浅拷贝，list2 中的第一个元素和 list1 中的第一个元素，共同指向同一个列表，因此 list2 中的第一个列表也会相对应的新增元素 3。

最后是 list1[1] += (50, 60)，因为元组是不可变的，这里表示对 list1 中的第二个元组拼接，然后重新创建了一个新元组作为 list1 中的第二个元素，而 list2 中没有引用新元组，因此 list2 并不受影响。

| >>>> ====================================================================

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

>>> tuple1 = (1, 2, 3)
>>> tuple2 = tuple(tuple1)
>>> print(tuple2)
(1, 2, 3)
>>> print("tuple1 == tuple2 ?",tuple1 == tuple2)
tuple1 == tuple2 ? True
>>> print("tuple1 is tuple2 ?",tuple1 is tuple2)
tuple1 is tuple2 ? True

>>> tuple3 = tuple1[:]
>>> print("tuple1 == tuple3 ?",tuple1 == tuple3)
tuple1 == tuple3 ? True
>>> print("tuple1 is tuple3 ?",tuple1 is tuple3)
tuple1 is tuple3 ? True

可以看到，元组 (1, 2, 3) 只被创建一次，t1 和 t2 同时指向这个元组。

可以想到对于字符串其 tuple() 或者切片操作符 ‘:’ 也是一样的，这是由于 str && tuple 是不可变对象，

==================================================================== <<<< |

---

通过上面浅拷贝的例子，你可以很清楚地看到使用浅拷贝可能带来的副作用。那么，怎么办？？？

浅拷贝

如果想避免拷贝可能带来的副作用，完整地拷贝一个新对象，而且对新对象中元素的操作不会影响到原对象，就需要使用深拷贝 >>>>

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

也就是说，通过深拷贝可以使得新对象和原对象没有任何关联！！！

那么，如何再 Python 中实现深拷贝呢？ >>>>

[1] >>>> Python 深拷贝方法

Python 中以 copy.deepcopy() 来实现对象的深度拷贝：

>>> import copy
>>> list1 = [[1, 2], (30, 40)]
>>> list2 = copy.deepcopy(list1)
>>> list1.append(100)
>>> print("list1:",list1)
list1: [[1, 2], (30, 40), 100]
>>> print("list2:",list2)
list2: [[1, 2], (30, 40)]
>>> list1[0].append(3)
>>> print("list1:",list1)
list1: [[1, 2, 3], (30, 40), 100]
>>> print("list2:",list2)
list2: [[1, 2], (30, 40)]
>>> list1[1] += (50, 60)
>>> print("list1:",list1)
list1: [[1, 2, 3], (30, 40, 50, 60), 100]
>>> print("list2:",list2)
list2: [[1, 2], (30, 40)]

可以看到，无论 list1 如何变化，list2 都不变。因为此时的 list1 和 list2 完全独立，没有任何联系（通过深拷贝实现了解耦）。

---

[2] >>>> 深拷贝无限循环问题

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

>>> list1 = [1]
>>> list1.append(list1)
>>> print(list1)
[1, [...]]
>>> list2 = copy.deepcopy(list1)
>>> print(list2)
[1, [...]]

此例子中，列表 x 中有指向自身的引用，因此 x 是一个无限嵌套的列表。

但是当深度拷贝 x 到 y 后，程序并没有出现栈溢出的现象。这是为什么呢？

其实，这是因为深度拷贝函数 deepcopy 中会维护一个字典，记录已经拷贝的对象与其 ID。拷贝过程中，如果字典里已经存储了将要拷贝的对象，则会从字典直接返回。

---