浅拷贝、深拷贝和普通赋值操作的区别是什么？

小开

对于不可变对象，不需要复制，因为数据永远不会改变，所以Python使用相同的数据;id总是相同的。对于可变对象，因为它们可能会改变，[浅]复制创建一个新对象。

深度复制与嵌套结构有关。如果你有列表的列表，那么深度复制copies嵌套列表也，所以它是一个递归复制。通过复制，您有一个新的外部列表，但内部列表是引用。

赋值不复制。它只是将引用设置为旧数据。因此，您需要复制来创建一个具有相同内容的新列表。

小开

最佳答案

正常的赋值操作只是将新变量指向现有对象。文档解释了浅拷贝和深拷贝之间的区别:

浅复制和深复制之间的差异仅与复合对象(包含其他对象的对象，如列表或类实例):

浅拷贝构造一个新的复合对象，然后(在可能的范围内)将对原始对象的引用插入其中。
深度复制构造一个新的复合对象，然后递归地将在复合对象中找到的对象的副本插入其中李。 < / >

这里有一个小示范:

import copy


a = [1, 2, 3]
b = [4, 5, 6]
c = [a, b]

使用普通赋值操作来复制:

d = c


print id(c) == id(d)          # True - d is the same object as c
print id(c[0]) == id(d[0])    # True - d[0] is the same object as c[0]

使用浅拷贝:

d = copy.copy(c)


print id(c) == id(d)          # False - d is now a new object
print id(c[0]) == id(d[0])    # True - d[0] is the same object as c[0]

使用深度拷贝:

d = copy.deepcopy(c)


print id(c) == id(d)          # False - d is now a new object
print id(c[0]) == id(d[0])    # False - d[0] is now a new object

小开

A, b, c, d, a1, b1, c1和d1是对内存中对象的引用，它们由它们的id唯一标识。

赋值操作接受内存中对象的引用，并将该引用赋给一个新名称。c=[1,2,3,4]是一个赋值，它创建一个包含这四个整数的新列表对象，并将该对象的引用赋值给c。c1=c是一个赋值，它接受对同一对象的相同引用并将其赋值给c1。因为列表是可变的，所以不管你是通过c还是c1访问它，发生在列表上的任何事情都是可见的，因为它们都引用了同一个对象。

c1=copy.copy(c)是一个“浅拷贝”，它创建一个新列表，并将对新列表的引用赋值给c1。c仍然指向原始的列表。因此，如果你在c1处修改列表，c所引用的列表将不会改变。

复制的概念与整数和字符串等不可变对象无关。由于不能修改这些对象，因此不需要在内存的不同位置有相同值的两个副本。因此，整数和字符串，以及其他一些复制概念不适用的对象，只是简单地重新赋值。这就是为什么使用a和b的例子会得到相同的id。

c1=copy.deepcopy(c)是一个“深度复制”，但在本例中它的功能与浅复制相同。深度拷贝与浅拷贝的不同之处在于，浅拷贝将创建对象本身的新副本，但该对象的任何引用内部本身不会被复制。在您的示例中，列表中只有整数(不可变)，正如前面讨论的那样，不需要复制这些整数。因此，深层复制的“深层”部分不适用。然而，考虑一下这个更复杂的列表:

e = [[1, 2],[4, 5, 6],[7, 8, 9]]

这是一个包含其他列表的列表(也可以将其描述为一个二维数组)。

如果你在e上运行一个“浅拷贝”，将它复制到e1，你会发现列表的id改变了，但是列表的每个副本都包含对相同的三个列表的引用——其中包含整数的列表。这意味着如果你要执行e[0].append(3)，那么e将是[[1, 2, 3],[4, 5, 6],[7, 8, 9]]。但是e1也可以是[[1, 2, 3],[4, 5, 6],[7, 8, 9]]。另一方面，如果你随后执行e.append([10, 11, 12])， e将是[[1, 2, 3],[4, 5, 6],[7, 8, 9],[10, 11, 12]]。但是e1仍然是[[1, 2, 3],[4, 5, 6],[7, 8, 9]]。这是因为外部列表是单独的对象，最初每个对象都包含三个对三个内部列表的引用。如果您修改了内部列表，无论您是通过一个副本还是另一个副本查看它们，都可以看到这些更改。但是如果你像上面那样修改一个外部列表，那么e包含三个对原来三个列表的引用，再加上一个对新列表的引用。并且e1仍然只包含原来的三个引用。

“深度复制”不仅会复制外部列表，而且还会进入列表内部并复制内部列表，因此两个结果对象不包含任何相同的引用(就可变对象而言)。如果内部列表中有更多的列表(或其他对象，如字典)，它们也会被复制。这是“深层复制”的“深层”部分。

小开

让我们在一个图形示例中看看下面的代码是如何执行的:

import copy


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




a = [Foo(), Foo()]
shallow = copy.copy(a)
deep = copy.deepcopy(a)

小开

对于不可变对象，创建一个副本没有多大意义，因为它们不会改变。对于可变对象assignment，copy和deepcopy的行为不同。让我们用例子来讨论每一个。

赋值操作只是将源的引用赋值给目标，例如:

>>> i = [1,2,3]
>>> j=i
>>> hex(id(i)), hex(id(j))
>>> ('0x10296f908', '0x10296f908') #Both addresses are identical

现在i和j在技术上指的是同一个列表。i和j都有相同的内存地址。任何更新其中一个会被另一个反射。例句:

>>> i.append(4)
>>> j
>>> [1,2,3,4] #Destination is updated


>>> j.append(5)
>>> i
>>> [1,2,3,4,5] #Source is updated

另一方面，copy和deepcopy创建了一个新的变量副本。所以现在对原始变量的更改将不会被反映复制变量，反之亦然。然而，copy(shallow copy)不创建嵌套对象的副本，而只是复制嵌套对象的引用。Deepcopy递归复制所有嵌套对象

一些演示copy和deepcopy行为的例子:

使用copy的平面列表示例:

>>> import copy
>>> i = [1,2,3]
>>> j = copy.copy(i)
>>> hex(id(i)), hex(id(j))
>>> ('0x102b9b7c8', '0x102971cc8') #Both addresses are different


>>> i.append(4)
>>> j
>>> [1,2,3] #Updation of original list didn't affected copied variable

使用copy的嵌套列表示例:

>>> import copy
>>> i = [1,2,3,[4,5]]
>>> j = copy.copy(i)


>>> hex(id(i)), hex(id(j))
>>> ('0x102b9b7c8', '0x102971cc8') #Both addresses are still different


>>> hex(id(i[3])), hex(id(j[3]))
>>> ('0x10296f908', '0x10296f908') #Nested lists have same address


>>> i[3].append(6)
>>> j
>>> [1,2,3,[4,5,6]] #Updation of original nested list updated the copy as well

平面列表示例，使用deepcopy

>>> import copy >>> i = [1,2,3] >>> j = copy.deepcopy(i) >>> hex(id(i)), hex(id(j)) >>> ('0x102b9b7c8', '0x102971cc8') #Both addresses are different >>> i.append(4) >>> j >>> [1,2,3] #Updation of original list didn't affected copied variable

使用deepcopy的嵌套列表示例:

>>> import copy >>> i = [1,2,3,[4,5]] >>> j = copy.deepcopy(i) >>> hex(id(i)), hex(id(j)) >>> ('0x102b9b7c8', '0x102971cc8') #Both addresses are still different >>> hex(id(i[3])), hex(id(j[3])) >>> ('0x10296f908', '0x102b9b7c8') #Nested lists have different addresses >>> i[3].append(6) >>> j >>> [1,2,3,[4,5]] #Updation of original nested list didn't affected the copied variable

小开

下面的代码演示了赋值、使用复制方法的浅复制、使用(slice)[:]的浅复制和深度复制之间的区别。下面的示例使用嵌套列表，使差异更加明显。

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]))

小开

这里的要点是: 使用“normal赋值”处理浅列表(没有子列表，只有单个元素)会在创建浅列表时产生“副作用”，然后使用“normal赋值”创建该列表的副本。这种“副作用”是当您更改创建的复制列表中的任何元素时，因为它将自动更改原始列表中的相同元素。这就是copy派上用场的时候，因为它在改变复制元素时不会改变原始的列表元素
另一方面，copy也有一个“副作用”，当你有一个列表，其中有列表(sub_lists)，而deepcopy解决了它。例如，如果您创建了一个大列表，其中有嵌套的列表(sub_lists)，并且您创建了这个大列表的副本(原始列表)。当你修改复制列表的sub_lists时会出现“副作用”，这会自动修改大列表的sub_lists。有时(在某些项目中)您希望保留大列表(原始列表)而不作任何修改，您所需要的只是复制其元素(sub_lists)。为此，你的解决方案是使用deepcopy，它将照顾这个“副作用”，并在不修改原始内容的情况下创建一个副本。

copy和deep copy操作的不同行为只涉及复合对象(即:包含其他对象(如列表)的对象)。

下面是这个简单的代码示例中说明的差异:

首先 

让我们通过创建一个原始列表和这个列表的副本来检查copy (shallow)的行为:

import copy original_list = [1, 2, 3, 4, 5, ['a', 'b']] copy_list = copy.copy(original_list)

现在，让我们运行一些print测试，看看原始列表与它的副本列表相比表现如何:

Original_list和copy_list的地址不同

print(hex(id(original_list)), hex(id(copy_list))) # 0x1fb3030 0x1fb3328

original_list和copy_list中的元素有相同的地址

print(hex(id(original_list[1])), hex(id(copy_list[1]))) # 0x537ed440 0x537ed440

original_list和copy_list的Sub_elements有相同的地址

print(hex(id(original_list[5])), hex(id(copy_list[5]))) # 0x1faef08 0x1faef08

修改original_list元素不会修改copy_list元素

original_list.append(6) print("original_list is:", original_list) # original_list is: [1, 2, 3, 4, 5, ['a', 'b'], 6] print("copy_list is:", copy_list) # copy_list is: [1, 2, 3, 4, 5, ['a', 'b']]

修改copy_list元素不会修改original_list元素

copy_list.append(7) print("original_list is:", original_list) # original_list is: [1, 2, 3, 4, 5, ['a', 'b'], 6] print("copy_list is:", copy_list) # copy_list is: [1, 2, 3, 4, 5, ['a', 'b'], 7]

修改original_list sub_elements会自动修改copy_list sub_elements

original_list[5].append('c') print("original_list is:", original_list) # original_list is: [1, 2, 3, 4, 5, ['a', 'b', 'c'], 6] print("copy_list is:", copy_list) # copy_list is: [1, 2, 3, 4, 5, ['a', 'b', 'c'], 7]

修改copy_list sub_elements会自动修改original_list sub_elements

copy_list[5].append('d') print("original_list is:", original_list) # original_list is: [1, 2, 3, 4, 5, ['a', 'b', 'c', 'd'], 6] print("copy_list is:", copy_list) # copy_list is: [1, 2, 3, 4, 5, ['a', 'b', 'c', 'd'], 7]

 第二

让我们检查一下deepcopy的行为，方法和copy一样(创建一个原始列表和这个列表的副本):

import copy original_list = [1, 2, 3, 4, 5, ['a', 'b']] copy_list = copy.copy(original_list)

现在，让我们运行一些print测试，看看原始列表与它的副本列表相比表现如何:

import copy original_list = [1, 2, 3, 4, 5, ['a', 'b']] copy_list = copy.deepcopy(original_list)

Original_list和copy_list的地址不同

print(hex(id(original_list)), hex(id(copy_list))) # 0x1fb3030 0x1fb3328

original_list和copy_list中的元素有相同的地址

print(hex(id(original_list[1])), hex(id(copy_list[1]))) # 0x537ed440 0x537ed440

original_list和copy_list的Sub_elements有不同的地址

print(hex(id(original_list[5])), hex(id(copy_list[5]))) # 0x24eef08 0x24f3300

修改original_list元素不会修改copy_list元素

original_list.append(6) print("original_list is:", original_list) # original_list is: [1, 2, 3, 4, 5, ['a', 'b'], 6] print("copy_list is:", copy_list) # copy_list is: [1, 2, 3, 4, 5, ['a', 'b']]

修改copy_list元素不会修改original_list元素

copy_list.append(7) print("original_list is:", original_list) # original_list is: [1, 2, 3, 4, 5, ['a', 'b'], 6] print("copy_list is:", copy_list) # copy_list is: [1, 2, 3, 4, 5, ['a', 'b'], 7]

修改original_list sub_elements不会修改copy_list sub_elements

original_list[5].append('c') print("original_list is:", original_list) # original_list is: [1, 2, 3, 4, 5, ['a', 'b', 'c'], 6] print("copy_list is:", copy_list) # copy_list is: [1, 2, 3, 4, 5, ['a', 'b'], 7]

修改copy_list sub_elements不会修改original_list sub_elements

copy_list[5].append('d') print("original_list is:", original_list) # original_list is: [1, 2, 3, 4, 5, ['a', 'b', 'c', 'd'], 6] print("copy_list is:", copy_list) # copy_list is: [1, 2, 3, 4, 5, ['a', 'b', 'd'], 7]

小开

在python中，当我们将list、tuples、dict等对象赋值给另一个对象(通常使用' = '符号)时，python会创建copy的通过引用。也就是说，我们有一个这样的列表:

list1 = [ [ 'a' , 'b' , 'c' ] , [ 'd' , 'e' , 'f' ] ]

然后我们给这个列表分配另一个列表，像这样:

list2 = list1

然后，如果我们在python终端中输出list2，我们将得到:

list2 = [ [ 'a', 'b', 'c'] , [ 'd', 'e', ' f '] ]

Both list1 &List2指向相同的内存位置，对其中任何一个的任何改变都会导致两个对象中可见的变化，即两个对象都指向相同的内存位置。如果我们像这样改变list1:
.
list1[0][0] = 'x’ list1.append( [ 'g'] )

那么list1和list2都将是:

list1 = [ [ 'x', 'b', 'c'] , [ 'd', 'e', ' f '] , [ 'g'] ] list2 = [ [ 'x', 'b', 'c'] , [ 'd', 'e', ' f '] , [ 'g’ ] ]
现在来到浅拷贝，当两个对象通过浅拷贝进行复制时，两个父对象的子对象引用相同的内存位置，但任何被复制对象中任何进一步的新更改都将彼此独立。让我们通过一个小例子来理解这一点。假设我们有这样一小段代码:

import copy list1 = [ [ 'a', 'b', 'c'] , [ 'd', 'e', ' f '] ] # assigning a list list2 = copy.copy(list1) # shallow copy is done using copy function of copy module list1.append ( [ 'g', 'h', 'i'] ) # appending another list to list1 print list1 list1 = [ [ 'a', 'b', 'c'] , [ 'd', 'e', ' f '] , [ 'g', 'h', 'i'] ] list2 = [ [ 'a', 'b', 'c'] , [ 'd', 'e', ' f '] ]

注意，list2不受影响，但如果我们对子对象进行如下更改:

list1[0][0] = 'x’

那么list1和list2都将得到变化:

list1 = [ [ 'x', 'b', 'c'] , [ 'd', 'e', ' f '] , [ 'g', 'h', 'i'] ] list2 = [ [ 'x', 'b', 'c'] , [ 'd', 'e', ' f '] ]
现在，深拷贝帮助创建彼此完全隔离的对象。如果两个对象通过深度复制进行复制，则双亲&它的子结点会指向不同的内存位置。例子:
import copy list1 = [ [ 'a', 'b', 'c'] , [ 'd', 'e', ' f '] ] # assigning a list list2 = deepcopy.copy(list1) # deep copy is done using deepcopy function of copy module list1.append ( [ 'g', 'h', 'i'] ) # appending another list to list1 print list1 list1 = [ [ 'a', 'b', 'c'] , [ 'd', 'e', ' f '] , [ 'g', 'h', 'i'] ] list2 = [ [ 'a', 'b', 'c'] , [ 'd', 'e', ' f '] ]

注意，list2不受影响，但如果我们对子对象进行如下更改:

list1[0][0] = 'x’

list2也不会受到影响，因为所有子对象和父对象都指向不同的内存位置:

list1 = [ [ 'x', 'b', 'c'] , [ 'd', 'e', ' f '] , [ 'g', 'h', 'i'] ] list2 = [ [ 'a', 'b', 'c'] , [ 'd', 'e', ' f ' ] ]

希望能有所帮助。

小开

>>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.

小开

不确定上面是否提到过，但是理解.copy()创建对原始对象的引用是非常重要的。如果你改变了复制的对象-你改变了原始对象。 .deepcopy()创建新对象并真正复制原始对象到新对象。改变新的深度复制对象不影响原始对象
是的，.deepcopy()递归复制原始对象，而.copy()创建一个引用对象到原始对象的一级数据。

因此.copy()和.deepcopy()之间的复制/引用差异是显著的。

小开

深度复制与嵌套结构有关。如果你有列表的列表，那么deepcopy也复制嵌套的列表，所以它是递归复制。通过复制，您有一个新的外部列表，但内部列表是引用。赋值不复制。对于Ex

import copy spam = [[0, 1, 2, 3], 4, 5] cheese = copy.copy(spam) cheese.append(3) cheese[0].append(3) print(spam) print(cheese)

输出

[[0,1,2,3,3]， 4,5] [[0,1,2,3,3]， 4,5,3] 复制方法将外部列表的内容复制到新列表，但两个列表的内部列表仍然相同，因此如果你在任何列表的内部列表中做出更改，它将影响两个列表。
但是如果你使用深度复制，它也会为内部列表创建新的实例。

import copy spam = [[0, 1, 2, 3], 4, 5] cheese = copy.deepcopy(spam) cheese.append(3) cheese[0].append(3) print(spam) print(cheese)

输出

[0,1,2,3] [[0, 1, 2, 3, 3]， 4, 5, 3]

小开

下面的代码显示了底层地址在复制、深度复制和赋值时是如何受到影响的。这类似于索Farooqi用列表显示的内容，但是用类显示的。

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)

这段代码的输出如下:

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>