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

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使用相同的数据；is总是相同的。对于可变对象，因为它们可能会更改，所以浅复制会创建一个新对象。

深度复制与嵌套结构相关。如果你有列表的列表，那么deepcopy copies嵌套的列表，所以它是一个递归的副本。使用just copy，你有了一个新的外部列表，但内部列表是引用。

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

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