内存的浅拷贝和深拷贝是面试时经常被问到的问题，如果不能理解其本质原理，有可能会答非所问，给面试官留下不好的印象。另外，理解浅拷贝和深拷贝的原理，还可以帮助我们理解Python内存机制。这篇文章将会通过一些例子，来验证内存拷贝的过程，帮助大家理解内存拷贝的原理。
Python3中的数据类型
我们首先得知道Python3中的数据被分为可变类型和不可变类型
- 可变类型：Number(数字)、String(字符串)、Tuple(元祖)
- 不可变类型：List(列表)、Dictionary(字典)、Set(集合)
对于可变类型和不可变类型，它们在浅拷贝和深拷贝中的表现是不一样的，下面我们就通过具体的例子来引出对应的结论。
浅拷贝
我们先来贴一个例子，然后大家可以先思考下结果会是怎样的。
def shadow_copy_test():
"""
对浅copy进行验证
:return:
"""
# 不可变数据类型
param_a = 17
param_b = "paramB"
param_c = (18, "paramC")
copy_param_a = copy.copy(param_a)
copy_param_b = copy.copy(param_b)
copy_param_c = copy.copy(param_c)
print("验证不可变数据类型")
print(id(param_a))
print(id(copy_param_a))
print(id(param_b))
print(id(copy_param_b))
print(id(param_c))
print(id(copy_param_c))
print("======================")
# 可变数据类型
param_d = [[2, 3], 18, "paramD"]
param_e = {"key1": 18, "key2": "paramE", "key3": [1, 2]}
param_f = {18, "paramF"}
copy_param_d = copy.copy(param_d)
copy_param_e = copy.copy(param_e)
copy_param_f = copy.copy(param_f)
print("验证可变数据类型")
print(id(param_d))
print(id(copy_param_d))
print(id(param_e))
print(id(copy_param_e))
print(id(param_f))
print(id(copy_param_f))
# 运行结果
验证不可变数据类型
4455468864
4455468864
4457955120
4457955120
4457945040
4457945040
======================
验证可变数据类型
4458366368
4458367168
4457911312
4457911552
4457982144
4458284768
由此我们可以看出，对于不可变类型，浅拷贝并不会更改内存地址，而对于可变数据类型，会产生一个新的内存地址。接下来我们再来看看对于可变数据类型，去修改其中的元素会怎么样：
print("验证列表中元素")
# 验证列表中第一个元素是否相等
print(id(param_d[1]))
print(id(copy_param_d[1]))
print(id(param_d[0]))
print(id(copy_param_d[0]))
print("======================")
# 更改列表中元素的值
print("验证修改可变数据类型元素的值")
param_d[0].append(4)
print(param_d)
print(copy_param_d)
param_d.append("abc")
print(param_d)
print(copy_param_d)
param_d[1] = 19
print(param_d)
print(copy_param_d)
# 运行结果
验证列表中元素
4534525792
4534525792
4537357968
4537357968
验证修改可变数据类型元素的值
[[2, 3, 4], 18, 'paramD']
[[2, 3, 4], 18, 'paramD']
[[2, 3, 4], 18, 'paramD', 'abc']
[[2, 3, 4], 18, 'paramD']
[[2, 3, 4], 19, 'paramD', 'abc']
[[2, 3, 4], 18, 'paramD']
我们从上面结果可以看出，对于可变数据结构，他们元素的内存地址没有变化（以List为例，相当于新生成一个List，然后将原来List中元素的值全部copy到新生成的List中），而修改其中的可变数据类型(比如：param_d[0])，copy对象也会同步修改(copy_param_d[0])；而修改不可变元素(比如：param_d[1])，并不会影响其copy对象(copy_param_d[1])。
综上我们可以得出如下结论（敲黑板，划重点）：
- 对于不可变数据类型，浅拷贝只是复制了内存引用（指向内存的地址），并不会开辟新的内存空间（上例中param_a和copy_param_a、param_b和copy_param_b、param_c和copy_param_c内存地址一致）。
- 对于可变数据类型，浅拷贝会开辟新的内存空间（上例中param_d和copy_param_d内存地址不一致），但是它里面元素的内存地址还是一样的。
- 对于可变数据类型，改变原始对象中的可变数据类型的值，会同时影响拷贝对象的值（因为它们指向了对一个内存地址）；改变原始对象中的不可变数据类型的值，不会影响拷贝对象的值。
为了方便大家理解，画了内存地址的简图：
首先是不可变数据类型，因为其值的内存地址是不可变的，所以在内存中只有这一份：
其次是可变数据类型：
深拷贝
同样的，我们还是先来看例子(代码基本和上面的保持一致，只是修改了深拷贝方法deepcopy)：
def deep_copy_test():
"""
对深拷贝进行验证
:return:
"""
"""
对浅copy进行验证
:return:
"""
# 不可变数据类型
param_a = 17
param_b = "paramB"
param_c = (18, "paramC")
copy_param_a = copy.deepcopy(param_a)
copy_param_b = copy.deepcopy(param_b)
copy_param_c = copy.deepcopy(param_c)
print("验证不可变数据类型")
print(id(param_a))
print(id(copy_param_a))
print(id(param_b))
print(id(copy_param_b))
print(id(param_c))
print(id(copy_param_c))
print("======================")
# 可变数据类型
param_d = [[2, 3], 18, "paramD"]
param_e = {"key1": 18, "key2": "paramE", "key3": [1, 2]}
param_f = {18, "paramF"}
copy_param_d = copy.deepcopy(param_d)
copy_param_e = copy.deepcopy(param_e)
copy_param_f = copy.deepcopy(param_f)
print("验证可变数据类型")
print(id(param_d))
print(id(copy_param_d))
print(id(param_e))
print(id(copy_param_e))
print(id(param_f))
print(id(copy_param_f))
print("======================")
print("验证列表中元素")
# 验证列表中第一个元素是否相等
print(id(param_d[1]))
print(id(copy_param_d[1]))
print(id(param_d[0]))
print(id(copy_param_d[0]))
print("======================")
# 更改列表中元素的值
print("验证修改可变数据类型元素的值")
param_d[0].append(4)
print(param_d)
print(copy_param_d)
param_d.append("abc")
print(param_d)
print(copy_param_d)
param_d[1] = 19
print(param_d)
print(copy_param_d)
# 打印结果如下：
验证不可变数据类型
4438175552
4438175552
4440636208
4440636208
4440885840
4440885840
======================
验证可变数据类型
4440987760
4441335360
4440593344
4440594224
4440966160
4440967840
======================
======================
验证列表中元素
4438175584
4438175584
4440628192
4441336000
验证修改可变数据类型元素的值
[[2, 3, 4], 18, 'paramD']
[[2, 3], 18, 'paramD']
[[2, 3, 4], 18, 'paramD', 'abc']
[[2, 3], 18, 'paramD']
[[2, 3, 4], 19, 'paramD', 'abc']
[[2, 3], 18, 'paramD']我们可以和浅拷贝的运行结果做个对比，其中有差别的地方是：浅拷贝时列表中元素的内存地址没变，而深拷贝时列表中元素的内存地址发生了变化(主要针对可变数据类型，比如：param_d[0]和copy_param_d[0])。另外，对于可变数据类型，修改原始数据中的值，并不会影响拷贝数据。
综上，我们得出如下结论(敲黑板，划重点)：
- 深拷贝是在浅拷贝的基础上，又对可变数据类型的元素进行了递归拷贝，因此拷贝完成时，对于可变数据类型的元素，其内存地址全部都不一致。
- 深拷贝修改原始对象和拷贝对象的值，相互之间不影响。
为了大家理解，同样画了一幅内存简图(主要是针对可变数据类型)，可以对比下和浅拷贝时内存简图的区别：
总结
本文主要介绍了在Python3中内存的深拷贝和浅拷贝机制，大家可以动手写一下文中贴的Python代码，这样更能加深你的理解。总结来说，对于Python的不可变数据类型，深拷贝和浅拷贝的差别不大；主要区别是Python中的可变数据类型，深拷贝会对列表中的子元素进行递归拷贝处理，而浅拷贝则不会。
