python必背源代码深拷贝浅拷贝copy代码

纸上星河
纸上星河
发布时间:2026-11-18 | 2人浏览过
原创

全面解析Python深拷贝与浅拷贝的核心区别与必背源代码。包含copy.copy与copy.deepcopy的内存原理、不可变与可变对象处理、经典避坑示例及自定义类深拷贝实现。

在Python中,处理复合数据复制的核心答案是明确三者的边界:直接赋值 b = a 仅创建对象的新引用别名;浅拷贝 copy.copy(a) 创建新的顶层容器,但嵌套子对象依然共享相同内存;深拷贝 copy.deepcopy(a) 则通过递归机制复制所有层级,生成完全解耦的崭新对象。理解并正确运用标准库 copy 模块的代码,是杜绝程序中由于“意外修改原始数据”导致静默数据污染的根本解法。
python必背源代码深拷贝浅拷贝copy代码
图 0:Python 变量赋值、浅拷贝与深拷贝核心特性速览

一、必背核心模板与三种操作基本对比

当需要操作已有列表或字典并保留初始状态时,最常混淆的就是等号赋值、浅拷贝和深拷贝。掌握其本质最直接的途径是观察对象的内存物理地址 id()。

Python 必背代码 1:三种拷贝方式的基础语法与内存地址对比
import copy

# 1. 原始嵌套列表
original = [10, [20, 30]]

# 2. 直接赋值:同一个对象的引用别名
alias = original

# 3. 浅拷贝:复制最外层容器,内层引用共享
shallow = copy.copy(original)
# 注:对于列表,original[:] 或 original.copy() 效果与 copy.copy 一致

# 4. 深拷贝:递归复制全部层级,完全独立
deep = copy.deepcopy(original)

# 打印各对象及其内层子列表的内存ID
print(f"原对象 ID: {id(original)}, 内层 ID: {id(original[1])}")
print(f"赋值别名 ID: {id(alias)}, 内层 ID: {id(alias[1])}")
print(f"浅拷贝 ID: {id(shallow)}, 内层 ID: {id(shallow[1])}")
print(f"深拷贝 ID: {id(deep)}, 内层 ID: {id(deep[1])}")
示例输出(内存地址数值因环境而异,重点观察地址是否相等)
原对象 ID: 4352108864, 内层 ID: 4352109504
赋值别名 ID: 4352108864, 内层 ID: 4352109504
浅拷贝 ID: 4352110272, 内层 ID: 4352109504
深拷贝 ID: 4352110592, 内层 ID: 4352110848

从输出结果可以观察到:

  • 直接赋值:alias 与 original 的外层和内层 ID 完全相同,它们本质上是绑定到同一块内存区域的两个变量标签。
  • 浅拷贝:shallow 获得了崭新的外层列表 ID(4352110272),但其内部保存的嵌套列表 shallow[1] 依然指向原对象的子列表(4352109504)。
  • 深拷贝:deep 的外层 ID 与内层 ID 全部重新分配,与原始数据无任何指针交叉。
python必背源代码深拷贝浅拷贝copy代码
图 1:直接赋值、浅拷贝与深拷贝在内存中的指针与对象层级结构分布图

二、浅拷贝的实现方式与嵌套修改风险

浅拷贝在日常开发中使用非常高频。除了调用 copy.copy() 之外,Python 的内置类型还提供了多种语法糖:

  • 列表切片:b = a[:]
  • 列表与集合内置方法:b = a.copy() 或工厂函数 b = list(a)
  • 字典拷贝:b = dict_a.copy() 或 b = dict(dict_a)

当数据结构只有一层(扁平结构,无嵌套容器)时,浅拷贝安全且效率极高。但如果数据存在嵌套列表或字典,修改浅拷贝的内层数据会直接反噬原始对象。

Python 必背代码 2:浅拷贝嵌套可变对象的副作用演示
import copy

# 定义包含嵌套可变列表的数据
data_source = ["web_config", ["port: 8080", "debug: True"]]

# 进行浅拷贝
copied_cfg = copy.copy(data_source)

# 1. 修改外层不可变元素:互不干扰
copied_cfg[0] = "production_config"
print(f"修改外层后 original[0]: {data_source[0]}")
print(f"修改外层后 copied[0]:   {copied_cfg[0]}")

# 2. 修改内层嵌套列表:产生连锁副作用!
copied_cfg[1].append("ssl: False")
print(f"修改内层后 original[1]: {data_source[1]}")
print(f"修改内层后 copied[1]:   {copied_cfg[1]}")
示例输出
修改外层后 original[0]: web_config
修改外层后 copied[0]:   production_config
修改内层后 original[1]: ['port: 8080', 'debug: True', 'ssl: False']
修改内层后 copied[1]:   ['port: 8080', 'debug: True', 'ssl: False']
关键解释: 当执行 copied_cfg[0] = ... 时,是对新列表的第一个位置重新赋指针,原列表不受影响;但执行 copied_cfg[1].append(...) 时,并没有修改 copied_cfg[1] 本身的指针,而是顺着指针在原地修改了所指向的列表对象。因为原对象的第一个槽位也指向该列表,所以原对象同步被改动。
python必背源代码深拷贝浅拷贝copy代码
图 2:浅拷贝在嵌套修改场景下的数据流转与副作用推导步骤

三、深拷贝运作机制与循环引用处理

为了彻底切断内层可变对象的关联,必须使用 copy.deepcopy()。深拷贝内部维护了一个名为 memo 的字典,用于记录每一个已复制对象的 id()。

memo 字典承担两大任务:一是确保同一个子对象被多次引用时,在拷贝后保持相同的对应关系;二是彻底避免对象之间存在相互引用(循环引用)时导致递归无限死循环。

Python 必背代码 3:深拷贝处理复杂嵌套与循环引用
import copy

# 1. 复杂嵌套字典
service_data = {
    "service_name": "auth_center",
    "cluster": {"node_a": "192.168.1.10", "node_b": "192.168.1.11"},
    "tags": ["core", "security"]
}

safe_clone = copy.deepcopy(service_data)

# 独立修改深拷贝对象的内层结构
safe_clone["cluster"]["node_a"] = "10.0.0.1"
safe_clone["tags"].append("v2")

print("原配置 node_a:", service_data["cluster"]["node_a"]) # 保持 192.168.1.10
print("新配置 node_a:", safe_clone["cluster"]["node_a"])   # 独立为 10.0.0.1
print("原配置 tags:  ", service_data["tags"])               # 保持 ['core', 'security']
print("新配置 tags:  ", safe_clone["tags"])                 # 独立为 ['core', 'security', 'v2']

# 2. 循环引用测试:对象包含自身
circular_list = [100]
circular_list.append(circular_list) # 列表内包含自身引用

deep_circular = copy.deepcopy(circular_list)
print("原循环列表元素数:", len(circular_list))
print("深拷贝成功执行,自身引用已独立:", deep_circular[1] is deep_circular)
print("深拷贝后的循环列表与原列表不同:", deep_circular is not circular_list)
示例输出
原配置 node_a: 192.168.1.10
新配置 node_a: 10.0.0.1
原配置 tags:   ['core', 'security']
新配置 tags:   ['core', 'security', 'v2']
原循环列表元素数: 2
深拷贝成功执行,自身引用已独立: True
深拷贝后的循环列表与原列表不同: True

deepcopy 之所以不会在循环引用中触发 RecursionError,正是因为其在遍历前会先查验 memo 映射,一旦发现该对象正在被构建,就会直接返回已创建的副本指针。

四、不可变对象的拷贝特殊性

Python 解释器在内存管理上具有优化机制。对于不可变对象(如 int、float、str、不含可变元素的 tuple、frozenset),即使调用 copy.copy() 或 copy.deepcopy(),Python 也不会开辟新内存,而是直接返回原对象的引用。因为不可变对象内容无法更改,共享内存不会产生任何并发或污染隐患。

Python 必背代码 4:不可变对象与混合元组的拷贝测试
import copy

# 1. 纯不可变元组
t1 = (1, 2, 3)
t1_shallow = copy.copy(t1)
t1_deep = copy.deepcopy(t1)

# 均为同一个对象
print("纯元组浅拷贝是否为同对象:", t1_shallow is t1) # True
print("纯元组深拷贝是否为同对象:", t1_deep is t1)    # True

# 2. 混合元组(元组内包含可变列表)
t2 = (1, [2, 3])
t2_shallow = copy.copy(t2)
t2_deep = copy.deepcopy(t2)

print("混合元组浅拷贝是否为同对象:", t2_shallow is t2) # True (外层元组不可变,依然复用)
print("混合元组深拷贝是否为同对象:", t2_deep is t2)    # False (内层含可变列表,触发完整深拷贝)
print("内层列表是否独立:", t2_deep[1] is not t2[1])     # True (内层列表已被完全复制)
示例输出
纯元组浅拷贝是否为同对象: True
纯元组深拷贝是否为同对象: True
混合元组浅拷贝是否为同对象: True
混合元组深拷贝是否为同对象: False
内层列表是否独立: True

五、自定义类中的深浅拷贝支持

在面向对象编程中,如果自定义类包含动态资源(如数据库游标、套接字、日志文件句柄或大型缓存),直接使用 copy.deepcopy 可能会复制不需要的连接,甚至因为对象不可序列化而抛出异常。

Python 允许类通过重写 __copy__(self) 和 __deepcopy__(self, memo) 方法定制拷贝逻辑。

Python 必背代码 5:自定义类重写深浅拷贝的规范模板
import copy

class TaskContext:
    def __init__(self, task_id, params, log_handle=None):
        self.task_id = task_id
        self.params = params         # 可变字典
        self.log_handle = log_handle # 模拟外部资源句柄

    def __copy__(self):
        """浅拷贝:复制对象实例,但内部 params 字典共享"""
        cls = self.__class__
        result = cls.__new__(cls)
        result.__dict__.update(self.__dict__)
        return result

    def __deepcopy__(self, memo):
        """深拷贝:递归复制 params,但排除或重置外部资源句柄"""
        cls = self.__class__
        result = cls.__new__(cls)
        memo[id(self)] = result
        for k, v in self.__dict__.items():
            if k == "log_handle":
                # 排除资源句柄,新对象重新置空或重新初始化
                setattr(result, k, None)
            else:
                setattr(result, k, copy.deepcopy(v, memo))
        return result

# 验证自定义拷贝行为
ctx = TaskContext("TASK-001", {"timeout": 30, "retries": 3}, log_handle="<FileHandle>")
deep_ctx = copy.deepcopy(ctx)

# 验证参数字典是否完全独立
deep_ctx.params["timeout"] = 60
print("原任务参数 timeout:", ctx.params["timeout"])       # 30
print("深拷贝任务参数 timeout:", deep_ctx.params["timeout"]) # 60
print("原任务日志句柄:", ctx.log_handle)                    # <FileHandle>
print("深拷贝后日志句柄已重置:", deep_ctx.log_handle)        # None
示例输出
原任务参数 timeout: 30
深拷贝任务参数 timeout: 60
原任务日志句柄: <FileHandle>
深拷贝后日志句柄已重置: None

六、拷贝方式选择决策流程

深拷贝虽然安全,但其需要递归遍历整个对象图并持续查询 memo 映射,在面对数十万个节点的大型数据时,时间与内存开销可能高出浅拷贝数个数量级。因此在工程实践中,应根据数据特征和修改需求进行精准选型。

python必背源代码深拷贝浅拷贝copy代码
图 3:Python 拷贝方式技术选型决策树

按照决策树逐步筛选:

  1. 仅作为读取别名或传递参数:使用直接赋值 b = a,时间复杂度 O(1),无额外内存损耗。
  2. 扁平列表或字典:优先使用 a[:]、a.copy() 或 dict(a),时间复杂度 O(n),只复制一层容器。
  3. 复杂嵌套只读结构:无需深度解耦,使用 copy.copy(a) 即可节约内存。
  4. 需要独立修改内部子列表或子字典:必须使用 copy.deepcopy(a),避免状态污染。
  5. 包含复杂系统资源(网络/文件/锁):重写 __deepcopy__ 进行显式过滤。

七、必背源代码速查矩阵与避坑提示

以下汇总表提炼了各类拷贝方式的核心语法、独立特性与适用场景,便于在开发中随查随用。

python必背源代码深拷贝浅拷贝copy代码
图 4:Python 拷贝方法必背源代码与特性对比矩阵

高频避坑提示

  • 误区一:切片 [:] 是深拷贝
    很多初学者认为 list_b = list_a[:] 能解决一切复制问题。切片本质上只是针对最外层的浅拷贝,一旦列表内嵌有其他列表,修改子列表依旧会破坏原数据。
  • 误区二:函数默认参数使用可变容器并直接修改
    形如 def add_item(val, target=[]) 的函数,target 在函数定义时只初始化一次。如果需要隔离每次调用的数据,应将默认值设为 None,并在函数内部通过 copy.deepcopy() 或新建空列表处理。
  • 误区三:无节制在循环体内调用 copy.deepcopy
    在性能敏感的循环处理或实时计算中,若数据体量较大,频繁 deepcopy 会导致明显的 CPU 尖刺和 GC 压力。此时应考虑只对真正需要修改的局部子字典/子列表进行复制,而非每次都全量深拷贝整个上下文。
总结记忆口诀:
赋值是别名,指针绑一块;
浅拷换外壳,嵌套依然爱;
深拷全脱胎,层层新房盖;
复合需隔离,deepcopy 最担待。
相关专题:

本站声明

本文内容仅供参考,不代表本站观点。转载或引用请注明出处。如发现内容问题,请通过联系我们页面反馈。

Python 相关产品和应用

全部下载

专题列表