blocks|key|76231|text|对于不可变对象，不需要复制，因为数据永远不会改变，所以Python使用相同的数据；is总是相同的。对于可变对象，因为它们可能会更改，所以浅复制会创建一个新对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|76232|深度复制与嵌套结构相关。如果你有列表的列表，那么deepcopy+copies嵌套的列表，所以它是一个递归的副本。使用just+copy，你有了一个新的外部列表，但内部列表是引用。|offset|length|style|CODE|76233|分配不会复制。它只是设置对旧数据的引用。因此，您需要复制以创建具有相同内容的新列表。|76234|entityMap^0|0|X|6|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

For immutable objects, there is no need for copying because the data will never change, so Python uses the same data; ids are always the same. For mutable objects, since they can potentially change, [shallow] copy creates a new object.

Deep copy is related to nested structures. If you have list of lists, then deepcopy <code>copies</code> the nested lists also, so it is a recursive copy. With just copy, you have a new outer list, but inner lists are references.

Assignment does not copy. It simply sets the reference to the old data. So you need copy to create a new list with the same contents.

blocks|key|293507|text|让我们在一个图形示例中看看如何执行以下代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|293508|import+copy

class+Foo(object):
++++def+__init__(self):
++++++++pass


a+=+[Foo(),+Foo()]
shallow+=+copy.copy(a)
deep+=+copy.deepcopy(a)|code-block|syntax|javascript|293509|​|293510|📷|atomic|offset|length|293511|293512|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/d0c04c1745262299116b5d10737339d1.png|imageAlt^0|0|0|0|0|1|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Z|8|@]|9|@]|A|$]]|$1|I|3|J|5|K|7|10|8|@]|9|@$L|11|M|12|1|13]]|A|$]]|$1|N|3|H|5|6|7|14|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V|W|-4]]]]

Let's see in a graphical example how the following code is executed:

<pre><code>import copy

class Foo(object):
 def __init__(self):
 pass


a = [Foo(), Foo()]
shallow = copy.copy(a)
deep = copy.deepcopy(a)
</code></pre>

<a href="https://i.stack.imgur.com/L6s7A.png" rel="noreferrer"><img src="https://i.stack.imgur.com/L6s7A.png" alt="enter image description here"></a>

blocks|key|76323|text|下面的代码演示了赋值、使用copy方法的浅复制、使用(slice)的浅复制和深度复制之间的区别。下面的示例使用嵌套列表，使差异更加明显。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|76324|from+copy+import+deepcopy

########"List+assignment+(does+not+create+a+copy)+############
l1+=+[1,2,3,+[4,5,6],+[7,8,9]]
l1_assigned+=+l1

print(l1)
print(l1_assigned)

print(id(l1),+id(l1_assigned))
print(id(l1[3]),+id(l1_assigned[3]))
print(id(l1[3][0]),+id(l1_assigned[3][0]))

l1[3][0]+=+100
l1.pop(4)
l1.remove(1)


print(l1)
print(l1_assigned)
print("###################################")

########"List+copy+using+copy+method+(shallow+copy)############

l2+=+[1,2,3,+[4,5,6],+[7,8,9]]
l2_copy+=+l2.copy()

print(l2)
print(l2_copy)

print(id(l2),+id(l2_copy))
print(id(l2[3]),+id(l2_copy[3]))
print(id(l2[3][0]),+id(l2_copy[3][0]))
l2[3][0]+=+100
l2.pop(4)
l2.remove(1)


print(l2)
print(l2_copy)

print("###################################")

########"List+copy+using+slice+(shallow+copy)############

l3+=+[1,2,3,+[4,5,6],+[7,8,9]]
l3_slice+=+l3[:]

print(l3)
print(l3_slice)

print(id(l3),+id(l3_slice))
print(id(l3[3]),+id(l3_slice[3]))
print(id(l3[3][0]),+id(l3_slice[3][0]))

l3[3][0]+=+100
l3.pop(4)
l3.remove(1)


print(l3)
print(l3_slice)

print("###################################")

########"List+copy+using+deepcopy+############

l4+=+[1,2,3,+[4,5,6],+[7,8,9]]
l4_deep+=+deepcopy(l4)

print(l4)
print(l4_deep)

print(id(l4),+id(l4_deep))
print(id(l4[3]),+id(l4_deep[3]))
print(id(l4[3][0]),+id(l4_deep[3][0]))

l4[3][0]+=+100
l4.pop(4)
l4.remove(1)

print(l4)
print(l4_deep)
print("##########################")
print(l4[2],+id(l4[2]))
print(l4_deep[3],+id(l4_deep[3]))

print(l4[2][0],+id(l4[2][0]))
print(l4_deep[3][0],+id(l4_deep[3][0]))|code-block|syntax|javascript|76325|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Below code demonstrates the difference between assignment, shallow copy using the copy method, shallow copy using the (slice) [:] and the deepcopy. Below example uses nested lists there by making the differences more evident.

<pre><code>from copy import deepcopy

########"List assignment (does not create a copy) ############
l1 = [1,2,3, [4,5,6], [7,8,9]]
l1_assigned = l1

print(l1)
print(l1_assigned)

print(id(l1), id(l1_assigned))
print(id(l1[3]), id(l1_assigned[3]))
print(id(l1[3][0]), id(l1_assigned[3][0]))

l1[3][0] = 100
l1.pop(4)
l1.remove(1)


print(l1)
print(l1_assigned)
print("###################################")

########"List copy using copy method (shallow copy)############

l2 = [1,2,3, [4,5,6], [7,8,9]]
l2_copy = l2.copy()

print(l2)
print(l2_copy)

print(id(l2), id(l2_copy))
print(id(l2[3]), id(l2_copy[3]))
print(id(l2[3][0]), id(l2_copy[3][0]))
l2[3][0] = 100
l2.pop(4)
l2.remove(1)


print(l2)
print(l2_copy)

print("###################################")

########"List copy using slice (shallow copy)############

l3 = [1,2,3, [4,5,6], [7,8,9]]
l3_slice = l3[:]

print(l3)
print(l3_slice)

print(id(l3), id(l3_slice))
print(id(l3[3]), id(l3_slice[3]))
print(id(l3[3][0]), id(l3_slice[3][0]))

l3[3][0] = 100
l3.pop(4)
l3.remove(1)


print(l3)
print(l3_slice)

print("###################################")

########"List copy using deepcopy ############

l4 = [1,2,3, [4,5,6], [7,8,9]]
l4_deep = deepcopy(l4)

print(l4)
print(l4_deep)

print(id(l4), id(l4_deep))
print(id(l4[3]), id(l4_deep[3]))
print(id(l4[3][0]), id(l4_deep[3][0]))

l4[3][0] = 100
l4.pop(4)
l4.remove(1)

print(l4)
print(l4_deep)
print("##########################")
print(l4[2], id(l4[2]))
print(l4_deep[3], id(l4_deep[3]))

print(l4[2][0], id(l4[2][0]))
print(l4_deep[3][0], id(l4_deep[3][0]))
</code></pre>

blocks|key|293553|text|>>lst=[1,2,3,4,5]

>>a=lst

>>b=lst[:]

>>>+b
[1,+2,+3,+4,+5]

>>>+a
[1,+2,+3,+4,+5]

>>>+lst+is+b
False

>>>+lst+is+a
True

>>>+id(lst)
46263192

>>>+id(a)
46263192+------>++See+here+id+of+a+and+id+of+lst+is+same+so+its+called+deep+copy+and+even+boolean+answer+is+true

>>>+id(b)
46263512+------>++See+here+id+of+b+and+id+of+lst+is+not+same+so+its+called+shallow+copy+and+even+boolean+answer+is+false+although+output+looks+same.|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|293554|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>&gt;&gt;lst=[1,2,3,4,5]

&gt;&gt;a=lst

&gt;&gt;b=lst[:]

&gt;&gt;&gt; b
[1, 2, 3, 4, 5]

&gt;&gt;&gt; a
[1, 2, 3, 4, 5]

&gt;&gt;&gt; lst is b
False

&gt;&gt;&gt; lst is a
True

&gt;&gt;&gt; id(lst)
46263192

&gt;&gt;&gt; id(a)
46263192 ------&gt; See here id of a and id of lst is same so its called deep copy and even boolean answer is true

&gt;&gt;&gt; id(b)
46263512 ------&gt; See here id of b and id of lst is not same so its called shallow copy and even boolean answer is false although output looks same.
</code></pre>

blocks|key|293675|text|不确定上面是否提到过，但是理解.copy()创建对原始对象的引用是非常重要的。如果更改复制的对象，则会更改原始对象。.deepcopy()创建新对象，并将原始对象实际复制到新对象。更改新的深度复制对象不会影响原始对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|293676|是的，.deepcopy()递归地复制原始对象，而.copy()创建对原始对象的一级数据的引用对象。|293677|因此，.copy()和.deepcopy()之间的复制/引用差异很大。|293678|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Not sure if it mentioned above or not, but it's very importable to undestand that .copy() create reference to original object. If you change copied object - you change the original object.
.deepcopy() creates new object and does real copying of original object to new one. Changing new deepcopied object doesn't affect original object.

And yes, .deepcopy() copies original object recursively, while .copy() create a reference object to first-level data of original object.

So the copying/referencing difference between .copy() and .deepcopy() is significant.

blocks|key|76483|text|下面的代码显示了底层地址在复制、深度复制和赋值过程中受到的影响。这与Sohaib+Farooqi在列表中显示的内容类似，但在类中显示。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|76484|from+copy+import+deepcopy,+copy

class+A(object):
++++"""docstring+for+A"""
++++def+__init__(self):
++++++++super().__init__()

class+B(object):
++++"""docstring+for+B"""
++++def+__init__(self):
++++++++super().__init__()
++++++++self.myA+=+A()

a+=+B()
print("a+is",+a)
print("a.myA+is",+a.myA)
print("After+copy")
b+=+copy(a)
print("b+is",+b)
print("b.myA+is",+b.myA)
b.myA+=+A()
print("--+after+changing+value")
print("a+is",+a)
print("a.myA+is",+a.myA)
print("b+is",+b)
print("b.myA+is",+b.myA)

print("Resetting")
print("*"*40)
a+=+B()
print("a+is",+a)
print("a.myA+is",+a.myA)
print("After+deepcopy")
b+=+deepcopy(a)
print("b+is",+b)
print("b.myA+is",+b.myA)
b.myA+=+A()
print("--+after+changing+value")
print("a+is",+a)
print("a.myA+is",+a.myA)
print("b+is",+b)
print("b.myA+is",+b.myA)

print("Resetting")
print("*"*40)
a+=+B()
print("a+is",+a)
print("a.myA+is",+a.myA)
print("After+assignment")
b+=+a
print("b+is",+b)
print("b.myA+is",+b.myA)
b.myA+=+A()
print("--+after+changing+value")
print("a+is",+a)
print("a.myA+is",+a.myA)
print("b+is",+b)
print("b.myA+is",+b.myA)|code-block|syntax|javascript|76485|此代码的输出如下所示：|76486|a+is+<__main__.B+object+at+0x7f1d8ff59760>
a.myA+is+<__main__.A+object+at+0x7f1d8fe8f970>
After+copy
b+is+<__main__.B+object+at+0x7f1d8fe43280>
b.myA+is+<__main__.A+object+at+0x7f1d8fe8f970>
--+after+changing+value
a+is+<__main__.B+object+at+0x7f1d8ff59760>
a.myA+is+<__main__.A+object+at+0x7f1d8fe8f970>
b+is+<__main__.B+object+at+0x7f1d8fe43280>
b.myA+is+<__main__.A+object+at+0x7f1d8fe85820>
Resetting
****************************************
a+is+<__main__.B+object+at+0x7f1d8fe85370>
a.myA+is+<__main__.A+object+at+0x7f1d8fe43310>
After+deepcopy
b+is+<__main__.B+object+at+0x7f1d8fde3040>
b.myA+is+<__main__.A+object+at+0x7f1d8fde30d0>
--+after+changing+value
a+is+<__main__.B+object+at+0x7f1d8fe85370>
a.myA+is+<__main__.A+object+at+0x7f1d8fe43310>
b+is+<__main__.B+object+at+0x7f1d8fde3040>
b.myA+is+<__main__.A+object+at+0x7f1d8fe43280>
Resetting
****************************************
a+is+<__main__.B+object+at+0x7f1d8fe432b0>
a.myA+is+<__main__.A+object+at+0x7f1d8fe85820>
After+assignment
b+is+<__main__.B+object+at+0x7f1d8fe432b0>
b.myA+is+<__main__.A+object+at+0x7f1d8fe85820>
--+after+changing+value
a+is+<__main__.B+object+at+0x7f1d8fe432b0>
a.myA+is+<__main__.A+object+at+0x7f1d8fe85370>
b+is+<__main__.B+object+at+0x7f1d8fe432b0>
b.myA+is+<__main__.A+object+at+0x7f1d8fe85370>|76487|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/46875999/6211109^0|Y|E|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

The following code shows how underlying addresses are affected in copy, deepcopy and assignment. This is similar to what <a href="https://stackoverflow.com/a/46875999/6211109">Sohaib Farooqi</a> showed with lists, but with classes.
<pre><code>from copy import deepcopy, copy

class A(object):
 &quot;&quot;&quot;docstring for A&quot;&quot;&quot;
 def __init__(self):
 super().__init__()

class B(object):
 &quot;&quot;&quot;docstring for B&quot;&quot;&quot;
 def __init__(self):
 super().__init__()
 self.myA = A()

a = B()
print(&quot;a is&quot;, a)
print(&quot;a.myA is&quot;, a.myA)
print(&quot;After copy&quot;)
b = copy(a)
print(&quot;b is&quot;, b)
print(&quot;b.myA is&quot;, b.myA)
b.myA = A()
print(&quot;-- after changing value&quot;)
print(&quot;a is&quot;, a)
print(&quot;a.myA is&quot;, a.myA)
print(&quot;b is&quot;, b)
print(&quot;b.myA is&quot;, b.myA)

print(&quot;Resetting&quot;)
print(&quot;*&quot;*40)
a = B()
print(&quot;a is&quot;, a)
print(&quot;a.myA is&quot;, a.myA)
print(&quot;After deepcopy&quot;)
b = deepcopy(a)
print(&quot;b is&quot;, b)
print(&quot;b.myA is&quot;, b.myA)
b.myA = A()
print(&quot;-- after changing value&quot;)
print(&quot;a is&quot;, a)
print(&quot;a.myA is&quot;, a.myA)
print(&quot;b is&quot;, b)
print(&quot;b.myA is&quot;, b.myA)

print(&quot;Resetting&quot;)
print(&quot;*&quot;*40)
a = B()
print(&quot;a is&quot;, a)
print(&quot;a.myA is&quot;, a.myA)
print(&quot;After assignment&quot;)
b = a
print(&quot;b is&quot;, b)
print(&quot;b.myA is&quot;, b.myA)
b.myA = A()
print(&quot;-- after changing value&quot;)
print(&quot;a is&quot;, a)
print(&quot;a.myA is&quot;, a.myA)
print(&quot;b is&quot;, b)
print(&quot;b.myA is&quot;, b.myA)
</code></pre>
The output from this code is as following:
<pre><code>a is &lt;__main__.B object at 0x7f1d8ff59760&gt;
a.myA is &lt;__main__.A object at 0x7f1d8fe8f970&gt;
After copy
b is &lt;__main__.B object at 0x7f1d8fe43280&gt;
b.myA is &lt;__main__.A object at 0x7f1d8fe8f970&gt;
-- after changing value
a is &lt;__main__.B object at 0x7f1d8ff59760&gt;
a.myA is &lt;__main__.A object at 0x7f1d8fe8f970&gt;
b is &lt;__main__.B object at 0x7f1d8fe43280&gt;
b.myA is &lt;__main__.A object at 0x7f1d8fe85820&gt;
Resetting
****************************************
a is &lt;__main__.B object at 0x7f1d8fe85370&gt;
a.myA is &lt;__main__.A object at 0x7f1d8fe43310&gt;
After deepcopy
b is &lt;__main__.B object at 0x7f1d8fde3040&gt;
b.myA is &lt;__main__.A object at 0x7f1d8fde30d0&gt;
-- after changing value
a is &lt;__main__.B object at 0x7f1d8fe85370&gt;
a.myA is &lt;__main__.A object at 0x7f1d8fe43310&gt;
b is &lt;__main__.B object at 0x7f1d8fde3040&gt;
b.myA is &lt;__main__.A object at 0x7f1d8fe43280&gt;
Resetting
****************************************
a is &lt;__main__.B object at 0x7f1d8fe432b0&gt;
a.myA is &lt;__main__.A object at 0x7f1d8fe85820&gt;
After assignment
b is &lt;__main__.B object at 0x7f1d8fe432b0&gt;
b.myA is &lt;__main__.A object at 0x7f1d8fe85820&gt;
-- after changing value
a is &lt;__main__.B object at 0x7f1d8fe432b0&gt;
a.myA is &lt;__main__.A object at 0x7f1d8fe85370&gt;
b is &lt;__main__.B object at 0x7f1d8fe432b0&gt;
b.myA is &lt;__main__.A object at 0x7f1d8fe85370&gt;
</code></pre>

<pre><code>import copy

a = "deepak"
b = 1, 2, 3, 4
c = [1, 2, 3, 4]
d = {1: 10, 2: 20, 3: 30}

a1 = copy.copy(a)
b1 = copy.copy(b)
c1 = copy.copy(c)
d1 = copy.copy(d)


print("immutable - id(a)==id(a1)", id(a) == id(a1))
print("immutable - id(b)==id(b1)", id(b) == id(b1))
print("mutable - id(c)==id(c1)", id(c) == id(c1))
print("mutable - id(d)==id(d1)", id(d) == id(d1))
</code></pre>

I get the following results:

<pre><code>immutable - id(a)==id(a1) True
immutable - id(b)==id(b1) True
mutable - id(c)==id(c1) False
mutable - id(d)==id(d1) False
</code></pre>

If I perform deepcopy:

<pre><code>a1 = copy.deepcopy(a)
b1 = copy.deepcopy(b)
c1 = copy.deepcopy(c)
d1 = copy.deepcopy(d)
</code></pre>

results are the same:

<pre><code>immutable - id(a)==id(a1) True
immutable - id(b)==id(b1) True
mutable - id(c)==id(c1) False
mutable - id(d)==id(d1) False
</code></pre>

If I work on assignment operations:

<pre><code>a1 = a
b1 = b
c1 = c
d1 = d
</code></pre>

then results are:

<pre><code>immutable - id(a)==id(a1) True
immutable - id(b)==id(b1) True
mutable - id(c)==id(c1) True
mutable - id(d)==id(d1) True
</code></pre>

Can somebody explain what exactly makes a difference between the copies? Is it something related to mutable &amp; immutable objects? If so, can you please explain it to me?

What is the difference between shallow copy, deepcopy and normal assignment operation?

Python

import copya = "deepak"b = 1, 2, 3, 4c = [1, 2, 3, 4]d = {1: 10, 2: 20, 3: 30}a1 = copy.copy(a)b1 = copy.copy(b)c1 = copy.copy(c)d1 = copy.copy(d)print("immutab...

问浅拷贝、深拷贝和正常赋值操作的区别是什么？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问浅拷贝、深拷贝和正常赋值操作的区别是什么？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问浅拷贝、深拷贝和正常赋值操作的区别是什么？
EN