所谓拷贝，就是复制。
深拷贝，就是复制的比较多，浅拷贝，就是复制的比较少。
在Python中，copy.copy可以完成浅拷贝，copy.deepcopy可以完成深拷贝。

举例 图解

1.赋值

如果 a = [11,22]， 把a赋给b：

In [1]: a = [11, 22]
In [2]: b = a

In [3]: a
Out[3]: [11, 22]

In [4]: b
Out[4]: [11, 22]

从结果来看是看不出来a和b是否是同一个，我们用id()函数查看一下a和b的id：

In [5]: id(a)
Out[5]: 2293026594376

In [6]: id(b)
Out[6]: 2293026594376

a 和 b的id相同，说明他们指向了同一块区域，这里说指向，是因为在Python中，实际上是有一个空间存储了[11, 22]，在给a赋值的时候，变量名a就指向了[11,22]的空间，当把a赋给b的时候，实际上是让b也指向[11,22]。
画图来说明是这样的：

image.png

2.浅拷贝

在python中，copy.copy()可以用来浅拷贝，copy.deepcopy()可以用来深拷贝。

重新定义了a，b，然后把a和b作为一个列表赋给c。

In [11]: a = [11,22]

In [12]: b = [33,44]

In [13]: c = [a, b]

这时候相当于：

image.png

验证一下：
如果a与c[0]的id相同，就说明他们指向的是相同的区域。

In [14]: id(a)
Out[14]: 2293027197896

In [15]: id(c[0])
Out[15]: 2293027197896

如果现在把c赋给d：

In [16]: d = c

这相当于：

image.png

验证一下：

In [17]: id(d)
Out[17]: 2293026531656

In [18]: id(c)
Out[18]: 2293026531656

如果这时候把c浅拷贝给e：

In [19]: import copy

In [20]: e = copy.copy(c)

这时候，e会指向一块新开辟的区域。

image.png

因为是浅拷贝，所以e的这块区域也会指向c的区域的指向，也就是这样：

image.png

验证：

In [21]: id(e)
Out[21]: 2293027309192

In [22]: id(c)
Out[22]: 2293026531656

In [23]: id(e[0])
Out[23]: 2293027197896

In [24]: id(c[0])
Out[24]: 2293027197896

e和c的地址不同，说明e和c指向的区域不一样，e[0]和c[0]的id相同，说明他们指向了同一块空间。
这就是浅拷贝，它只拷贝了第一层，第二层以下的数据并没有真的“拷贝”出来。
当前的a，b和c，e：

In [25]: a
Out[25]: [11, 22]

In [26]: b
Out[26]: [33, 44]

In [27]: c
Out[27]: [[11, 22], [33, 44]]

In [28]: e
Out[28]: [[11, 22], [33, 44]]

因为是浅拷贝，所以如果a修改了，e也会修改。

In [30]: a
Out[30]: [11, 22, 'hahaha']

In [31]: c
Out[31]: [[11, 22, 'hahaha'], [33, 44]]

In [32]: e
Out[32]: [[11, 22, 'hahaha'], [33, 44]]

a = [11,22] c = [a,b]，再来看看深拷贝。

3.深拷贝

如果是深拷贝，就原原本本的把所有层的数据都拷贝一份新的，指向也指向这份新的数据。

In [44]: f = copy.deepcopy(c)

In [45]: c
Out[45]: [[11, 22], [33, 44]]

In [46]: f
Out[46]: [[11, 22], [33, 44]]

这时候的指向是这样的：

image.png

验证：
如果c和f，c[0]和f[0]的地址不同，说明是这样的。

In [47]: id(c)
Out[47]: 2293026784840

In [48]: id(f)
Out[48]: 2293027611400

In [49]: id(c[0])
Out[49]: 2293027354312

In [50]: id(f[0])
Out[50]: 2293027035208

4.总结

所以不管是copy还是deepcopy，都会先创建一份新的空间，而直接赋值b=a则不会。

几个问题

1.问题1

前提如下：

In [53]: a = [11,22]

In [54]: b = [33,44]

In [55]: c = [a, b]

In [56]: d = copy.copy(c)

In [57]: e = copy.deepcopy(c)

如果这时候在c中append一个新的列表[55,66]d和e会如何变化？
查看结果：

In [58]: c.append([55,66])

In [59]: d
Out[59]: [[11, 22], [33, 44]]

In [60]: e
Out[60]: [[11, 22], [33, 44]]

原因图解如下：
一开始的指向是这样的：

image.png

或者把d放在上面更直观一些：

image.png

image.png

问题2

前提：

In [70]: a = (11,22)

In [71]:  b = copy.copy(a)

把a浅拷贝给b，这时候a是一个元组。
来查看a和b的id：

In [73]: id(a)
Out[73]: 2293027979080

In [74]: id(b)
Out[74]: 2293027979080

发现他们的地址是一样的。
所以如果浅拷贝发现拷贝对象是一个元组，就直接不拷贝了，变为了指向。
因为元组是不可变类型，数据不会被修改。
如果是深拷贝：

In [75]: c = copy.deepcopy(a)

这时候查看c的id和a的id：

In [76]: id(c)
Out[76]: 2293027979080

In [77]: id(a)
Out[77]: 2293027979080

他们的地址相同，说明深拷贝也没有拷贝。
再看一种情况：

In [79]: a = [11,22]

In [80]: b = [33,44]

In [81]: c = (a,b)

In [82]: d = copy.copy(c)

In [83]: e = copy.deepcopy(c)

此时a和b都是可变的列表，c是不可变的元组，d有了c的浅拷贝，e有了d的深拷贝。
这时候d和e有没有拷贝c？
来查看一下id：

In [84]: id(c)
Out[84]: 2293028072520

In [85]: id(d)
Out[85]: 2293028072520

In [86]: id(e)
Out[86]: 2293027609416

说明浅拷贝还是没有拷贝，还是指向，但深拷贝拷贝了。
所以：

• 如果拷贝的是一个元组（第一层是元组），而且元组中都是不可变对象，那么copy模块不管是深拷贝还是浅拷贝都变为了指向（引用）。
• 如果拷贝的是一个元组（第一层是元组），不管元组中的对象可变还是不可变，浅拷贝都直接指向，而不开辟新的空间了。
• 如果拷贝的是一个元组（第一层是元组），元组中有可变对象，那么深拷贝还是会开辟新的空间，把每一层的数据都拷贝了。
• 所以当深拷贝的时候，如果每一层的元素都是不可变对象，那深拷贝也不拷贝了，变为了指向，但是不管哪一层的数据，只要有一个是可变对象，那么深拷贝就会递归的把所有的数据都拷贝一份。

问题3

切片是浅拷贝。

In [88]: a = [11,22]

In [89]: b = [33,44]

In [90]: c = [a,b]

In [91]: d = c[:]

In [92]: id(c)
Out[92]: 2293027355592

In [93]: id(d)
Out[93]: 2293026561416

In [94]: a.append("lalala")

In [95]: a
Out[95]: [11, 22, 'lalala']

In [96]: c
Out[96]: [[11, 22, 'lalala'], [33, 44]]

In [97]: d
Out[97]: [[11, 22, 'lalala'], [33, 44]]

问题4

字典中的拷贝。
字典有一个copy方法，用法如下：

dict.copy()

这个拷贝是一个浅拷贝。

In [100]: first = {"a":[1,2],"b":33}

In [101]: second = first.copy()

查看一下两个字典：

In [102]: first
Out[102]: {'a': [1, 2], 'b': 33}

In [103]: second
Out[103]: {'a': [1, 2], 'b': 33}

如果这时候[11,22]列表中添加一个新的值3，再查看一下：

In [104]: first['a'].append(3)

In [105]: first
Out[105]: {'a': [1, 2, 3], 'b': 33}

In [106]: second
Out[106]: {'a': [1, 2, 3], 'b': 33}

说明是浅拷贝。
补充说明：
字典的key是保存在字典里的，value才是指向。

image.png

补充说明：

在python中，像11这样的值的类型的数据在只会创建一个，所以如果a=[11,22],b=[11,22]，实际指向是这样的：

image.png