浅拷贝与深拷贝

是什么，为什么存在

Python 变量保存的是对象引用。backup = settings 这样的赋值会把另一个名称绑定到同一个对象，并不会复制对象。如果任一名称访问并修改了可变对象，另一个名称也会看到变化。

对象的 对象标识（object identity） 可判断两个引用是否指向同一个对象。is 运算符比较标识，== 则询问对象的值是否相等。因此，两个复制得到的列表可以满足 left == right，同时 left is right 为假。

如果代码必须保留源值，同时修改派生值，就需要复制。常见边界包括：从配置模板创建单次请求的设置、在多项测试之间复用测试夹具，或把可变快照传给不得修改存储状态的代码。应该由所需的边界决定使用哪种操作，而不是只看对象是否嵌套。

copy 模块提供 3 种相关操作。copy.copy() 创建浅拷贝，copy.deepcopy() 创建深拷贝，copy.replace() 创建相同类型的对象并替换指定字段。第 3 种操作在 Python 3.13 中加入，也包含在这里验证的 Python 3.14 目标中。

这些操作并不保证每个可达对象都获得新标识。不可变值通常可以安全共享，函数和类会原样返回，一些持有资源的对象则无法复制。有用的复制是一项明确的对象所有权策略，不是内存的逐字节复刻。

工作原理

可以把复合对象看成 对象图（object graph） 。容器和实例是节点，它们对其他对象的引用是边。复制操作决定哪些节点是新的，以及哪些边仍指向现有节点。

赋值不会创建新的图节点。 浅拷贝（shallow copy） 创建一个新的外层节点，并把源对象直接子项的引用放进去。 深拷贝（deep copy） 遍历可达对象，并在复制协议支持时递归构造替代对象。

图中说明了两种效果：改写 shallow 的顶层字段不会重新绑定 source 中的字段，但修改共享的 items 列表会同时影响两者。深拷贝指向另一个列表，因此通过这条边发生的修改彼此隔离。

浅拷贝

copy.copy(value) 会询问值的类型应如何进行浅拷贝。对于内置容器，records.copy()、dict(mapping) 或完整切片等直接形式可能更清楚地表达「只复制当前容器」的意图。复制子类时，这些直接形式可能返回基类实例，而 copy.copy() 通常保留源对象的类型。

只要复制操作对该类型有意义，它只保证外层对象是新的。列表元素、字典值以及普通实例的属性仍然是原来的引用。替换副本中的某个槽位不会影响源对象，但修改通过共享槽位访问到的对象仍会影响两者。

常见写法的作用范围如下：

这张表描述的是所有权，而不是相等性。刚构造完成时，这 5 种结果都可能与源对象比较相等。真正重要的差异要通过对象标识和后续修改来观察。

深拷贝

copy.deepcopy(value) 会递归跟随引用，但不会独立克隆每一条边。在一次遍历中，它维护一个 备忘字典（memo dictionary） ，把源对象标识映射到已复制对象。再次遇到同一个源对象时，它会复用已经创建的副本。

memo 解决了两个结构问题。遇到循环时，新对象可以指回自身，不会无限递归；源对象中两条边共享同一个子对象时，复制后的两条边也可以共享对应的一个子对象。保留这种拓扑关系是正确深拷贝行为的一部分。

深拷贝也可能复制过多内容。类中可能含有本应共享的不可变目录、需要清空的缓存，或应该重新创建而不是复制的锁。因此，类可以定义 __deepcopy__(self, memo)，无需接受通用的逐字段策略。

选择操作

先从计划执行的修改出发，画出从根对象到目标对象的路径。凡是修改必须隔离的路径，复制操作都要沿途创建新节点。如果所有权清楚，其他位置保持共享完全可以是正确且有用的选择。

按以下顺序判断：

1. 确实需要共享标识时，使用赋值。
2. 只有外层容器或实例会变化时，使用浅拷贝。
3. 可达的可变对象图必须隔离，而且所有成员都支持合理复制策略时，使用深拷贝。
4. 需要创建新记录并按名称修改字段，而不是递归复制时，使用 copy.replace()。

测试应同时断言值和标识关系。== 用于确认数据符合预期，经过选择的 is 检查则确认哪些可变部分共享、哪些相互独立。完成这些检查后，再修改一个副本，就能通过行为验证所有权边界，而不只是检查结构。

API 设计中的复制边界

在每个入口和出口都复制，并不会自动形成防御式设计。这样做可能掩盖不清楚的所有权，调用者也无法判断 API 返回的是实时视图、浅快照，还是隔离的对象图。应在操作名称或文档中写明这项契约。

不可变返回类型往往比深拷贝更能清楚表达边界。由不可变记录构成的元组，无需在每次读取前递归复制。如果确实需要修改，可以用创建下一个有效领域值的方法，并在同一边界校验变更。

对于可变输入，要明确被调用方是仅在调用期间借用对象、保存引用、取得浅快照，还是拥有隔离副本。这项决定也会影响并发调用者能观察到什么。复制不会让原本不安全的共享服务自动获得线程安全性。

最窄且正确的边界通常最容易测试。如果只会修改某个列表，就只复制该列表。如果字段遵循不同的所有权规则，应选择类级策略或具名构造函数。

示例

下面的示例依次展示普通容器、对象图拓扑、结构化替换和类自定义策略。所有输出均由 Python 3.14 实际生成。

赋值、浅拷贝与深拷贝

这个示例从同一个嵌套字典出发，分别采用 3 种处理方式。修改操作有意同时涉及一个顶层字段和两个嵌套列表，以便清楚显示边界。

修改 alias["owner"] 会改变 source，因为这两个名称指向同一个字典。浅拷贝已经拥有自己的顶层 owner 槽位，因此这次重新绑定不会影响它。

源字典与浅拷贝字典都指向同一个 items 列表。更新列表中的字典时，两个根对象都能看到变化。深拷贝拥有不同的列表和嵌套字典，所以新增元素以及原来的数量值都保持隔离。

共享子对象与循环

深拷贝会保留对象图内部的关系。这里有两个键共享同一个角色列表，self 键则指回根字典。

import copy

shared_roles = ["reader"]
account = {"primary": shared_roles, "backup": shared_roles}
account["self"] = account

clone = copy.deepcopy(account)

print("new root:", clone is not account)
print("new roles:", clone["primary"] is not account["primary"])
print("alias preserved:", clone["primary"] is clone["backup"])
print("cycle preserved:", clone["self"] is clone)

clone["primary"].append("editor")
print("source roles:", account["primary"])
print("clone roles:", clone["backup"])

new root: True
new roles: True
alias preserved: True
cycle preserved: True
source roles: ['reader']
clone roles: ['reader', 'editor']

复制得到的角色列表与源列表相互独立，但副本中的 primary 和 backup 仍共享一个列表。deepcopy() 不会把源对象中的这两条引用变成彼此无关的值。反向引用也会指向 clone，而不是 account。

因此，深拷贝测试不能只有修改断言。如果领域模型依赖重复引用和循环，还应验证这些关系。树形测试夹具无法暴露只在对象图中出现的错误。

替换字段而不递归复制

copy.replace() 支持具名元组、数据类，以及实现了 __replace__() 的类。它会创建相同类型的对象并应用具名变更，未变字段则遵循该类型的替换语义。

from copy import replace
from dataclasses import dataclass


@dataclass(frozen=True)
class Job:
    queue: str
    labels: list[str]


template = Job(queue="normal", labels=["billing"])
urgent = replace(template, queue="urgent")

print(template)
print(urgent)
print("same labels:", urgent.labels is template.labels)

urgent.labels.append("priority")
print("template labels:", template.labels)

Job(queue='normal', labels=['billing'])
Job(queue='urgent', labels=['billing'])
same labels: True
template labels: ['billing', 'priority']

新的 Job 使用了不同的 queue，但 replace() 不会深拷贝 labels。即使数据类已经冻结，其中仍然可以包含可变对象；冻结只会阻止重新绑定字段，不会阻止通过列表引用执行修改。

未变字段可以安全共享或本身就是不可变值时，适合使用替换。如果 labels 必须隔离，应在变更中显式传入复制后的列表：replace(template, queue="urgent", labels=template.labels.copy())。

为类定义复制行为

这个 Node 类明确给出了浅拷贝策略，并实现了可安全处理对象图的深拷贝策略。深拷贝钩子会先登记新节点，再递归复制子节点。

import copy


class Node:
    def __init__(self, name):
        self.name = name
        self.children = []

    def __copy__(self):
        clone = type(self)(self.name)
        clone.children = self.children
        return clone

    def __deepcopy__(self, memo):
        clone = type(self)(self.name)
        memo[id(self)] = clone
        clone.children = copy.deepcopy(self.children, memo)
        return clone


root = Node("root")
leaf = Node("leaf")
root.children = [leaf, leaf, root]

shallow = copy.copy(root)
deep = copy.deepcopy(root)

print("shallow shares list:", shallow.children is root.children)
print("deep has new list:", deep.children is not root.children)
print("deep keeps alias:", deep.children[0] is deep.children[1])
print("deep keeps cycle:", deep.children[2] is deep)

shallow shares list: True
deep has new list: True
deep keeps alias: True
deep keeps cycle: True

__copy__() 不接收 memo，并且有意复用子节点列表。__deepcopy__() 接收本次遍历的 memo，先登记占位对象，再把同一个字典传给递归调用。memo 应视为 deepcopy() 所拥有的不透明内部记录。

先登记副本非常重要，因为 root 会在自己的子节点中再次出现。递归到达这条边时，memo 已经建立从源根节点到副本的映射。重复出现的 leaf 边也会解析到同一个已复制叶节点。

陷阱

把赋值当成复制

认为浅拷贝能隔离嵌套状态

把 deepcopy() 当成通用安全包装

破坏 memo 契约

混淆替换与深拷贝

用相等性测试独立性

延伸阅读

• Python 3.14 copy 模块
• Python 3.14 数据模型：对象、值与类型
• Python 3.14 copyreg 模块