深入理解 Python 中的浅拷贝与深拷贝：案例解析与潜在陷阱20240919

🕗 发布于 2024-09-19 21:35 python

深入理解 Python 中的浅拷贝与深拷贝：案例解析与潜在陷阱

引言

在 Python 编程中，浅拷贝（shallow copy）和 深拷贝（deep copy）是两个容易混淆但又非常重要的概念。尤其是在处理嵌套数据结构时，如果对它们理解不够深入，可能会导致一些难以发现的 bug。本文将通过实际案例，深入剖析浅拷贝与深拷贝的原理和区别，帮助您在实际项目中准确应用它们，避免潜在陷阱。

基础概念回顾

在探讨浅拷贝与深拷贝之前，先了解三种常见的赋值方式：

简单赋值：创建一个新的变量名，但它指向与原始对象相同的内存地址。
浅拷贝：创建一个新的对象，但其子对象（如嵌套对象）仍然引用原始对象中的内容。
深拷贝：递归地复制对象以及其包含的所有子对象，生成完全独立的副本。

这些概念的区别不仅影响代码的逻辑正确性，还直接关系到性能的优化，特别是在复杂的嵌套数据结构中。

实战案例解析

案例一：列表的简单赋值与浅拷贝

import copy

# 定义一个嵌套列表
original_list = [[1, 2, 3], [4, 5, 6]]

# 简单赋值
simple_assigned_list = original_list

# 浅拷贝
shallow_copied_list = copy.copy(original_list)

# 修改 simple_assigned_list
simple_assigned_list[0][0] = 'A'

print("Original List:", original_list)
print("Simple Assigned List:", simple_assigned_list)
print("Shallow Copied List:", shallow_copied_list)

输出：

Original List: [['A', 2, 3], [4, 5, 6]]
Simple Assigned List: [['A', 2, 3], [4, 5, 6]]
Shallow Copied List: [['A', 2, 3], [4, 5, 6]]

解释：

简单赋值 和 浅拷贝 都在某种程度上共享了对象的引用。虽然浅拷贝创建了一个新的列表对象，但嵌套的子列表仍然共享相同的引用，因此修改其中一个嵌套对象将影响所有引用了该对象的变量。

案例二：深拷贝的效果

import copy

# 深拷贝
deep_copied_list = copy.deepcopy(original_list)

# 修改 deep_copied_list
deep_copied_list[0][0] = 'B'

print("Original List after deepcopy modification:", original_list)
print("Deep Copied List:", deep_copied_list)

输出：

Original List after deepcopy modification: [['A', 2, 3], [4, 5, 6]]
Deep Copied List: [['B', 2, 3], [4, 5, 6]]

解释：

深拷贝 完全复制了原始列表和其嵌套子对象，因此修改 deep_copied_list 的内容不会影响 original_list。这是因为两者没有共享任何嵌套子对象。

深入分析

简单赋值

行为：不创建新对象，所有变量名指向同一块内存。
内存关系：修改其中一个变量，所有引用该对象的变量都会受到影响。
适用场景：适用于不需要改变原始对象的场景，但当需要修改对象时应谨慎。

浅拷贝

行为：只拷贝对象的顶层结构，不递归复制其子对象。
内存关系：新对象和原对象共享子对象的引用，修改嵌套的可变对象时，原对象也会受到影响。
适用场景：适用于数据结构较为扁平或不包含嵌套可变对象的场景。

深拷贝

行为：递归复制对象及其所有子对象，生成完全独立的新对象。
内存关系：新对象与原对象彻底分离，任何层级的修改都不会互相影响。
适用场景：适用于需要对嵌套数据结构进行深层次修改而不影响原始对象的场景。

实战中的潜在陷阱

错误的二维数组初始化

二维数组的初始化常常容易犯下浅拷贝的错误。例如，以下代码创建的二维数组中的所有行实际上指向相同的列表对象：

# 错误示例
matrix = [[0] * 3] * 3
matrix[0][0] = 1
print(matrix)

输出：

[[1, 0, 0], [1, 0, 0], [1, 0, 0]]

解决方案：

使用列表推导式来确保每一行都是独立的对象：

# 正确示例
matrix = [[0 for _ in range(3)] for _ in range(3)]
matrix[0][0] = 1
print(matrix)

输出：

[[1, 0, 0], [0, 0, 0], [0, 0, 0]]

字典的浅拷贝与深拷贝

同样，字典在浅拷贝和深拷贝中也有类似的问题。修改浅拷贝中的嵌套对象会影响原始字典。

浅拷贝示例

import copy

original_dict = {'a': [1, 2], 'b': [3, 4]}
shallow_copied_dict = copy.copy(original_dict)
shallow_copied_dict['a'][0] = 100

print("Original Dict:", original_dict)
print("Shallow Copied Dict:", shallow_copied_dict)

输出：

Original Dict: {'a': [100, 2], 'b': [3, 4]}
Shallow Copied Dict: {'a': [100, 2], 'b': [3, 4]}

深拷贝示例

deep_copied_dict = copy.deepcopy(original_dict)
deep_copied_dict['a'][0] = 200

print("Original Dict after deepcopy modification:", original_dict)
print("Deep Copied Dict:", deep_copied_dict)

输出：

Original Dict after deepcopy modification: {'a': [100, 2], 'b': [3, 4]}
Deep Copied Dict: {'a': [200, 2], 'b': [3, 4]}

自定义类的拷贝问题

在处理自定义类时，浅拷贝和深拷贝的区别同样适用。如果类中包含嵌套的可变对象，浅拷贝可能会带来意想不到的结果。

浅拷贝问题

import copy

class MyClass:
    def __init__(self, data):
        self.data = data

obj = MyClass([1, 2, 3])
shallow_copied_obj = copy.copy(obj)
shallow_copied_obj.data[0] = 'X'

print("Original Object Data:", obj.data)
print("Shallow Copied Object Data:", shallow_copied_obj.data)

输出：

Original Object Data: ['X', 2, 3]
Shallow Copied Object Data: ['X', 2, 3]

深拷贝解决方案

deep_copied_obj = copy.deepcopy(obj)
deep_copied_obj.data[0] = 'Y'

print("Original Object Data after deepcopy:", obj.data)
print("Deep Copied Object Data:", deep_copied_obj.data)

输出：

Original Object Data after deepcopy: ['X', 2, 3]
Deep Copied Object Data: ['Y', 2, 3]

总结与建议

通过上述案例和分析，我们可以总结出：

简单赋值 和 浅拷贝 并不相同，前者只创建了一个新的引用，后者则创建了一个新的顶层对象。
浅拷贝 会导致嵌套可变对象共享引用，可能会带来意料之外的副作用。
深拷贝 是避免共享引用问题的方式，但由于深拷贝的递归性，它可能会导致性能开销。

实践中的建议：

根据需求选择赋值方式：在性能敏感的场景中，浅拷贝可能是更合适的选择，但要小心潜在的副作用。
定期检查数据结构：如果使用复杂的嵌套数据结构，应该经常通过 id() 等工具检查对象之间的引用关系。
多做实践练习：编码过程中，深入理解这些概念可以帮助更好地编写高效的代码。

练习题

为巩固您的理解，请尝试以下练习：

练习一：验证元组在浅拷贝和深拷贝中的行为

import copy

# 定义一个包含元组的列表
original_list = [(1, 2, 3), (4, 5, 6)]

# 浅拷贝
shallow_copied_list = copy.copy(original_list)

# 深拷贝
deep_copied_list = copy.deepcopy(original_list)

# 尝试修改拷贝中的元组
# 元组是不可变的，直接修改会报错
try:
    shallow_copied_list[0][0] = 'A'
except TypeError as e:
    print(f"Error when modifying shallow copy: {e}")

try:
    deep_copied_list[0][0] = 'B'
except TypeError as e:
    print(f"Error when modifying deep copy: {e}")

# 修改整个元组对象
shallow_copied_list[0] = ('A', 2, 3)
deep_copied_list[0] = ('B', 2, 3)

print("Original List:", original_list)
print("Shallow Copied List:", shallow_copied_list)
print("Deep Copied List:", deep_copied_list)

分析：

元组是不可变对象，浅拷贝和深拷贝对元组本身并没有差异。
直接修改元组的元素会引发 TypeError。
但是可以通过重新赋值替换整个元组对象，浅拷贝和深拷贝都是独立的。

练习二：观察嵌套数据结构的拷贝行为

import copy

# 创建嵌套字典和列表的复杂结构
original_structure = {
    'a': [1, 2, {'x': 10, 'y': [100, 200]}],
    'b': [3, 4]
}

# 浅拷贝
shallow_copied_structure = copy.copy(original_structure)

# 深拷贝
deep_copied_structure = copy.deepcopy(original_structure)

# 修改浅拷贝中的嵌套列表和字典
shallow_copied_structure['a'][2]['x'] = 'Modified'

# 修改深拷贝中的嵌套列表和字典
deep_copied_structure['a'][2]['y'][0] = 'Deep Modified'

print("Original Structure:", original_structure)
print("Shallow Copied Structure:", shallow_copied_structure)
print("Deep Copied Structure:", deep_copied_structure)

分析：

浅拷贝只复制了顶层数据结构，嵌套结构依然共享引用。
修改浅拷贝中的嵌套结构会影响原始结构。
深拷贝则完全复制了整个数据结构，修改深拷贝不会影响原始结构。

练习三：自定义类的浅拷贝与深拷贝

import copy

# 定义一个包含可变和不可变属性的类
class MyClass:
    def __init__(self, immutable, mutable):
        self.immutable = immutable  # 不可变类型
        self.mutable = mutable      # 可变类型

# 创建一个对象
obj = MyClass(immutable=(1, 2, 3), mutable=[4, 5, 6])

# 浅拷贝
shallow_copied_obj = copy.copy(obj)

# 深拷贝
deep_copied_obj = copy.deepcopy(obj)

# 修改可变属性
shallow_copied_obj.mutable[0] = 'Modified'
deep_copied_obj.mutable[0] = 'Deep Modified'

# 修改不可变属性（重新赋值）
shallow_copied_obj.immutable = ('A', 2, 3)
deep_copied_obj.immutable = ('B', 2, 3)

print("Original Object Mutable:", obj.mutable)
print("Shallow Copied Object Mutable:", shallow_copied_obj.mutable)
print("Deep Copied Object Mutable:", deep_copied_obj.mutable)

print("Original Object Immutable:", obj.immutable)
print("Shallow Copied Object Immutable:", shallow_copied_obj.immutable)
print("Deep Copied Object Immutable:", deep_copied_obj.immutable)

分析：

在浅拷贝中，可变属性（列表）仍然与原对象共享引用，修改会影响原对象。
不可变属性（元组）只能通过重新赋值来修改，浅拷贝和深拷贝对此是独立的。
深拷贝完全复制了对象，修改任何属性都不会影响原始对象。

这三道练习帮助您巩固浅拷贝与深拷贝在不同数据类型中的行为。通过修改嵌套结构和自定义类，您可以观察拷贝方式的实际效果。

结语

理解浅拷贝和深拷贝在 Python 中的行为对于编写健壮、高效的代码至关重要。希望本文的案例解析和实践建议能帮助您在实际工作中避免常见的陷阱，提高代码质量。

欢迎在评论区分享您的见解和疑问，共同探讨 Python 编程中的更多精彩话题！

原文地址：https://blog.csdn.net/Narutolxy/article/details/142361987

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：文件操作详解
下一篇：集群聊天服务器项目【C++】（五）网络模块和业务模块

基于微信小程序的宠物寄养平台的设计与实现+ssm(lw+演示+源码+运行）
Key words:目录摘要1Abstract2第1章绪论11.1选题背景11.2选题目的11.3选题意义2第2章系统分析32.1使用关键技术分析32.1.1Java语言介绍32.1.2Mysq
阅读更多2024-09-23
软件测试分类篇（下）
软件测试分类方式
阅读更多2024-09-23
AI开发-三方库
AI开发-三方库
阅读更多2024-09-23
计算机毕业设计基于SpringBoot的小区运动中心预约管理系统的设计与实现 Java实战项目附源码+文档+视频讲解
本项目是一个小区运动中心预约管理系统，基于SpringBoot框架，提供在线预约场馆、教练和器材服务，优化资源管理，增强用户体验。系统包含交流论坛、通知公告等功能，促进社区互动，支持管理者决策，旨在提
阅读更多2024-09-23
【超详细】基于YOLOv8训练无人机视角Visdrone2019数据集
VisDrone数据集是由天津大学等团队开源的一个大型无人机视角的数据集，官方提供的数据中训练集是6471、验证集是548、测试集1610张。数据集共提供了以下12个类，分别是：‘忽略区域’, ‘pe
阅读更多2024-09-23
【测试】——JUnit
JUnit 是一个流行的 Java 测试框架，主要用于编写和运行单元测试，用来管理测试用例。本文采用JUnit 5
阅读更多2024-09-23
浅谈C#之SynchronizationContext
是一个抽象类，它提供了一种机制，允许代码与创建它的线程同步。这在UI编程中非常有用，比如在Windows Forms或WPF应用程序中，你可能需要确保某些操作在UI线程上执行，以避免跨线程操作导致的问
阅读更多2024-09-23
[mongodb][备份]MongoDBBak.bat
备份清理：脚本已经包含了删除旧文件的功能，但请确保备份策略符合您的数据保留需求。权限问题：确保运行脚本的用户有足够的权限访问MongoDB实例和指定的目录。错误处理：脚本中没有错误处理机制，可能需要添
阅读更多2024-09-23
sql语法学习
SQL 是管理和操作关系型数据库的关键工具，掌握 SQL 基本语法和查询技巧可以高效地与数据库交互。通过学习创建、查询、更新、删除数据，以及如何执行复杂查询和事务操作，你可以有效地管理数据库中的数据。
阅读更多2024-09-23
提升动态数据查询效率：应对数据库成为性能瓶颈的优化方案
索引优化：通过正确设计和使用索引来提高查询性能。缓存机制：引入缓存系统，减少数据库查询压力。分库分表：对大表进行拆分，减轻单库和单表的负载。SQL 优化：通过分析和优化 SQL 查询，减少查询时间。数
阅读更多2024-09-23

深入理解 Python 中的浅拷贝与深拷贝：案例解析与潜在陷阱20240919