Python賦值操作或函數(shù)參數(shù)傳遞抒痒，傳遞的永遠(yuǎn)是對象引用（即內(nèi)存地址）杉允，而不是對象內(nèi)容膳犹。在Python中一切皆對象，對象又分為可變(mutable)和不可變(immutable)兩種類型蜂林。對象拷貝是指在內(nèi)存中創(chuàng)建新的對象遥诉，產(chǎn)生新的內(nèi)存地址。當(dāng)頂層對象和它的子元素對象全都是immutable不可變對象時噪叙，不存在被拷貝矮锈，因為沒有產(chǎn)生新對象。淺拷貝(Shallow Copy)睁蕾，拷貝頂層對象苞笨，但不會拷貝內(nèi)部的子元素對象。深拷貝(Deep Copy)子眶，遞歸拷貝頂層對象瀑凝，以及它內(nèi)部的子元素對象。
- 可變對象與不可變對象
- copy模塊
- 其它拷貝方法
一臭杰、可變對象與不可變對象
Python中一切皆對象粤咪，對象就像一個塑料盒子， 里面裝的是數(shù)據(jù)渴杆。對象有不同類型射窒，例如布爾型和整型，類型決定了可以對它進(jìn)行的操作〗埽現(xiàn)實生活中的"陶器"會暗含一些信息（例如它可能很重且易碎，注意不要掉到地上）蝌麸。
對象的類型還決定了它裝著的數(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)容
In [1]: a = 1
In [2]: b = a
In [3]: id(a)
Out[3]: 9164864
In [4]: id(b)
Out[4]: 9164864
In [5]: b += 1
In [6]: a
Out[6]: 1
In [7]: b
Out[7]: 2
In [8]: id(a) # 對象引用a還是指向Number對象1
Out[8]: 9164864
In [9]: id(b) # 對象引用b指向了Number對象2
Out[9]: 9164896
Python會緩存使用非常頻繁的小整數(shù)-5至256、ISO/IEC 8859-1單字符隅津、只包含大小寫英文字母的字符串诬垂，以對其復(fù)用，不會創(chuàng)建新的對象：
1. 不會創(chuàng)建新對象
In [1]: a = 10
In [2]: b = 10
In [3]: id(a)
Out[3]: 9165152
In [4]: id(b)
Out[4]: 9165152
In [5]: a = '@'
In [6]: b = '@'
In [7]: id(a)
Out[7]: 139812844740424
In [8]: id(b)
Out[8]: 139812844740424
In [9]: a = 'HELLOWORLDhelloworld'
In [10]: b = 'HELLOWORLDhelloworld'
In [11]: id(a)
Out[11]: 139812785036792
In [12]: id(b)
Out[12]: 139812785036792
2. 會創(chuàng)建新的對象
In [1]: a = 1000
In [2]: b = 1000
In [3]: id(a)
Out[3]: 140528314730384
In [4]: id(b)
Out[4]: 140528314731824
In [5]: a = 'x*y'
In [6]: b = 'x*y'
In [7]: id(a)
Out[7]: 139897777405880
In [8]: id(b)
Out[8]: 139897777403808
In [9]: a = 'Hello World'
In [10]: b = 'Hello World'
In [11]: id(a)
Out[11]: 139897789146096
In [12]: id(b)
Out[12]: 139897789179568
二伦仍、copy模塊
對象拷貝是指在內(nèi)存中創(chuàng)建新的對象结窘，產(chǎn)生新的內(nèi)存地址。
- 淺拷貝只拷貝最外層對象呢铆，深拷貝還會遞歸拷貝內(nèi)層對象
- 無論是淺拷貝還是深拷貝晦鞋，只拷貝mutable可變對象成為一個新對象，而immutable不可變對象還是原來的那個
- 當(dāng)頂層對象和它的子元素對象全都是immutable不可變對象時棺克，因為沒有產(chǎn)生新對象悠垛，所以不存在被拷貝
2.1淺拷貝
淺拷貝(Shallow Copy)，拷貝頂層對象娜谊，但不會拷貝內(nèi)部的子元素對象确买。
2.1.1. 頂層是mutable，子元素全是immutable
當(dāng)頂層對象是mutable可變對象纱皆，但是它的子元素對象全都是immutable不可變對象時湾趾，如[1, 'world', 2]
① 創(chuàng)建列表對象并賦值給變量a
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
③ 修改變量a的子元素a[0] = 3搀缠，由于整數(shù)是不可變對象，所以并不是修改1變?yōu)?近迁，而是更改a[0]指向?qū)ο?
In [9]: a[0] = 3
In [10]: a
Out[10]: [3, 'world', 2]
In [11]: b
Out[11]: [1, 'world', 2]
In [12]: [ id(item) for item in a ]
Out[12]: [9164928, 140104749066928, 9164896]
In [13]: [ id(item) for item in b ]
Out[13]: [9164864, 140104749066928, 9164896]
2.1.2. 頂層是mutable艺普，子元素部分immutable
當(dāng)頂層對象是mutable可變對象，但子元素也存在mutable可變對象時，如[1, 2, ['hello','world']]
① 淺拷貝copy.copy()只拷貝了頂層對象歧譬，沒有拷貝子元素對象['hello','world']岸浑，即a[2]和b[2]指向同一個列表對象
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]
② 修改a[2][1] = 'china'，則b[2][1] = 'china'
In [10]: a[2][1] = 'china'
In [11]: a
Out[11]: [1, 2, ['hello', 'china']]
In [12]: b
Out[12]: [1, 2, ['hello', 'china']]
In [13]: [ id(item) for item in a[2] ]
Out[13]: [139770585378520, 139770584993552]
In [14]: [ id(item) for item in b[2] ]
Out[14]: [139770585378520, 139770584993552]
2.1.3. 頂層是immutable瑰步，子元素全是immutable
當(dāng)頂層對象是immutable不可變對象矢洲，同時它的子元素對象也全都是immutable不可變對象時，如(1, 2, 3)
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指向的是同一個元組對象缩焦，沒有拷貝
2.1.4. 頂層是immutable读虏，子元素部分mutable
當(dāng)頂層對象是immutable不可變對象時，但子元素存在mutable可變對象時舌界，如(1, 2, ['hello','world'])
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]
2.2. 深拷貝
深拷貝(Deep Copy)呻拌，遞歸拷貝頂層對象葱轩，以及它內(nèi)部的子元素對象
2.2.1. 頂層是mutable，子元素全是immutable
當(dāng)頂層對象是mutable可變對象藐握，但是它的子元素對象全都是immutable不可變對象時靴拱，如[1, 'world', 2]
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.2.2. 頂層是mutable袜炕，子元素部分mutable
當(dāng)頂層對象是mutable可變對象，但子元素也存在mutable可變對象時初家，如[1, 2, ['hello','world']]
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]
In [10]: a[2][1] = 'china'
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]: [140531582302896, 140531581905808]
In [14]: [ id(item) for item in b[2] ]
Out[14]: [140531582302896, 140531582302784]
深拷貝既拷貝了頂層對象偎窘，又遞歸拷貝了子元素對象，所以a[2]與b[2]指向了兩個不同的列表對象(但是列表對象的子元素初始指定的字符串對象一樣)溜在，修改a[2][1] = 'china'后陌知，它重新指向了新的字符串對象（內(nèi)存地址為140531581905808），不會影響到b[2][1]
2.2.3. 頂層是immutable掖肋，子元素全是immutable
當(dāng)頂層對象是immutable不可變對象仆葡，同時它的子元素對象也全都是immutable不可變對象時，如(1, 2, 3)
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指向的是同一個元組對象志笼，不存在拷貝
2.2.4. 頂層是immutable沿盅，子元素部分mutable
當(dāng)頂層對象是immutable不可變對象時，但子元素存在mutable可變對象時纫溃，如(1, 2, ['hello','world'])
In [1]: a = (1, 2, ['hello','world'])
In [2]: import copy
In [3]: b = copy.deepcopy(a)
In [4]: id(a)
Out[4]: 140437037631672
In [5]: id(b)
Out[5]: 140437085244440
In [6]: [ id(item) for item in a ]
Out[6]: [9164864, 9164896, 140437036297096]
In [7]: [ id(item) for item in b ]
Out[7]: [9164864, 9164896, 140437036357960]
In [8]: [ id(item) for item in a[2] ]
Out[8]: [140437024839640, 140437024839528]
In [9]: [ id(item) for item in b[2] ]
Out[9]: [140437024839640, 140437024839528]
In [10]: a[2][1] = 'china'
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]
3. 其它拷貝方法
3.1. 列表的復(fù)制
In [1]: a = [1, 2, 3]
In [2]: b = a
In [3]: b
Out[3]: [1, 2, 3]
In [4]: a[0] = 'wangy'
In [5]: a
Out[5]: ['wangy', 2, 3]
In [6]: b
Out[6]: ['wangy', 2, 3]
使用=是賦值紊浩，即將列表對象的引用也賦值給變量b窖铡，可以將列表對象想像成一個盒子揍很，變量a相當(dāng)于這個盒子上的標(biāo)簽，執(zhí)行b = a后万伤，相當(dāng)于再在這個盒子上貼上b標(biāo)簽，a和b實際上指向的是同一個對象呜袁。因此敌买，無論我們是通過a還是通過b來修改列表的內(nèi)容，其結(jié)果都會作用于雙方阶界。
列表的復(fù)制都相當(dāng)于淺拷貝效果虹钮，有以下三種方式：
- 列表的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']]
b/c/d都是a的復(fù)制，它們都指向了不同的列表對象膘融，但是沒有拷貝子元素芙粱，a[2]和b[2]/c[2]/d[2]指向同一個列表，相當(dāng)于淺拷貝的效果
3.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其實是指向同一個元組春畔，而且沒有拷貝子元素，a[2]和b[2]也指向同一個列表岛都，相當(dāng)于淺拷貝的效果
3.3. 字典的復(fù)制
同列表類似律姨，可以使用字典的copy()函數(shù)或者轉(zhuǎn)換函數(shù)dict()
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)于淺拷貝的效果
3.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
