浅拷贝，深度拷贝和正常分配操作之间究竟有什么区别？

Question

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)

我得到以下结果 -

immutable - id(a)==id(a1) True
immutable   - id(b)==id(b1) True
mutable - id(c)==id(c1) False
mutable   - id(d)==id(d1) False

如果我执行深度扫描 -

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

结果相同 -

immutable - id(a)==id(a1) True
immutable   - id(b)==id(b1) True
mutable - id(c)==id(c1) False
mutable   - id(d)==id(d1) False

如果我从事作业操作 -

a1=a
b1=b
c1=c
d1=d

然后结果是 -

immutable - id(a)==id(a1) True
immutable   - id(b)==id(b1) True
mutable - id(c)==id(c1) True
mutable   - id(d)==id(d1) True

有人可以解释这些副本究竟有什么区别吗？它是否与可变的相关？不可变对象？如果是的话，你可以向我解释一下吗？

Answer 1

正常分配操作只会将新变量指向现有对象。 docs解释了浅拷贝和深拷贝之间的区别：

  

浅层和深层复制之间的区别仅与之相关   复合对象（包含其他对象的对象，如列表或   类实例）：

     

  

• 浅层复制构造一个新的复合对象，然后（尽可能）将对它的引用插入到原始对象中找到的对象。

  

• 深层复制构造一个新的复合对象，然后递归地将复制对象插入其中的对象中。   原始

  

这是一个小小的演示：

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

Answer 2

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

深层复制与嵌套结构有关。如果您有列表列表，那么深度复制copies嵌套列表也是如此，因此它是一个递归副本。只需复制，您就有了一个新的外部列表，但内部列表是引用。

作业不会复制。它只是设置对旧数据的引用。因此，您需要复制以创建具有相同内容的新列表。

Answer 3

对于不可变对象，创建副本没有多大意义，因为它们不会改变。对于可变对象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    

Answer 4

让我们在图形示例中看到如何执行以下代码：

import copy

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


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

Answer 5

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会发生变化，但列表的每个副本都包含对同一个副本的引用lists - 里面有整数的列表。这意味着，如果您要执行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仍然只包含原始的三个引用。

'深拷贝'不仅会复制外部列表，而且还会进入列表并复制内部列表，这样两个结果对象就不包含任何相同的引用（就可变对象而言）有关）。如果内部列表中包含其他列表（或其他对象，如字典），则它们也会被复制。这是“深层复制”的“深层”部分。

Answer 6

在python中，当我们将list，tuples，dict等对象分配给另一个通常带有'='符号的对象时，python会通过引用创建副本的。也就是说，假设我们有一个列表如下：

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

我们将另一个列表分配给此列表，如：

list2 = list1

然后如果我们在python终端中打印list2，我们就会得到这个：

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

list1＆amp; 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 '] ]

现在，深层复制有助于彼此创建完全隔离的对象。如果通过Deep Copy复制了两个对象，则父对象和父对象都会复制。它的孩子将指向不同的记忆位置。 示例：

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

希望它有所帮助。

Answer 7

下面的代码演示了赋值，使用复制方法的浅拷贝，使用（slice）[：]的浅拷贝和deepcopy之间的区别。下面的示例使用嵌套列表，使差异更明显。

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

Answer 8

要采取的GIST是这样的： 使用＆＃34;正常分配＆＃34;处理浅层列表（没有子列表，只有单个元素）提高副作用＆＃34;当您创建浅表列表然后使用＆＃34;正常分配＆＃34;创建此列表的副本时。这种＆＃34;副作用＆＃34;是当您更改创建的副本列表的任何元素时，因为它将自动更改原始列表的相同元素。那就是copy派上用场时，因为它在更改复制元素时不会更改原始列表元素。

另一方面，copy确实有副作用＆＃34;同样，当你有一个包含列表的列表（sub_lists）时，deepcopy解决它。例如，如果您创建一个包含嵌套列表的大型列表（sub_lists），并创建此大列表（原始列表）的副本。 ＆＃34;副作用＆＃34;修改复制列表的子列表时会出现，该列表会自动修改大列表的子列表。有时（在某些项目中）您希望保留大型列表（原始列表），而不进行修改，您只需要复制其元素（sub_lists）。为此，您的解决方案是使用deepcopy来处理这个＆＃34;副作用＆＃34;并制作副本而不修改原始内容。

copy和deep copy操作的不同行为仅涉及复合对象（即：包含其他对象（如列表）的对象）。

以下是此简单代码示例中说明的差异：

首先

通过创建原始列表和此列表的副本，让我们检查copy（浅）的行为：

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]

Answer 9

>>lst=[1,2,3,4,5]

  

    

a = lst

         

b = lst [：]

         

      

b       [1、2、3、4、5]

             

a       [1、2、3、4、5]

             

第一个是b       错误

             

第一个是       是

             

id（lst）       46263192

             

id（a）       46263192 ------>请参阅此处a的id和lst的id相同，因此其称为深度复制甚至布尔答案都是正确的

             

id（b）       46263512 ------>请参阅此处b的id和lst的id不相同，因此尽管输出看起来相同，但其称为“浅表复制”甚至是布尔型回答都是错误的。

    

  

Answer 10

不确定上面是否提到了它，但是要理解.copy（）创建对原始对象的引用是非常重要的。如果更改复制的对象-则更改原始对象。 .deepcopy（）创建新对象，并将原始对象真正复制到新对象。更改新的深层复制对象不会影响原始对象。

是的，.deepcopy（）递归复制原始对象，而.copy（）创建一个引用对象到原始对象的第一级数据。

因此.copy（）和.deepcopy（）之间的复制/引用差异很大。

Answer 11

深层复制与嵌套结构有关。如果您有列表列表，则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] 复制方法将外部列表的内容复制到新列表，但两个列表的内部列表仍然相同，因此，如果在任何列表的内部列表中进行更改，都会影响两个列表。

但是，如果您使用Deep复制，那么它也会为内部列表创建新实例。

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]