Python賦值操作或函數(shù)參數(shù)傳遞傳遞的永遠(yuǎn)是對象引用（即內(nèi)存地址）解阅，而不是對象內(nèi)容落竹。在Python中一切皆對象泌霍，對象又分為可變(mutable)和不可變(immutable)兩種類型货抄。
對象拷貝是指在內(nèi)存中創(chuàng)建新的對象，產(chǎn)生新的內(nèi)存地址朱转。當(dāng)頂層對象和它的子元素對象全都是immutable不可變對象時蟹地，不存在被拷貝，因?yàn)闆]有產(chǎn)生新對象藤为。
- 淺拷貝(Shallow Copy)：拷貝頂層對象怪与，但不會拷貝內(nèi)部的子元素對象。
- 深拷貝(Deep Copy)：遞歸拷貝頂層對象缅疟，以及它內(nèi)部的子元素對象
可變對象和不可變對象
對象的類型決定了它裝著的數(shù)據(jù)是允許被修改的變量（可變的mutable）還是不可被修改的常量（不可變的immutable）分别。你可以把不可變對象想象成一個透明但封閉的盒子：你可以看到里面裝的數(shù)據(jù)，但是無法改變它存淫。類似地耘斩，可變對象就像一個開著口的盒子，你不僅可以看到里面的數(shù)據(jù)桅咆，還可以拿出來修改它括授，但你無法改變這個盒子本身，即你無法改變對象的類型岩饼。
mutable: 可變對象荚虚，如List、Dict
immutable: 不可變對象籍茧，如Number版述、String、Tuple寞冯、Frozenset
【注釋】：Python賦值操作或函數(shù)參數(shù)傳遞俭正，傳遞的永遠(yuǎn)是對象引用（即內(nèi)存地址）浸须，而不是對象內(nèi)容酷含。
關(guān)于 copy模塊
對象拷貝：
是指在內(nèi)存中創(chuàng)建新的對象，產(chǎn)生新的內(nèi)存地址撬腾。
【特點(diǎn)如下】：
（1）淺拷貝只拷貝最外層對象，深拷貝還會遞歸拷貝內(nèi)層對象恢恼；
（2）無論是淺拷貝還是深拷貝民傻，只拷貝mutable可變對象成為一個新對象，而immutable不可變對象還是原來的那個场斑；
（3）當(dāng)頂層對象和它的子元素對象全都是immutable不可變對象時漓踢，因?yàn)闆]有產(chǎn)生新對象，所以不存在被拷貝漏隐；
關(guān)于淺拷貝
【一句話介紹】淺拷貝(Shallow Copy)喧半，拷貝頂層對象，但不會拷貝內(nèi)部的子元素對象青责。
【換句話說】傳遞的是地址挺据，不會新建一個對象。
分別討論以下情況：
- （1）當(dāng)頂層對象是mutable可變對象脖隶，但是它的子元素對象全都是immutable不可變對象
程序環(huán)境基于【jupyter-notebook】
In [1]: a = [1, 'world', 2]
In [2]: [ id(item) for item in a ]
Out[2]: [9164864, 140104749066928, 9164896]
In [3]: id(a)
Out[3]: 140104759916040
【小提升】：導(dǎo)入copy模塊扁耐，使用copy.copy()函數(shù)淺拷貝a，并賦值給變量b产阱。
In [4]: import copy
In [5]: b = copy.copy(a)
In [6]: b
Out[6]: [1, 'world', 2]
In [7]: [ id(item) for item in b ]
Out[7]: [9164864, 140104749066928, 9164896]
In [8]: id(b)
Out[8]: 140104760027784
- （2）當(dāng)頂層對象是mutable可變對象婉称，但子元素也存在mutable可變對象（子元素部分immutable）
【舉個栗子】：
In [1]: a = [1, 2, ['hello','world']]
In [2]: import copy
In [3]: b = copy.copy(a)
In [4]: id(a)
Out[4]: 139770596269064
In [5]: id(b)
Out[5]: 139770596639368
In [6]: [ id(item) for item in a ]
Out[6]: [9164864, 9164896, 139770596304840]
In [7]: [ id(item) for item in b ]
Out[7]: [9164864, 9164896, 139770596304840]
In [8]: [ id(item) for item in a[2] ]
Out[8]: [139770585378520, 139770585378408]
In [9]: [ id(item) for item in b[2] ]
Out[9]: [139770585378520, 139770585378408]
【解釋】：淺拷貝copy.copy()只拷貝了頂層對象，沒有拷貝子元素對象['hello','world']构蹬，即a[2]和b[2]指向同一個列表對象
- （3）當(dāng)頂層對象是immutable不可變對象王暗，同時它的子元素對象也全都是immutable不可變對象
In [1]: a = (1, 2, 3)
In [2]: import copy
In [3]: b = copy.copy(a)
In [4]: id(a)
Out[4]: 139664680010016
In [5]: id(b)
Out[5]: 139664680010016
In [6]: [ id(item) for item in a ]
Out[6]: [9164864, 9164896, 9164928]
In [7]: [ id(item) for item in b ]
Out[7]: [9164864, 9164896, 9164928]
【解釋】：變量a與變量b指向的是同一個元組對象，沒有拷貝
- （4）當(dāng)頂層對象是immutable不可變對象時庄敛，但子元素存在mutable可變對象（子元素部分mutable）
來個栗子俗壹；
In [1]: a = (1, 2, ['hello','world'])
In [2]: import copy
In [3]: b = copy.copy(a)
In [4]: id(a)
Out[4]: 139650704096640
In [5]: id(b)
Out[5]: 139650704096640
In [6]: [ id(item) for item in a ]
Out[6]: [9164864, 9164896, 139650704068680]
In [7]: [ id(item) for item in b ]
Out[7]: [9164864, 9164896, 139650704068680]
In [8]: [ id(item) for item in a[2] ]
Out[8]: [139650692293328, 139650692293216]
In [9]: [ id(item) for item in b[2] ]
Out[9]: [139650692293328, 139650692293216]
In [10]: a[2][1] = 'china'
In [11]: a
Out[11]: (1, 2, ['hello', 'china'])
In [12]: b
Out[12]: (1, 2, ['hello', 'china'])
【解釋一下】：變量a與變量b指向的是相同的元組對象，并且a[2]與b[2]指向同一個列表铐姚，所以修改a[2][1]會影響b[2][1]
關(guān)于深拷貝
【一句話介紹】：
深拷貝(Deep Copy)策肝，遞歸拷貝頂層對象，以及它內(nèi)部的子元素對象隐绵。
【換句話說】：深拷貝時之众，會拷貝可變元素本身，而不是地址依许。
- （1）當(dāng)頂層對象是mutable可變對象棺禾，但是它的子元素對象全都是immutable不可變對象
In [1]: a = [1, 'world', 2]
In [2]: import copy
In [3]: b = copy.deepcopy(a)
In [4]: id(a)
Out[4]: 140664823442376
In [5]: id(b)
Out[5]: 140664823349192
In [6]: [ id(item) for item in a ]
Out[6]: [9164864, 140664823391544, 9164896]
In [7]: [ id(item) for item in b ]
Out[7]: [9164864, 140664823391544, 9164896]
In [8]: a[0] = 3
In [9]: a
Out[9]: [3, 'world', 2]
In [10]: b
Out[10]: [1, 'world', 2]
In [11]: [ id(item) for item in a ]
Out[11]: [9164928, 140664823391544, 9164896]
In [12]: [ id(item) for item in b ]
Out[12]: [9164864, 140664823391544, 9164896]
【解釋】：變量a與變量b指向不同的列表對象，修改a[0]只是將列表a的第一個元素重新指向新對象峭跳，不會影響b[0]
- （2）當(dāng)頂層對象是mutable可變對象膘婶，但子元素也存在mutable可變對象（子元素部分mutable）
In [1]: a = [1, 2, ['hello','world']]
In [2]: import copy
In [3]: b = copy.deepcopy(a)
In [4]: id(a)
Out[4]: 140531593252104
In [5]: id(b)
Out[5]: 140531593479304
In [6]: [ id(item) for item in a ]
Out[6]: [9164864, 9164896, 140531593299016]
In [7]: [ id(item) for item in b ]
Out[7]: [9164864, 9164896, 140531593324232]
In [8]: [ id(item) for item in a[2] ]
Out[8]: [140531582302896, 140531582302784]
In [9]: [ id(item) for item in b[2] ]
Out[9]: [140531582302896, 140531582302784]
【解釋】：深拷貝既拷貝了頂層對象缺前，又遞歸拷貝了子元素對象，所以a[2]與b[2]指向了兩個不同的列表對象(但是列表對象的子元素初始指定的字符串對象一樣)悬襟，修改a[2][1] = 'china'后衅码，它重新指向了新的字符串對象（內(nèi)存地址為140531581905808），不會影響到b[2][1]
- （3）當(dāng)頂層對象是immutable不可變對象脊岳，同時它的子元素對象也全都是immutable不可變對象
In [1]: a = (1, 2, 3)
In [2]: import copy
In [3]: b = copy.deepcopy(a)
In [4]: id(a)
Out[4]: 140021832303960
In [5]: id(b)
Out[5]: 140021832303960
In [6]: [ id(item) for item in a ]
Out[6]: [9164864, 9164896, 9164928]
In [7]: [ id(item) for item in b ]
Out[7]: [9164864, 9164896, 9164928]
【嗯逝段，對！】：變量a與變量b指向的是同一個元組對象割捅，不存在拷貝
- （4）當(dāng)頂層對象是immutable不可變對象時奶躯，但子元素存在mutable可變對象（子元素部分mutable）
In [11]: a
Out[11]: (1, 2, ['hello', 'china'])
In [12]: b
Out[12]: (1, 2, ['hello', 'world'])
In [13]: [ id(item) for item in a[2] ]
Out[13]: [140437024839640, 140437016189336]
In [14]: [ id(item) for item in b[2] ]
Out[14]: [140437024839640, 140437024839528]
【不想多打字了...】：變量a與變量b指向的是不同的元組對象，同時a[2]與b[2]指向不同的列表對象亿驾，所以修改a[2][1]不會影響b[2][1]
其它拷貝方法
（1）列表的復(fù)制
列表的復(fù)制嘹黔，有以下三種方式：
列表的copy()函數(shù)
list()轉(zhuǎn)換函數(shù)
列表分片[:]
In [1]: a = [1, 2, ['hello','world']]
In [2]: b = a.copy()
In [3]: c = list(a)
In [4]: d = a[:]
In [5]: id(a), id(b), id(c), id(d)
Out[5]: (140277244933640, 140277244846856, 140277323038536, 140277244767944)
In [6]: a[0] = 100
In [7]: a[2][1] = 'wangy'
In [8]: a
Out[8]: [100, 2, ['hello', 'wangy']]
In [9]: b
Out[9]: [1, 2, ['hello', 'wangy']]
In [10]: c
Out[10]: [1, 2, ['hello', 'wangy']]
In [11]: d
Out[11]: [1, 2, ['hello', 'wangy']]
【列表的復(fù)制都相當(dāng)于淺拷貝效果】
【解釋】：b/c/d都是a的復(fù)制，它們都指向了不同的列表對象莫瞬，但是沒有拷貝子元素儡蔓，a[2]和b[2]/c[2]/d[2]指向同一個列表，相當(dāng)于淺拷貝的效果
（2）元組的復(fù)制
In [1]: a = (1, 2, ['hello','world'])
In [2]: b = a[:]
In [3]: id(a), id(b)
Out[3]: (140146192445512, 140146192445512)
In [4]: a
Out[4]: (1, 2, ['hello', 'world'])
In [5]: b
Out[5]: (1, 2, ['hello', 'world'])
In [6]: a[2][1] = 'wangy'
In [7]: a
Out[7]: (1, 2, ['hello', 'wangy'])
In [8]: b
Out[8]: (1, 2, ['hello', 'wangy'])
【解釋】：使用分片[:]操作乏悄，a和b其實(shí)是指向同一個元組浙值，而且沒有拷貝子元素恳不，a[2]和b[2]也指向同一個列表檩小，相當(dāng)于淺拷貝的效果。
（3）字典的復(fù)制
In [1]: a = {'name': 'wangy', 'age': 18, 'jobs': ['devops', 'dba']}
In [2]: b = a.copy()
In [3]: c = dict(a)
In [4]: id(a), id(b), id(c)
Out[4]: (139653533041504, 139653544192616, 139653533040712)
In [5]: a['age'] = 20
In [6]: a['jobs'].append('python')
In [7]: a
Out[7]: {'name': 'wangy', 'age': 20, 'jobs': ['devops', 'dba', 'python']}
In [8]: b
Out[8]: {'name': 'wangy', 'age': 18, 'jobs': ['devops', 'dba', 'python']}
In [9]: c
Out[9]: {'name': 'wangy', 'age': 18, 'jobs': ['devops', 'dba', 'python']}
【解釋】：變量a與變量b/c指向不同的字典烟勋，但是沒有拷貝子元素规求，a['jobs']和b['jobs']/c['jobs']指定同一個列表，相當(dāng)于淺拷貝的效果
（4）集合的復(fù)制
同列表類似卵惦，可以使用集合的copy()函數(shù)或者轉(zhuǎn)換函數(shù)set()
In [1]: a = {1, 2, 3}
In [2]: b = a.copy()
In [3]: c = set(a)
In [4]: id(a), id(b), id(c)
Out[4]: (139965317888712, 139965317888936, 139965317889608)
In [5]: a.add('wangy')
In [6]: a
Out[6]: {1, 2, 3, 'wangy'}
In [7]: b
Out[7]: {1, 2, 3}
In [8]: c
Out[8]: {1, 2, 3}
【解釋】：變量a與變量b/c指向不同的集合阻肿，而集合的元素必須是hashable，所以修改集合a不會影響到b/c
