直接进入正题！
一.赋值“=”
python赋值操作的最终结果是将变量指向某个内存中的对象，只是引用。
但不同的赋值操作的中间过程是不一样的，另一篇文章已经对赋值操作做了详细说明：https://www.jianshu.com/p/521bdd67790e。
总结起来就是：
1）“变量B=变量A”（变量A肯定已经指向某个对象了），对于变量之间的赋值，毫无悬念，两个变量最终指向同一个对象。
2）“变量A=对象”（如A = 'python'），对于这种情况，如果对象在内存中不存在，那么将新建这个对象，然后将变量A指向该对象；如果对象已经存在了，那情况就稍微复杂了，部分情况是将变量指向原有的对象，部分情况会新建建一个对象（即使内存中已经有了一个值完全相同的对象），然后将变量指向这个新的对象！
二.拷贝（复制）
所谓拷贝，是完完整整地产生一个一模一样的新对象，拷贝完成后，两者应该是独立的个体，不再有半点联系。按照这个逻辑，“赋值”操作完全不属于拷贝的范畴。
三.浅拷贝
所谓“浅拷贝”，意思是，拷贝了，但又拷贝得不彻底。浅拷贝之后，新对象确实是生成了，但在某些情况下新对象还和被拷贝对象有千丝万缕的联系。
浅拷贝只拷贝了最外层数据，对于子数据对象没有拷贝，而只是一个引用（与原数据共用一个自数据对象），无论修改新数据的子对象还是元数据的子对象，另一个都会改变。
从其说明来看，对于非嵌套的数据（没有子对象），浅拷贝实际上是完全拷贝了一个独立的对象。
浅拷贝方法：某些对象自身的copy()方法、copy模块中的copy()方法、切片操作[:]。
实例：
1）浅拷贝“非嵌套数据对象”
>>>a = [1,2,3]
>>>b = a.copy() #浅拷贝a给b
>>>print(id(a))
>>>print(id(b))
41921864
41943176
a[0] = 'A' #修改a的元素
print('a={}'.format(a))
print('b={}'.format(b))
a=['A', 2, 3]
b=[1, 2, 3]
上例中[1,2,3]是一个非嵌套的列表数据，b = a.copy()是将a浅拷贝一份然后指向b，从id可以看出，b指向的是一个与a相互独立的对象。后面修改了a指向的对象元素后，b指向的对象没有变化，进一步说明了两者的独立性。copy模块中的copy()方法、切片操作[:]的结果与此例完全相同，不再赘述。
2）浅拷贝“嵌套数据对象”
>>>a = [1,2,['A','B']]
>>>b = a.copy()
>>>print(id(a))
>>>print(id(b))
36044936
36047688
>>>print(id(a[2][0]))
>>>print(id(b[2][0]))
34525456
34525456
>>>a[0] = 'P' #修改a的外圈元素
>>>a[2][0] = 'Q' #修改a的子对象元素
print('a={}'.format(a))
print('b={}'.format(b))
a=['P', 2, ['Q', 'B']]
b=[1, 2, ['Q', 'B']]
此例中[1,2,['A','B']]是个嵌套列表，b = a.copy()只会拷贝最外层数据给新的对象，然后指向b，而子对象['A','B']则不会拷贝，a和b共同指向该子对象。id(a)≠id(b)，说明了a.copy()确实只拷贝了外层对象，而id(a[2][0])=id(b[2][0])说明子对象是共用的，没重新拷贝。后面a[0] = 'P'和a[2][0] = 'Q'分别修改了列表的外圈元素和子对象元素，从打印结果可以看出b的外圈元素没变，而内圈元素变了，进一步说明了外圈是独立对象而子对象是共享的。
copy模块中的copy()方法、切片操作[:]的结果与此例完全相同，不再赘述。
四.深拷贝
有了浅拷贝的比较，深拷贝就很简单了，深拷贝才是真正的拷贝，无论多少嵌套，一股脑儿都拷贝一个新，是彻底的拷贝，拷贝以后与被拷贝对象不再有任何瓜葛。
深拷贝方法：copy中的deepcopy()方法
实例：
1）深拷贝“非嵌套数据对象”
这种情况与前面的“浅拷贝“非嵌套数据对象””一模一样，不再赘述。
2）深拷贝“嵌套数据对象”
import copy
>>>a = [1,2,['A','B']]
>>>b = copy.deepcopy(a) #深拷贝
>>>print(id(a))
>>>print(id(b))
42275400
42276680
>>>print(id(a[2][0]))
>>>print(id(b[2][0]))
34328848
34328848
上例中我们惊奇地发现id(a[2][0])=id(b[2][0])，这不是和浅拷贝一模一样吗？没有我们所谓的独立拷贝一个啊？这是怎么回事？一开始笔者也非常纳闷。研究发现实际上这是Python节省内存的方式，虽然是深拷贝，但我先不急着拷贝子对象，先共用，如果后面程序需要单独用到这些数据时，再执行拷贝子对象这个动作。接着上面的代码：
>>>a[2][0] = 'Q' #修改a的子对象元素
>>>b[2][1] = 'QQ' #修该b的子对象元素
>>>print('a={}'.format(a))
>>>print('b={}'.format(b))
a=['1', 2, ['Q', 'B']]
b=['1', 2, ['A', 'QQ']]
>>>print(id(a[2][0]))
>>>print(id(b[2][0]))
39764128
39764408
我们通过a[2][0] = 'Q'修改a的子对象的第一个元素，通过b[2][1] = 'QQ'修改b的子对象的第二个元素，根据输出结果a=['1', 2, ['Q', 'B']]和b=['1', 2, ['A', 'QQ']]两者确实相互不影响，说明是独立的。此时我们再输出第一个子对象的地址，发现id(a[2][0])≠id(b[2][0])了，说明此时子对象已经是两个独立的对象了，而且两者都不等于原来子对象的内存地址34328848。这个结果说明了两个问题：1）深度拷贝后，需要对子对象操作时，才会真正执行拷贝一个子对象的动作；2）深拷贝后，如果无需要对两个对象的子对象元素进行修改，那么两者都会先重新生成一个子对象（也就是这里的39764128和39764408），然后再修改，至于最开始的那个子对象（上面的34328848）则会被销毁；如果只是修改一个的子对象元素，那么另一个仍然指向最原始的子对象，而不会被销毁。
五.总结
1）赋值“=”操作，只是传递了一个引用，压根不是“拷贝”的范畴；
2）浅拷贝的作用是为了节省空间，对于非嵌套数据，浅拷贝和深拷贝实际是一样的；对于嵌套数据，浅拷贝只拷贝最外层数据，而共享子对象数据；
3）深拷贝完全拷贝真个对象，包括子对象；但并非直接生产两个独立的子对象，而是有一个共享子对象的中间过程（也是为了节省空间），当需要改变子对象时，才会最终执行单独拷贝子对象的操作，而且当两个对象都进行更改子对象操作时，两个对象都会重新建立新的子对象，而把最初的子对象抛弃；
4）编程时，如果需要保留原数据，那么应该进行深拷贝，避免修改原数据。
