python怎么避免浅拷贝#技术派的书架#引言Python附带了一个名为copy的模块，它提供了特定的复制功能。顾名思义，不可变对象是不可以被修改的，因此，当这些对象的值被修改时，Python会创建一个新的对象。这意味着，当修改可变对象类型的值时，保存对同一对象的引用的所有变量都会受到影响。这意味着，如果这两个变量中的任何一个用于执行就地修改，其他变量也将受到影响。总结在本文中，我们探讨了用Python复制对象的三种基本方法。
python怎么避免浅拷贝?#技术派的书架#，我来为大家科普一下关于python怎么避免浅拷贝?以下内容希望对你有帮助!
python怎么避免浅拷贝
#技术派的书架#
引言Python 附带了一个名为 copy 的模块，它提供了特定的复制功能。在本文中，我们将探索什么是深拷贝和浅拷贝。此外，我们还将讨论它们之间的差异以及何时使用其中一种而不是另一种。
不可变对象 vs 可变对象
在进入 Python 中的浅拷贝和深拷贝之前，首先要理解可变对象类型和不可变对象类型之间的区别。顾名思义，不可变对象是不可以被修改的，因此，当这些对象的值被修改时，Python 会创建一个新的对象。
例如，假设我们有两个变量引用同一个整数对象:
>>> a = 10>>> b = a# variables a and b hold the reference to the same object
现在，如果我们对变量 a 执行任何类型的操作，并且考虑到 Python 中的整数是不可变的，那么结果将会创建一个保存新值的新对象。这意味着对象的旧值(以及引用它的所有变量)将保持不变:
>>> a = a1>>> print(a)11>>> print(b)10
另一方面，可变对象类型允许对对象值进行就地修改。这意味着，当修改可变对象类型的值时，保存对同一对象的引用的所有变量都会受到影响。例如，假设我们确实有以下列表
>>> list_1 = [1, 2, 3]>>> list_2 = list_1
考虑到 Python 中的列表是可变的，如果我们改变这两个列表中的任何一个，这个操作也会对其他变量产生直接影响，因为它们都指向内存中相同的对象引用。
>>> list_1[0] = 0>>> print(list_1)[0, 2, 3]>>> print(list_2)[0, 2, 3]
复制对象最直接的方法是通过常规的赋值操作。假设我们有一下操作：
a = [1, 2, 3]b = a
在这种情况下，变量 a 和 b 对同一个对象都有相同的引用。这意味着，如果这两个变量中的任何一个用于执行就地修改，其他变量也将受到影响。
>>> a[0] = 0>>> print(a)[0, 2, 3]>>> print(b)[0, 2, 3]
因此，当我们必须处理不可变的对象类型时，通常会使用常规的赋值操作。在这种情况下，当使用两个变量中的任何一个执行操作时，另一个变量将保持不变，因为它的引用指向的是不变的旧对象。
>>> id(a) == id(b)True
Python 中的赋值语句不复制对象，它们在目标和对象之间创建绑定。
浅拷贝 vs 深拷贝在深入讨论浅拷贝和深拷贝的细节之前，请注意，它们的区别只有在我们必须处理本质上是嵌套结构的复合对象时才有意义。换句话说，复合对象是包含其他对象的对象，例如，列表列表或集合字典。
一个浅拷贝将获得一个原始对象的副本并创建一个新的复合对象，但是如果我们正在复制的对象是一个复合对象，那么内部对象将与在原始对象中找到的对象相同。
>>> import copy>>> b = copy.copy(a)>>> id(a) == id(b)False
如我们所见，列表对象 a 和 b 是不同的，这意味着它们持有指向内存中不同对象的不同引用（即使这些对象的值相同）。
当我们需要处理复合对象时，事情会变得有点复杂。现在让我们假设变量 a 是一个复合对象，它表示一个列表列表:
a = [[1, 2, 3], [4, 5, 6]]
现在让我们对 a 进行浅拷贝：
>>> import copy>>> b = copy.copy(a)
我们可以看到 a 和 b 是不同的对象：
>>> id(a) == id(b)False
然而，内部对象(即两个内部列表)与原始对象引用的对象相同:
>>> id(a[0]) == id(b[0])True
这是非常危险的，因为任何内部列表的更改都会影响引用这些内部列表的其他复合对象:
>>> a[0][0] = 0>>> a[[0, 2, 3], [4, 5, 6]]>>> b[[0, 2, 3], [4, 5, 6]]
因此，只有当我们不必处理复合对象时，浅拷贝才适用。
浅拷贝构造一个新的复合对象，然后（在可能的范围内）将对原始对象中找到的对象的引用插入其中。
深层拷贝将获取原始对象的副本，然后递归地获取找到的内部对象的副本(如果有的话)。
>>> import copy>>> a = [[1, 2, 3], [4, 5, 6]]>>> b = copy.deepcopy(a)
同样，我们可以看到原始对象和复制对象在本质上是不同的:
>>> id(a) == id(b)False
但在这种情况下，即使是内部对象也会不同:
>>> id(a[0]) == id(b[0])False
这意味着 a 中任何嵌套列表的更改都不会影响对象 b 中的相应列表:
>>> a[0][0] = 0>>> a[[0, 2, 3], [4, 5, 6]]>>> b[[1, 2, 3], [4, 5, 6]]
因此，当我们必须处理复合对象并希望确保任何内部对象的更改都不会影响引用相同对象的其他变量时，深拷贝更为合适。
深拷贝构造一个新的复合对象，然后递归地将原始对象中找到的对象的副本插入其中。
总结在本文中，我们探讨了用 Python 复制对象的三种基本方法。最初，我们讨论了不可变对象类型和可变对象类型之间的区别。不需要复制不可变物件类型，因为这些实例的值永远不会改变。另一方面，开发人员在修改可变对象类型时需要非常小心，因为这个操作可能会潜在地影响保存相同对象的引用的其他变量。当此类对象就地更改时，引用同一对象的所有其他变量也将受到此更改的影响。
因此，了解如何正确地复制可变对象以避免代码中的 bug 非常重要。回想一下，一个浅拷贝将从原始对象中创建一个新对象，但是如果对象包含其他对象，那么内部对象将不会被复制。另一方面，深度拷贝将为复合对象中包含的内部对象创建一个新对象。
