Python---The difference between copy (), Deepcopy () and assignment

The copy between deepcopy is the entire value, and the deepcopy does not change when the original value changes

Array type copy, the copied value also changes, if it is a = [1,3] This full assignment, the original copy value will not change, if the value of each position of the array is assigned a new value (such as a[1] = 1,a[2] = 3)

The main difference between copy () and Deepcopy () is how Python stores the data.

First straight to the conclusion:

-deep copy, which will be copied completely again as a separate new entity exists alone. Therefore, changing the original copied object will not affect the new object that has been copied.

--and equal to the assignment, does not produce a separate object, he simply hits the original block with a new tag, so when one of the tags is changed, the data block changes and the other tag changes.

--and shallow replication is discussed in two different situations:

1) When the value of a shallow copy is an immutable object (numeric, string, tuple) and is equal to assignment, the object's ID value is the same as the light copy original value.

2) When the value of a shallow copy is a mutable object (list and tuple), a "not so independent object" exists. There are two types of situations:

The first case is that there are no complex sub-objects in the copied object, and the change of the original value does not affect the value of the shallow copy, and the value changes of the shallow copy do not affect the original value. The ID value of the original value differs from the original value of shallow copy.

The second case is that there are complex sub-objects in the copied object (for example, a child element in the list is a list), and if you do not change the complex sub-object, the value of the shallow copy changes without affecting the original value. However, changing the value of the complex sub-object in the original value affects the value of the shallow copy.

For simple object, such as immutable objects (numeric, string, tuple), there is no difference between shallow copy and deep copy

Complex object, such as the list in the case, shallow copy of the sub-list, not from the original object really "independent" out. In other words, if you change an element in the child list of the original object, your copy will change along with it. This is different from our intuitive understanding of "copy".

When the value of a shallow copy is an immutable object (numeric, string, tuple), the code is as follows:

1. >>> a="1234567"
2. >>> b=a
3. >>> ID (a)
4. 4367619440
5. >>> ID (b)
6. 4367619440
7. >>> c=copy.copy (a)
8. >>> ID (c)
9. 4367619440
10. >>> d=copy.deepcopy (a)
11. >>> ID (d)
12. 4367619440

When the value of a shallow copy is a mutable object (list, dictionary), the changed value is not the complex sub-object code as follows:

2. >>> l1=[1,2,3]
4. >>> l2=l1
6. >>> l3=copy.copy (L1)
8. >>> ID (L1)
10. 4367654664
12. >>> ID (L2)
14. 4367654664
16. >>> ID (L3)
18. 4367628616
20. >>> l1.append (in)
22. >>> Print (L1)
24. [1, 2, 3, + ]
26. >>> Print (L3)
28. [1, 2, 3]

When the value of a shallow copy is a mutable object (list, dictionary), the changed value is the complex sub-object code as follows:

2. >>> Import copy
4. >>> list1=[1,2,[' A ',' B ']
6. >>> List2=list1
8. >>> list3=copy.copy (list2)
10. >>> list4=copy.deepcopy (LIST3)
12. >>> ID (list1)
14. 4338414656
16. >>> ID (list2)
18. 4338414656
20. >>> ID (list3)
22. 4338415016
24. >>> ID (list4)
26. 4338414368
28. >>> list1[2].append (' a ')
30. >>> ID (list1)
32. 4338414656
34. >>> Print List1
36. [1, 2, [' a ', ' B ', ' a ']]
38. >>> print list3
40. [1, 2, [' a ', ' B ', ' a ']]
42. >>> print list4
44. [1, 2, [' a ', ' B ']]
46. >>> list1.append (+)
48. >>> ID (list1)
50. 4338414656
52. >>> ID (list3)
54. 4338415016
56. >>> Print List1
58. [1, 2, [' a ', ' B ', ' a '], [ ]
60. >>> print list3
62. [1, 2, [' a ', ' B ', ' a ']]

Code Description: When changing elements in complex sub-objects, the shallow copy values have changed; When the changed value is not a complex sub-object, the value of the shallow copy does not change. Because of shallow copying, complex sub-objects are saved as a reference, so modifying the values of the shallow copy and the original values can change the values of the complex sub-objects.

How python data is stored

Python stores variables in a different way than other OOP languages. Instead of assigning a value to a variable, it is a reference to a specific value.

When in Python a = something should be understood to put a label on the something. When you assign a value to a, it's like taking a tag off the original something and pasting it onto other objects to create a new reference. This explains some of the strange things you might encounter in Python:

2. >> A = [1, 2, 3]
4. >>> B = a
6. >>> a = [4, 5, 6]//assigns a new value to a
8. >>> a
10. [4, 5, 6]
12. >>> b
14. [1, 2, 3]
16. # After the value of a has changed, B does not change with a
20. >>> A = [1, 2, 3]
22. >>> B = a
24. >>> a[0], a[1], a[2] = 4, 5, 6//change the elements in the original list
26. >>> a
28. [4, 5, 6]
30. >>> b
32. [4, 5, 6]
34. # After the value of a has changed, B changes with a

In both of the above code, the value of a has changed. The difference is that the first piece of code is directly assigned a new value (from [1, 2, 3] to [4, 5, 6]), and the second paragraph changes each element in the list individually. The effect on B is different, one does not change the value of B, and the other changes. How to use the above reason to explain the strange difference? For the first time, [1, 2, 3] is regarded as an object. A = [1, 2, 3] is equivalent to labeling the item A. B = A is a label for the item and a B.

The first case: a = [4, 5, 6] is equivalent to tearing a label from [1, 2, 3] and pasting it onto [4, 5, 6]. In this process, [1, 2, 3] This item does not disappear. b from start to finish well on [1, 2, 3], since this reference has not changed. The value of B does not change naturally.

The second case: A[0], a[1], a[2] = 4, 5, 6 is directly changed [1, 2, 3] the item itself. Re-modified every part of it inside. After the internal modification, [1, 2, 3] itself became [4, 5, 6]. And in the process, A and B are not moving, they are also affixed to the item. So the natural value of a B is changed to [4, 5, 6].

After figuring this out, I'm going to ask, what happened to a simple copy of a complex object in copy?
Look at the code again:

2. >>> import copy
4. >>> origin = [1, 2, [3, 4]]
6. There are three elements inside #origin: 1, 2,[3, 4]
8. >>> cop1 = Copy.copy (Origin)
10. >>> cop2 = Copy.deepcopy (Origin)
12. >>> Cop1 = = Cop2
14. True
16. >>> cop1 is cop2
18. False
20. #cop1 and Cop2 look the same, but are no longer the same object
22. >>> origin[2][0] = "hey!"
24. >>> Origin
26. [1, 2, [' hey! ', 4]]
28. >>> Cop1
30. [1, 2, [' hey! ', 4]]
32. >>> cop2
34. [1, 2, [3, 4]]
36. #把origin内的子list [3, 4] changed an element to observe COP1 and COP2

People who have studied Docker should be familiar with the concept of mirroring, and we can apply the concept of mirroring to copy.

The copy concept map is as follows:

Copy (shallow copy) for a complex object's sub-object is not completely copied, what is the sub-object of complex objects? Like nested sequences in a sequence, nested sequences in a dictionary are sub-objects of complex objects. For sub-objects, Python stores it as a public image, and all copies of it are treated as a reference, so that when one of the references changes the mirror and the other reference uses the mirror, the image is changed.

So look at the origin[2 here], that is [3, 4] this list. According to the definition of shallow copy, the cop1[2] points to the same list [3, 4]. Well, if we change this list here, it will cause both origin and cop1 to change at the same time. This is why the top origin[2][0] = "hey!", Cop1 also became [1, 2, [' hey! ', 4]].

The Deepcopy concept map is as follows:

Deepcopy will copy each layer of the complex object to a single individual.
This time origin[2] and cop2[2] Although the values are equal to [3, 4], but it is not the same list. That we replicate in the ordinary sense.

Python---The difference between copy (), Deepcopy () and assignment