Python赋值语句=

在 Python 中，赋值语句不会复制对象，而是在目标和对象之间创建绑定关系。当我们使用 = 运算符时，它只创建一个共享原始对象引用的新变量。为了创建这些对象的“真实副本”或“克隆”，我们可以使用 Python 中的复制模块。

Python Deepcopy 和Shallowcopy

Deepcopy的语法

语法：copy.deepcopy（x）

Shallowcopy 的语法

语法：copy.copy（x）

浅层和深层副本的用法。

• 浅拷贝 是使用 copy.copy（） 创建的，它保留了顶级结构，但共享对内部列表的引用。
• 深拷贝 copy.deepcopy（） 创建完全独立的副本 包括所有嵌套元素。

copy模块代码

import copy
li1 = [1, 2, [3, 5], 4]
li2 = copy.copy(li1)
print("li2 ID: ", id(li2), "Value: ", li2)

li3 = copy.deepcopy(li1)
print("li3 ID: ", id(li3), "Value: ", li3)

li2 ID:  2521878674624 Value:  [1, 2, [3, 5], 4]
li3 ID:  2521878676160 Value:  [1, 2, [3, 5], 4]

如何理解浅拷贝的实际效果

import copy
li1 = [1, 2,   [3, 5]  , 4]
li2 = copy.copy(li1)
print("li2 ID: ", id(li2), "Value: ", li2)

可以看到 li2是一个新副本 [3, 5]是列表中的第三个元素，也是一个列表

现在我们把 li2中的第三个元素中添加一个瓣的元素7,后再看一下 li1， li2中的数据情况

import copy
li1 = [1, 2,   [3, 5]  , 4]
li2 = copy.copy(li1)
print("====before ====")
print("li1 " , li1 )
print("li2 " , li2 )
print("====after ====")
li2[2].append(7)
print("li1 " , li1 )
print("li2 " , li2 )

看一下结果

====before ====
li1  [1, 2, [3, 5], 4]
li2  [1, 2, [3, 5], 4]
====after ====
li1  [1, 2, [3, 5, 7], 4]
li2  [1, 2, [3, 5, 7], 4]

可以发现我们只是在li2中的第三个元素中添加了一个新元素，但是 li1的内容也被同时更改了。因为第三个元素 [3, 5]其实是同个个对象。

如何理解浅拷贝的负作用，下面的代码与之前的作用是一样的。

import copy
sharedO阳 = [3, 5]
li1 = [1, 2, sharedO阳    , 4]
li2 = copy.copy(li1)

print(id(sharedO阳) )
print(id(li1[2]) )
print(id(li2[2]) )
 

2231145442496
2231145442496
2231145442496

通过查看列表中的第三个元素的id发现其实copy之后听对象其实还是同一个对象，这也就解释了为什么向li2的第三个元素append新元素时，li1的内容也变化了。

浅拷贝 是使用 copy.copy（） 创建的，它保留了顶级结构，但共享对内部列表的引用

什么是Python 中的深度复制？

深层复制会创建一个新的对象，然后以递归方式将原始对象中的项的副本插入其中。这意味着首先构造一个新的对象，然后用原始对象中找到的子对象的副本递归填充它。在深层复制的情况下，对象的副本被复制到另一个对象中。这意味着 对对象副本所做的任何更改都不会反映在原始对象中。

Python 中的深拷贝可以解决 浅拷贝的问题

import copy
li1 = [1, 2, [3,5], 4]
li2 = copy.deepcopy(li1)
print ("The original elements before deep copying")
for i in range(0,len(li1)):
    print (li1[i],end=" ")
 
print("\r")
li2[2][0] = 7
print ("The new list of elements after deep copying ")
for i in range(0,len( li1)):
    print (li2[i],end=" ")
 
print("\r")
print ("The original elements after deep copying")
for i in range(0,len( li1)):
    print (li1[i],end=" ")

The original elements before deep copying
1 2 [3, 5] 4 
The new list of elements after deep copying 
1 2 [7, 5] 4 
The original elements after deep copying
1 2 [3, 5] 4 

继续看deepcopy

deepcopy时，看一下新对象与旧对象之前有没有关联影响

>>> import copy
>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> zs = copy.deepcopy(xs)

>>> xs
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> zs
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

>>> xs[1][0] = 'X'
>>> xs
[[1, 2, 3], ['X', 5, 6], [7, 8, 9]]
>>> zs
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

可以发现其实这两个对象已经是完全独立的。

class对象的copy

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __repr__(self):
        return f'Point({self.x!r}, {self.y!r})'

>>> a = Point(23, 42)
>>> b = copy.copy(a)

>>> a
Point(23, 42)
>>> b
Point(23, 42)
>>> a is b
False

class Rectangle:
    def __init__(self, topleft, bottomright):
        self.topleft = topleft
        self.bottomright = bottomright

    def __repr__(self):
        return (f'Rectangle({self.topleft!r}, '
                f'{self.bottomright!r})')

rect = Rectangle(Point(0, 1), Point(5, 6))
srect = copy.copy(rect)

>>> rect
Rectangle(Point(0, 1), Point(5, 6))
>>> srect
Rectangle(Point(0, 1), Point(5, 6))
>>> rect is srect
False

>>> rect.topleft.x = 999
>>> rect
Rectangle(Point(999, 1), Point(5, 6))
>>> srect
Rectangle(Point(999, 1), Point(5, 6))

从上面的代码中可以看到 Rectangle被copy出来的新对象，其中的topleft和bottomright这两个对象其实是同一个。因此修改其中一个point的属性后，加一个Rectangle对象中的Rectangle属性也跟着变化，因为这两个Rectangle中的对象其实是一个point

class对象的deepcopy

>>> drect = copy.deepcopy(srect)
>>> drect.topleft.x = 222
>>> drect
Rectangle(Point(222, 1), Point(5, 6))
>>> rect
Rectangle(Point(999, 1), Point(5, 6))
>>> srect
Rectangle(Point(999, 1), Point(5, 6))

可以看到这两个Rectangle对象的属性topleft是完全 都是独立的，因为deepcopy是完全创建了新对象。