Python 对象的浅复制与深复制

制作浅副本

在下面的示例中，我们将创建一个新的嵌套列表，然后浅浅地复制它与list()工厂功能：

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

这意味着ys现在将是一个新的独立对象，其内容与xs。您可以通过检查这两个对象来验证这一点：

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

确认ys确实与原始版本无关，让我们设计一个小实验。您可以尝试将新的子列表添加到原始（xs），然后检查以确保此修改不会影响副本（ys):

>>> xs.append(['new sublist'])
>>> xs
[[1, 2, 3], [4, 5, 6], [7, 8, 9], ['new sublist']]
>>> ys
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

正如您所看到的，这达到了预期的效果。在“表面”层面修改复制的列表完全没有问题。

然而，因为我们只创建了一个浅的原始清单的副本，ys仍然包含对存储在中的原始子对象的引用xs.

这些孩子是not复制的。它们只是在复制的列表中再次被引用。

因此，当您修改其中的子对象之一时xs，此修改将反映在ys也是——那是因为两个列表共享相同的子对象。该副本只是浅层、一层深的副本：

>>> xs[1][0] = 'X'
>>> xs
[[1, 2, 3], ['X', 5, 6], [7, 8, 9], ['new sublist']]
>>> ys
[[1, 2, 3], ['X', 5, 6], [7, 8, 9]]

在上面的例子中，我们（看起来）只做了改变xs。但事实证明两个都索引 1 处的子列表xs and ys被修改。同样，发生这种情况是因为我们只创建了一个浅的原始列表的副本。

如果我们创建了一个深的备份xs第一步，两个对象都是完全独立的。这是对象的浅拷贝和深拷贝之间的实际区别。

现在您知道如何创建一些内置集合类的浅拷贝，并且知道浅拷贝和深拷贝之间的区别。我们仍然希望得到答案的问题是：

• 如何创建内置集合的深层副本？
• 如何创建任意对象（包括自定义类）的副本（浅层和深层）？

这些问题的答案就在于copyPython 标准库中的模块。这模块提供了一个简单的接口，用于创建任意Python对象的浅拷贝和深拷贝。

制作深层副本

让我们重复前面的列表复制示例，但有一个重要的区别。这次我们要创建一个深的使用复制deepcopy()函数定义在copy模块代替：

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

当你检查时xs和它的克隆zs我们用它创建的copy.deepcopy()，您会发现它们看起来再次相同 - 就像前面的示例一样：

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

但是，如果您对原始对象中的子对象之一进行修改（xs），你会发现这个修改不会影响深拷贝（zs).

这次，原始对象和副本这两个对象都是完全独立的。xs被递归克隆，包括其所有子对象：

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

您现在可能想花一些时间坐下来使用 Python 解释器并玩一下这些示例。当您亲自体验和使用示例时，您会更容易专注于复制对象。

顺便说一句，您还可以使用以下函数创建浅拷贝copy模块。这copy.copy()函数创建对象的浅拷贝。

如果您需要清楚地表明您正在代码中的某个位置创建浅表副本，那么这非常有用。使用copy.copy()让您表明这一事实。然而，对于内置集合，简单地使用列表、字典和集合工厂函数来创建浅拷贝被认为更Pythonic。

复制任意Python对象

我们仍然需要回答的问题是如何创建任意对象（包括自定义类）的副本（浅层和深层）。现在让我们看一下。

再次copy模块来拯救我们。它是copy.copy()和copy.deepcopy()函数可用于复制任何对象。

再次强调，了解如何使用它们的最佳方法是进行简单的实验。我将基于之前的列表复制示例。让我们从定义一个简单的 2D 点类开始：

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})'

我希望您同意这非常简单。我添加了一个__repr__()实现，以便我们可以轻松地在 Python 解释器中检查从此类创建的对象。

笔记：上面的例子使用了一个Python 3.6 f 字符串构造返回的字符串__repr__。在 Python 2 和 3.6 之前的 Python 3 版本上，您将使用不同的字符串格式化表达式，例如：

def __repr__(self):
    return 'Point(%r, %r)' % (self.x, self.y)

接下来，我们将创建一个Point实例，然后（浅层）复制它，使用copy模块：

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

如果我们检查原件的内容Point对象及其（浅）克隆，我们看到了我们所期望的：

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

还有其他需要记住的事情。因为我们的点对象使用不可变类型（int）作为其坐标，所以在这种情况下浅拷贝和深拷贝之间没有区别。但我稍后会扩展这个例子。

让我们继续看一个更复杂的例子。我将定义另一个类来表示 2D 矩形。我将以一种允许我们创建更复杂的对象层次结构的方式来完成它 - 我的矩形将使用Point对象来表示它们的坐标：

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)

如果你检查原始矩形及其副本，你会发现它们的效果是多么好__repr__()覆盖正在发挥作用，并且浅复制过程按预期工作：

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

我希望这会按照您的预期进行。接下来，我将创建原始矩形的深层副本。然后我将应用另一个修改，您将看到哪些对象受到影响：

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

瞧！这次是深拷贝（drect) 完全独立于原来的 (rect）和浅拷贝（srect).

我们已经在这里介绍了很多内容，对于复制对象仍然有一些更好的要点。

深入研究这个主题是值得的（哈！），所以你可能想研究一下复制模块文档。例如，对象可以通过定义来控制它们的复制方式特殊方法 __copy__()和__deepcopy__()在他们。

3 件事要记住

• 制作对象的浅表副本不会克隆子对象。因此，副本并不完全独立于原件。
• 对象的深层复制将递归地克隆子对象。克隆完全独立于原始副本，但创建深层副本速度较慢。
• 您可以使用以下命令复制任意对象（包括自定义类）copy模块。

如果您想深入了解其他中级 Python 编程技术，请查看此免费奖励：