深入了解赋值、深拷贝、浅拷贝

在说明之前，先丢一个问题：

import copy
t = ['a','b']
a = [1,2,3,t]
b = a
c = copy.copy(a)
d = copy.deepcopy(a)

a.append(4)
b = ?
c = ?
d = ?
t.append('c')
b = ？
c = ?
d = ?

以上三个值分别代表：直接赋值，浅拷贝，深拷贝；
如果你对上面问题的答案还不确定，接下来我们就来逐个介绍它们是什么以及其中的区别。
确认的话可以直接跳转四

一. 直接赋值与拷贝的区别

a = [11,22,33]
b = a
id(a)
-->4504216328
id(b)
-->4504216328

可以看到通过直接赋值的b和a的id相同，即变量b和a指向同一块内存地址。
我们将其与拷贝对比，如上的情况：

import  copy
a = [11,22,33]
c = copy.copy(a)
d = copy.deepcopy(a)
print(id(a))
-->4504215816
print(id(c))
-->4504352520
print(id(d))
-->4503501704

明显看到，copy和deepcopy均是指向了一个新的内存空间；

我们对a改变，观察直接赋值和copy模块的区别：

a.append(44)
print(a)
-->[11, 22, 33, 44]
print(b)
-->[11, 22, 33, 44]
print(c)
-->[11, 22, 33]
print(d)
-->[11, 22, 33]

由此可以知道，直接赋值的拷贝和原变量共享一个对象，其直接把变量的地址复制过去，得到原变量的引用，而没有去指向新的内存空间。
而copy模块则是指向了新的内存空间。

可以描述如下：

二. 浅拷贝copy与深拷贝deepcopy的区别

在上面，我们已经知道了copy模块是开辟一个新的内存空间，那么浅拷贝copy和深拷贝deepcopy有什么区别呢？
当要拷贝的对象中仍然嵌套着一个对象时,copy的内容是指向嵌套子对象的引用?
还是又开辟了新的内存空间，复制了嵌套子对象的值？
我们通过这个例子来验证一下想法：

import copy
a = [1,2,3]
b = [4,5,6]
c = [a,b]
d = copy.copy(c)
e = copy.deepcopy(c)
a.append(4)
print(c)
print(d)
print(e)

如果是拷贝指向嵌套子对象的引用，那么我们改变嵌套子对象的值，则拷贝的也会改变；
如果是拷贝的是嵌套子对象的值，那么我们改变嵌套子对象的值，则拷贝的则不会改变。
得到的结果如下：

[[1, 2, 3, 4], [4, 5, 6]]
[[1, 2, 3, 4], [4, 5, 6]]
[[1, 2, 3], [4, 5, 6]]

可以看到，copy.copy的值随着嵌套子对象a的值改变而改变，可以描述如下：

如果拷贝的可变对象中仍有嵌套的子对象，那么copy.copy就只复制一层，子对象使用之前的引用，而copy.deepcopy则会递归的拷贝对象下子对象的内容；

三. 扩展-不可变对象的copy

还是先由内存空间id开始：

a = [1,2,3]
b = [4,5,6]
c = (a,b)
d = c
e = copy.copy(c)
f = copy.deepcopy(c)

按照前面的实验，我们先猜想下print出id的结果，应该是d和c相同，因为d指向的是c的内存空间，e,f均为copy，其应该指向不同的内存空间，但是结果是：

print(id(c))
print(id(e))
print(id(f))
4502541960
4502541960
4502714696

？？？为什么copy.copy也是指向了和c相同的内存空间？
原因是：元组为不可变类型，copy.copy能够判断是否为可变类型：如果是可变类型，使用copy功能时，只完成一层拷贝；如果时不可变类型时，那使用copy类型时，就只去引用，和赋值的效果一样。
而当子对象改变时，其结果仍然是和上述相同：

print(c)
print(d)
print(e)
print(f)
([1, 2, 3, 4], [4, 5, 6])
([1, 2, 3, 4], [4, 5, 6])
([1, 2, 3, 4], [4, 5, 6])
([1, 2, 3], [4, 5, 6])

四. 前言问题的答案

对于这个问题，我们先看下原拷贝对象的结构，其由不变的值1，2，3和嵌套子对象(列表)组成，那么对于直接赋值，copy.copy，copy.deepcopy可以描述如下：

根据上面的描述，那么：
(1) 当a的固定值改变时
b引用a的地址，b的状态随着a而改变，b = [1,2,3,[‘a’,‘b’],4]
c是copy.copy，因为改变的是常量，故c的值会不变，c = [1,2,3,[‘a’,‘b’]]
d是copy.deepcopy，所有的值都是自己独有的,故d的值也不会变，
d = [1,2,3,[‘a’,‘b’]]
(2) 当a的嵌套子对象列表改变时
b引用a的地址，b的状态随着a而改变，b = [1,2,3,[‘a’,‘b’,‘c’]]
c是copy.copy，其只copy一层,对于嵌套子对象用的仍是原来的引用，故c的值会随着a而改变，
c = [1,2,3,[‘a’,‘b’,‘c’]]
d是copy.deepcopy，所有的值都是自己独有的,故d的值仍然不会变，
d = [1,2,3,[‘a’,‘b’]]

程序输出结果和推理一致：

当a的固定值改变时
[1, 2, 3, ['a', 'b'], 4]
[1, 2, 3, ['a', 'b']]
[1, 2, 3, ['a', 'b']]
当a的嵌套子对象列表改变时
[1, 2, 3, ['a', 'b', 'c']]
[1, 2, 3, ['a', 'b', 'c']]
[1, 2, 3, ['a', 'b']]

---