1、赋值，深拷贝，浅拷贝
对于Python来说没有指针，但是所有对象均为指针，把一个对象传给另一个对象有三种方式：
直接赋值也就是常用的 =
深拷贝也就是 copy.deepcopy()
浅拷贝也就是 copy.copy()
这三者有什么区别呢？假如一个对象[1,[2,3]]，对于这个对象来说他是有真实的地址在内存中假如为123，占有内存空间的。容器中的1和[2,3]同样为对象，占有真实内存空间，具有内存地址456与789。相对于1和[2,3]来说123为对象容器，1和[2,3]为对象中的子元素。
那么我们把这个对象赋值给a==>a=[1,[2,3]]，此时a是一个指向内存中对象[1,[2,3]]的引用，指向内存地址123，而b=a，就相当于b是a的一个别名，b同样是指向内存中对象[1,[2,3]]的引用，指向内存地址123。赋值仅仅传递这个值的引用，相当于取别名，指向的实体是同一个，对象容器与对象子元素均相同。旧瓶装旧酒
那么当我们使用浅拷贝时c=copy.copy(a)，此时先在系统中复制一个对象[1,[2,3]]，然后再赋值给c。注意！此时的这个复制出来的对象[1,[2,3]]在内存地址为124，与原a的内存地址123不同，但是！此时对象124中的对象1和[2,3]指向的对象为456与789。也就是说浅拷贝会复制的其实是对象容器，然后在内存中创造一个同样的容器，容器中存放的子元素是没有复制的，是同一个子元素对象的引用。也就是新瓶装旧酒。
那么当我们使用深拷贝时d=copy.deepcopy(a)，同样会在内存中复制一个对象，然后赋值给d。那么此时这个复制出来的容器对象的内存地址与其子元素的内存地址还会原地址相同吗？此时在内存中复制出来一个内存地址为125的容器对象，他的子元素内存地址为457与781。也就是说此时的d与a相比，不仅对象容器是重新复制的，连对象中子元素也是重新复制的。也就是说新瓶装新酒。
import copy
a = [1,[2,[3,4]]]
#原对象容器id及其子元素id
id(a)
Out[22]: 96144200
[id(i) for i in a]
Out[25]: [1529015408, 96251592]
#赋值对象容器id及其子元素id
b = a
id(b)
Out[26]: 96144200
[id(i) for i in b]
Out[27]: [1529015408, 96251592]
#浅拷贝对象容器id及其子元素id
c = copy.copy(a)
id(c)
Out[28]: 96217224
[id(i) for i in c]
Out[29]: [1529015408, 96251592]
#深拷贝对象容器id及其子元素id
d = copy.deepcopy(a)
id(d)
Out[30]: 96248392
[id(i) for i in d]
Out[31]: [1529015408, 95952776]
并且，
id(a[1][1])
Out[33]: 1529015472
id(d[1][1])
Out[32]: 96913992
a=(
[(2,3),[4,5]],
([2,5],(3,(4,)))
)
b=deepcopy(a)
plist=[a,b]
#不可变对象容器
[id(i) for i in plist]
Out[260]: [96249288, 88108168]
#可变子元素
[id(i[0]) for i in plist]
Out[261]: [97060296, 97069448]
# 可变子元素=>递归下去没有可变子元素
[id(i[0][0]) for i in plist]
Out[264]: [96248776, 96248776]
# 可变子元素=>递归下去有可变子元素
[id(i[0][1]) for i in plist]
Out[263]: [96216008, 97069256]
#不可变子元素
[id(i[1]) for i in plist]
Out[262]: [96080008, 87858568]
# 不可变子元素=>递归下去没有可变子元素
[id(i[1][1]) for i in plist]
Out[266]: [88038664, 88038664]
# 不可变子元素=>递归下去有可变子元素
[id(i[1][0]) for i in plist]
Out[265]: [97056904, 97088456]
深拷贝不仅仅往里复制了一层子元素而已，子元素的子元素假如为可变对象依然是依次复制，直到子元素中递归下去都没有可变的子元素才会引用，层次递归进去，否则便会复制。所以说从
| 方式 | 对象容器（可变） | 对象容器（不可变） | 子元素（可变） | 子元素（不可变） | 子元素的子元素（可变） | 子元素的子元素（不可变） |
|---|---|---|---|---|---|---|
| 赋值 | 引用 | 引用 | 引用 | 引用 | 引用 | 引用 |
| 浅拷贝 | 复制 | 引用 | 引用 | 引用 | 引用 | 引用 |
| 深拷贝 | 复制 | 复制（主要针对touple除非遇到没有可变子元素才会引用）;list/int/logint/string均引用 | 复制 | 复制（主要针对touple除非遇到没有可变子元素才会引用）;list/int/logint/string均引用 | 复制 | 复制（主要针对touple除非遇到没有可变子元素才会引用）;list/int/logint/string均引用 |
2、赋值、浅拷贝、深拷贝改变原对象的影响
复制的对象，当更改这个对象本身（也就是引用）不会影响，引用的对象更改对象本身（引用）便会影响。
尝试下更改不同复制方式，更改原对象会有什么不同呢？
from copy import copy,deepcopy
a=(1,(2,[3,4]))
b=a
c=copy(a)
d=deepcopy(a)
a=[1,[2,[3,4]]]
b=a
c=copy.copy(a)
d=copy.deepcopy(a)
a
Out[75]: [1, [2, [3, 4]]]
b
Out[76]: [1, [2, [3, 4]]]
c
Out[77]: [1, [2, [3, 4]]]
d
Out[78]: [1, [2, [3, 4]]]
#操作对象容器（本身）
a.append(5)
a
Out[94]: [1, [2, [3, 4]], 5]
b
Out[95]: [1, [2, [3, 4]], 5]
c
Out[96]: [1, [2, [3, 4]]]
d
Out[97]: [1, [2, [3, 4]]]
#操作对象容器（引用）
a=1
a
Out[214]: 1
b
Out[215]: (1, (2, [3, 4]))
c
Out[216]: (1, (2, [3, 4]))
d
Out[217]: (1, (2, [3, 4]))
#操作对象容器子元素（本身）
a[1].append('a')
a
Out[99]: [1, [2, [3, 4], 'a'], 5]
b
Out[100]: [1, [2, [3, 4], 'a'], 5]
c
Out[101]: [1, [2, [3, 4], 'a']]
d
Out[102]: [1, [2, [3, 4]]]
#操作对象容器子元素（引用）
a[1]=2
a
Out[231]: [1, 2]
b
Out[232]: [1, 2]
c
Out[233]: [1, [2, [3, 4]]]
d
Out[234]: [1, [2, [3, 4]]]
#操作对象容器子元素的子元素（本身）
a[1][1].append('b')
a
Out[104]: [1, [2, [3, 4, 'b'], 'a'], 5]
b
Out[106]: [1, [2, [3, 4, 'b'], 'a'], 5]
c
Out[107]: [1, [2, [3, 4, 'b'], 'a']]
d
Out[108]: [1, [2, [3, 4]]]
#操作对象容器子元素的子元素（引用）
a[1][0]=5
a
Out[240]: [1, [5, [3, 4]]]
b
Out[241]: [1, [5, [3, 4]]]
c
Out[242]: [1, [5, [3, 4]]]
d
Out[243]: [1, [2, [3, 4]]]
| 操作对象 | 赋值对象 | 浅拷贝对象 | 深拷贝对象 |
|---|---|---|---|
| 对象容器（本身） | Ture | False | False |
| 对象容器（引用） | False | False | False |
| 对象容器子元素（本身） | Ture | Ture | False |
| 对象容器子元素（引用） | Ture | False | False |
| 对象容器子元素的子元素（本身） | Ture | Ture | False |
| 对象容器子元素的子元素（引用） | Ture | Ture | False |
