python深拷贝及浅拷贝详解

简单粗暴从例子先看的，然后再详解深拷贝及浅拷贝两个概念~

浅拷贝：

栗子1

list1 = [1,2,3]
list2 = list(list1) #这里就是浅拷贝,也可以写作下面两种写法
#list2 = list1[:]
#list2 = copy.copy(list1)
print(list2)
print("list1==list2 ?",list1==list2)
print("list1 is list2 ?",list1 is list2)

结果1：

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

但是有一个特殊的数据结构就是元组tuple，如果使用tuple()或者切片操作":"，或者copy.copy()，并不会创建一份浅拷贝，会创建一个指相同元组的引用：

栗子2

import copy
tuple1 = (1, 2, 3)
tuple2 = copy.copy(tuple1)
print(tuple2)
print("tuple1 == tuple2 ?",tuple1 == tuple2)
print("tuple1 is tuple2 ?",tuple1 is tuple2)

结果2

(1, 2, 3)
tuple1 == tuple2 ? True
tuple1 is tuple2 ? True

结论：

简单来讲，**浅拷贝是指重新分配一块内存，创建一个新的对象，里面的元素是原对象中各个子对象的引用。**如果数据采用浅拷贝方式，如果原来对象元素不改变，采用浅拷贝不会出现错误；如果元素可变，则会出现一些问题。

栗子3

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

list1.append(100)
print("list1:",list1)
print("list2:",list2)

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

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

结果3：

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

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

list1: [[1, 2, 3], (30, 40, 50, 60), 100]
list2: [[1, 2, 3], (30, 40)]

1）初始化list1,包含一个list[1,2]和一个元组（30,40）,list2是对list1的浅拷贝，此时与list1元素一致；
2）list1添加了元素，并没有改变其中的元素，所以list2并没有变化，因为两者为不同对象，不共享内存。
3）list1改变了第一个元素，这时list2第一个元素也改变，因为两者共同指向同一个元素;
4）list1改变了其为元组的元素，因为元组是不可变的，这里表示对 list1 中的第二个元组拼接，然后重新创建了一个新元组作为 list1 中的第二个元素，而 list2 中没有引用新元组，因此 list2 并不受影响。

深拷贝

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

深拷贝通过copy.deepcopy()实现：

import copy
list1 = [[1, 2], (30, 40)]
list2 = copy.deepcopy(list1)

list1.append(100)
print("list1:",list1)
print("list2:",list2)

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

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

结果：

list1: [[1, 2], (30, 40), 100]
list2: [[1, 2], (30, 40)]
list1: [[1, 2, 3], (30, 40), 100]
list2: [[1, 2], (30, 40)]
list1: [[1, 2, 3], (30, 40, 50, 60), 100]
list2: [[1, 2], (30, 40)]

不过深拷贝需要注意的点，如果被拷贝对象中存在指向自身的引用，那么程序很容易陷入无限循环，例如：

import copy
list1 = [1]
list1.append(list1)
print(list1)

list2 = copy.deepcopy(list1)
print(list2)

结果

[1, [...]]
[1, [...]]

此例子中，列表 x 中有指向自身的引用，因此 x 是一个无限嵌套的列表。但是当深度拷贝 x 到 y 后，程序并没有出现栈溢出的现象。这是为什么呢？

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

def deepcopy(x, memo=None, _nil=[]):
    """Deep copy operation on arbitrary Python objects.
       
    See the module's __doc__ string for more info.
    """
   
    if memo is None:
        memo = {}
    d = id(x) # 查询被拷贝对象 x 的 id
    y = memo.get(d, _nil) # 查询字典里是否已经存储了该对象
    if y is not _nil:
        return y # 如果字典里已经存储了将要拷贝的对象，则直接返回
        ...