Python---copy()、deepcopy()与赋值的区别

copy()与deepcopy()之间的主要区别是python对数据的存储方式。python2中，需要import copy模块。python3中，直接可以使用copy（）方法，但deepcopy（）还是需要导入copy模块

>首先直接上结论：

—–深复制，即将被复制对象完全再复制一遍作为独立的新个体单独存在。所以改变原有被复制对象不会对已经复制出来的新对象产生影响。 

—–而等于赋值，并不会产生一个独立的对象单独存在，他只是将原有的数据块打上一个新标签，所以当其中一个标签被改变的时候，数据块就会发生变化，另一个标签也会随之改变。

—–而浅复制要分两种情况进行讨论：

1）当浅复制的值是不可变对象（数值，字符串，元组）时和“等于赋值”的情况一样，对象的id值与浅复制原来的值相同。

2）当浅复制的值是可变对象（列表和元组）时会产生一个“不是那么独立的对象”存在。有两种情况：

第一种情况：复制的 对象中无 复杂 子对象，原来值的改变并不会影响浅复制的值，同时浅复制的值改变也并不会影响原来的值。原来值的id值与浅复制原来的值不同。

第二种情况：复制的对象中有 复杂 子对象 （例如列表中的一个子元素是一个列表），如果不改变其中复杂子对象，浅复制的值改变并不会影响原来的值。 但是改变原来的值 中的复杂子对象的值  会影响浅复制的值。

对于简单的 object，例如不可变对象（数值，字符串，元组），用 shallow copy 和 deep copy 没区别

复杂的 object， 如 list 中套着 list 的情况，shallow copy 中的 子list，并未从原 object 真的「独立」出来。也就是说，如果你改变原 object 的子 list 中的一个元素，你的 copy 就会跟着一起变。这跟我们直觉上对「复制」的理解不同。

不可变数据类型的copy

#不可变数据类型的copy
import  copy
a='123445'
b=a
c=copy.copy(a)
d=copy.deepcopy(a)
print('a===%s'%a)
print('b===%s'%b)
print('c===%s'%c)
print('id(a)是：',id(a))
print('id(b)是：',id(b))
print('id(c)是：',id(c))

 结果是：

a===123445
b===123445
c===123445
id(a)是： 3113366507904
id(b)是： 3113366507904
id(c)是： 3113366507904

分析：不可变的数据类型，等于赋值、浅复制、深复制id都是一样的。

可变数据类型（列表、字典）的copy（元素不包含复杂元素）：

#可变数据类型的copy
import copy
l1=[1,2,3,4,5,6]
l2=l1
l3=copy.copy(l1)
l4=copy.deepcopy(l1)
l1.append('hello')
l3[3]='world'
print('l1====%s'%l1)
print('l2====%s'%l2)
print('l3====%s'%l3)
print('l4====%s'%l4)
l4.append('list')
print('l4修改后为====%s'%l4)
print('id(l1)是：',id(l1))
print('id(l2)是：',id(l2))
print('id(l3)是：',id(l3))
print('id(l4)是：',id(l4))

结果为：

l1====[1, 2, 3, 4, 5, 6, 'hello']
l2====[1, 2, 3, 4, 5, 6, 'hello']
l3====[1, 2, 3, 'world', 5, 6]
l4====[1, 2, 3, 4, 5, 6]
l4修改后为====[1, 2, 3, 4, 5, 6, 'list']
id(l1)是： 1510329127816
id(l2)是： 1510329127816
id(l3)是： 1510329128008
id(l4)是： 1510329129288

分析：可变数据类型的浅copy()方法，并不会修改被复制对象。

可变数据类型包含复杂元素的copy:

>>> import copy
>>> list1=[1,2,3,['hello','hey','hi']]
>>> list2=list1
>>> list3=copy.copy(list1)
>>> list4=copy.deepcopy(list1)
>>> id(list1)
2380371448840
>>> id(list2)
2380371448840
>>> id(list3)
2380371450056
>>> id(list4)
2380371450120
>>> list1[3].append('list') #改变被复制对象内的列表项，浅复制的也跟着改变了，但是深复制的没有改变
>>> id(list1)
2380371448840
>>> list2
[1, 2, 3, ['hello', 'hey', 'hi', 'list']]
>>> id(list2)
2380371448840
>>> list3
[1, 2, 3, ['hello', 'hey', 'hi', 'list']]
>>> id(list3)
2380371450056
>>> list4
[1, 2, 3, ['hello', 'hey', 'hi']]
>>> id(list4)
2380371450120
>>> list3[3][0]=0  #改变浅复制得到的对象内的列表，被复制对象也改变了，深复制对象没改变
>>> list3
[1, 2, 3, [0, 'hey', 'hi', 'list']]
>>> list1
[1, 2, 3, [0, 'hey', 'hi', 'list']]
>>> id(list1)
2380371448840
>>> id(list3)
2380371450056
>>> list4
[1, 2, 3, ['hello', 'hey', 'hi']]
>>> id(list4)
2380371450120
>>> list4.append('hahahha') #改变深复制的来的对象内的一般项，被复制对象没有改变
>>> list4
[1, 2, 3, ['hello', 'hey', 'hi'], 'hahahha']
>>> list1
[1, 2, 3, [0, 'hey', 'hi', 'list']]
>>> list3
[1, 2, 3, [0, 'hey', 'hi', 'list']]
>>> id(list1)
2380371448840
>>> id(list3)
2380371450056
>>> id(list4)
2380371450120
>>> list4[3][0]=1  #改变深复制的来的对象内的列表对象，被复制对象没有改变，浅复制对象也没改变
>>> list4
[1, 2, 3, [1, 'hey', 'hi'], 'hahahha']
>>> list1
[1, 2, 3, [0, 'hey', 'hi', 'list']]
>>> list3
[1, 2, 3, [0, 'hey', 'hi', 'list']]
>>> id(list4)
2380371450120
>>> id(list1)
2380371448840
>>> id(list3)
2380371450056
>>> list1.append('change') 
>>> list1
[1, 2, 3, ['list1', 'hey', 'hi', 'list'], 'change']
>>> list3
[1, 2, 3, ['list1', 'hey', 'hi', 'list']] #改变被复制对象的一般元素时，浅复制对象没有改变
>>> list4
[1, 2, 3, [1, 'hey', 'hi'], 'hahahha']
>>> #从始至终，每个对象的id没有改变过

分析：

1.改变被复制对象的一般元素时，浅复制对象没有改变，深复制对象没改变

2.改变被复制对象的复杂子项中的元素时，浅复制对象跟着改变了，深复制对象没改变

3.改变浅复制对象的一般项时，被复制对象没有改变，深复制对象没有改变

4.改变浅复制对象的复制子项内的元素时，被复制对象改变了，深复制对象没有改变

5.改变深复制对象的一般项时，被复制对象没有改变，浅复制对象没有改变

6.改变深复制对象的复制子项内的元素时，被复制对象没有改变，浅复制对象没有改变

python的数据存储方式

Python 存储变量的方法跟其他 OOP 语言不同。它与其说是把值赋给变量，不如说是给变量建立了一个到具体值的 reference。

当在 Python 中 a = something 应该理解为给 something 贴上了一个标签 a。当再赋值给 a 的时候，就好象把 a 这个标签从原来的 something 上拿下来，贴到其他对象上，建立新的 reference。 这就解释了一些 Python 中可能遇到的诡异情况：

1. >> a = [1, 2, 3]

2. >>> b = a

3. >>> a = [4, 5, 6] //赋新的值给 a

4. >>> a

5. [4, 5, 6]

6. >>> b

7. [1, 2, 3]

8. # a 的值改变后，b 并没有随着 a 变

9.  

10. >>> a = [1, 2, 3]

11. >>> b = a

12. >>> a[0], a[1], a[2] = 4, 5, 6 //改变原来 list 中的元素

13. >>> a

14. [4, 5, 6]

15. >>> b

16. [4, 5, 6]

17. # a 的值改变后，b 随着 a 变了

上面两段代码中，a 的值都发生了变化。区别在于，第一段代码中是直接赋给了 a 新的值（从 [1, 2, 3] 变为 [4, 5, 6]）；而第二段则是把 list 中每个元素分别改变。而对 b 的影响则是不同的，一个没有让 b 的值发生改变，另一个变了。怎么用上边的道理来解释这个诡异的不同呢？首次把 [1, 2, 3] 看成一个物品。a = [1, 2, 3] 就相当于给这个物品上贴上 a 这个标签。而 b = a 就是给这个物品又贴上了一个 b 的标签。 

 
第一种情况：a = [4, 5, 6] 就相当于把 a 标签从 [1 ,2, 3] 上撕下来，贴到了 [4, 5, 6] 上。在这个过程中，[1, 2, 3] 这个物品并没有消失。 b 自始至终都好好的贴在 [1, 2, 3] 上，既然这个 reference 也没有改变过。 b 的值自然不变。

 
 

第二种情况：a[0], a[1], a[2] = 4, 5, 6 则是直接改变了 [1, 2, 3] 这个物品本身。把它内部的每一部分都重新改装了一下。内部改装完毕后，[1, 2, 3] 本身变成了 [4, 5, 6]。而在此过程当中，a 和 b 都没有动，他们还贴在那个物品上。因此自然 a b 的值都变成了 [4, 5, 6]。

搞明白这个之后就要问了，对于一个复杂对象的浅copy，在copy的时候到底发生了什么？ 
再看一段代码：

1. >>> import copy

2. >>> origin = [1, 2, [3, 4]]

3. #origin 里边有三个元素：1， 2，[3, 4]

4. >>> cop1 = copy.copy(origin)

5. >>> cop2 = copy.deepcopy(origin)

6. >>> cop1 == cop2

7. True

8. >>> cop1 is cop2

9. False

10. #cop1 和 cop2 看上去相同，但已不再是同一个object

11. >>> origin[2][0] = "hey!"

12. >>> origin

13. [1, 2, ['hey!', 4]]

14. >>> cop1

15. [1, 2, ['hey!', 4]]

16. >>> cop2

17. [1, 2, [3, 4]]

18. #把origin内的子list [3, 4] 改掉了一个元素，观察 cop1 和 cop2

 

学过docker的人应该对镜像这个概念不陌生，我们可以把镜像的概念套用在copy上面。

copy概念图如下： 

copy（浅复制）对于一个复杂对象的子对象并不会完全复制，什么是复杂对象的子对象呢？就比如序列里的嵌套序列，字典里的嵌套序列等都是复杂对象的子对象。对于子对象，python会把它当作一个公共镜像存储起来，所有对他的复制都被当成一个引用，所以说当其中一个引用将镜像改变了之后另一个引用使用镜像的时候镜像已经被改变了。

所以说看这里的origin[2]，也就是 [3, 4] 这个 list。根据 shallow copy 的定义，在 cop1[2] 指向的是同一个 list [3, 4]。那么，如果这里我们改变了这个 list，就会导致 origin 和 cop1 同时改变。这就是为什么上边 origin[2][0] = “hey!” 之后，cop1 也随之变成了 [1, 2, [‘hey!’, 4]]。

deepcopy概念图如下： 

deepcopy的时候会将复杂对象的每一层复制一个单独的个体出来。 
这时候的 origin[2] 和 cop2[2] 虽然值都等于 [3, 4]，但已经不是同一个 list了。即我们寻常意义上的复制。