图解Python深拷贝和浅拷贝

最新推荐文章于 2025-06-26 17:03:01 发布
转载 最新推荐文章于 2025-06-26 17:03:01 发布 · 364 阅读 · 0

参见连接：http://www.cnblogs.com/wilber2013/p/4645353.html

总结：

  • Python中对象的赋值都是进行对象引用（内存地址）传递
  • 使用copy.copy()，可以进行对象的浅拷贝，它复制了对象，但对于对象中的元素，依然使用原始的引用.
  • 如果需要复制一个容器对象，以及它里面的所有元素（包含元素的子元素），可以使用copy.deepcopy()进行深拷贝
  • 对于非容器类型（如数字、字符串、和其他'原子'类型的对象）没有被拷贝一说
  • 如果元祖变量只包含原子类型对象，则不能深拷贝，看下面的例子

Python教程：一文了解Python的深拷贝与浅拷贝
旦莫的博客
04-12 3443
理解 Python 中的深拷贝（deep copy）和浅拷贝（shallow copy）是非常重要的，特别是在处理嵌套结构的数据时。让我们深入探讨这两个概念，并通过代码示例进行说明。
【Python浅拷贝与深拷贝详解】
赶紧的博客
04-14 1115
本文通过10+个典型场景对比，深入解析Python中浅拷贝与深拷贝的核心差异，并提供可落地的工程实践方案。
Python深拷贝与浅拷贝：一文彻底搞懂
weixin_45729710的博客
06-26 1107
Python中的拷贝分为浅拷贝（Shallow Copy）和深拷贝（Deep Copy）。浅拷贝仅复制对象的顶层结构，嵌套对象仍与原对象共享引用，内存开销较小，适用于性能敏感场景。深拷贝则递归复制整个对象树，生成完全独立的副本，内存消耗较大但能彻底隔离数据。 关键区别： 浅拷贝（copy.copy()/切片）共享嵌套对象，修改会影响原对象； 深拷贝（copy.deepcopy()）完全独立，适合需要隔离数据的场景； 不可变对象（如字符串）在拷贝中行为特殊，修改时会创建新对象。 实际应用时需权衡内存开销与数据
深度解读Python深拷贝与浅拷贝问题
Python中文社区
02-23 2011
 Illustrations by Leon Tukker♚作者：PayneLi，Python全家桶，主要讲述数据挖掘、机器学习和深度学习领域的前沿技术，同时还会推荐一些...
【Python】python深拷贝与浅拷贝详解（必须掌握）
热门推荐
测试开发自动化
02-27 1万+
（关注“测试开发自动化” 弓中皓，获取更多学习内容）
python深复制与浅复制_python深拷贝与浅拷贝
weixin_39789094的博客
12-02 145
之前关于 Python 的作用域、赋值、参数传递，我们接连谈了几篇文章：今天我们依然要就相关话题继续下去。首先是上次最后的思考题：m = [1, 2, [3]]n = m[:]n[1] = 4n[2][0] = 5print(m)m 的结果是什么？正确答案是 [1, 2, [5]] ，这次比上次好点，有 35% 的正确率。当时我留了个提示，说和浅拷贝、深拷贝有关，现在我们就来具体说一说。假设有这样...
图解：python中的浅拷贝和深拷贝
12-21
在Python编程语言中，了解如何正确处理对象的拷贝至关重要，特别是浅拷贝和深拷贝的概念。浅拷贝和深拷贝主要涉及到列表、元组等可变对象的复制，以及这些对象内部包含的不可变和可变对象的情况。 浅拷贝（Shallow ...
搞定面试之图解Python深拷贝浅拷贝
吾非同
12-22 263
搞定面试之图解Python深拷贝浅拷贝首先了解一些基本概念「在Python中一切皆对象」，任何对象都有三个属性：唯一标识、类型、值。例如一个字符串：lst="hellopyt...
图解Python中深浅copy（通俗易懂）
09-16
对于只包含不可变对象（如整数、字符串、元组）的列表，浅拷贝和深拷贝没有区别，因为这些对象不能被修改。然而，如果列表中包含可变对象，深拷贝能确保拷贝后的列表是独立且不相关的。 在实际编程中，选择哪种拷贝...
python中的浅拷贝与深拷贝（与c++的对比）
s_m_c的博客
02-05 356
最近在系统的学习python的过程中的发现好多博客所写的python中的浅拷贝和深拷贝的区别都是错误的（都理解成了c++中的浅拷贝和深拷贝），在此记录。
Python 拷贝对象（深拷贝deepcopy与浅拷贝copy）
12-24
1. copy.copy 浅拷贝 只拷贝父对象，不会拷贝对象的内部的子对象。2. copy.deepcopy 深拷贝 拷贝对象及其子对象一个很好的例子： import copya = [1, 2, 3, 4, [‘a’, ‘b’]]  #原始对象b = a  #赋值，传对象的引用c = copy.copy(a)  #对象拷贝，浅拷贝d = copy.deepcopy(a)  #对象拷贝，深拷贝a.append(5)  #修改对象aa[4].append(‘c’)  #修改对象a中的[‘a’, ‘b’]数组对象print ‘a = ‘, aprint ‘b = ‘, bprint ‘c = ‘,
python 深复制和浅复制
很长很长的专栏
08-03 397
>>> l1 = [1,[2,3],(4,5)] >>> l2 = list(l1) >>> l1.append(99) >>> l1 [1, [2, 3], (4, 5), 99] >>> l2 [1, [2, 3], (4, 5)] >>> l1[1].remove(2) >>> l1 [1, [3], (4, 5), 99] >>> l2 [1, [3], (4, 5)] >>> l2[1]
Python的深复制和浅复制
GoProLin的博客
06-24 414
在Python编程中，理解对象的复制是至关重要的。Python提供了两种主要的复制方法：浅复制（shallow copy）和深复制（deep copy）。这两种方法在处理可变对象时有着显著的区别。下面我们简单看一下两者的使用。千夫指是指创建一个新对象，这个新对象是原对象的一部分或者全部的副本，但对于原对象中嵌套的对象（比如列表中的列表），浅复制仅仅复制它们的引用，也就是说浅复制不会递归复制所有的子对象。深复制则是创建一个新对象，并递归地复制所有子对象。
python深复制与浅复制
喜欢就要珍惜，珍惜就别放弃
03-16 683
在python中尽量不要使用全局变量更不能随便修改全局变量的值，也不能随便修改可变数 据类型的值， 否则会引发不易发现的异常，在进行变量复制时要分清是浅复制还是深复制，变量名内存放的是地址， 把一个变量内的地址赋值给另一个变量是浅复制，把一个变量的内容赋值给另一个变量则为深复制， 如：ll=[1,2,3]      l2=l1(浅复制，l1内容改变则l2也会随之改变)     l3=l
python中深复制与浅复制
一只懒虫的博客
04-25 370
先看一下官方文档给的区别及注意（python3.6）：The difference between shallow and deep copying is only relevant for compound objects (objects that contain other objects, like lists or class instances): A shallow copy con...
python 深复制 浅复制
weixin_43206271的博客
02-03 337
python 深复制 浅复制
python的深拷贝和浅拷贝
树新风的博客
07-15 957
深拷贝与浅拷贝的区别：深拷贝是递归拷贝，而浅拷贝只为最外层数据开辟新的内存的空间(如果数据内部还有引用 浅拷贝不会开辟新的内存空间)。 其中深拷贝与浅拷贝对于不可变类型数据都是直接引用。 import copy a = [1,2,3] b = [4,5,6] c = [a,b] d = copy.copy(c) a[0] = 10 print(d) d = copy.deepcopy(c)...
✅什么是深拷贝和浅拷贝？
最新发布
07-31
<think>我们正在讨论深拷贝和浅拷贝的概念及其区别。根据引用内容，我们可以总结如下： 1. 深拷贝和浅拷贝主要针对引用数据类型（如对象、数组等），因为基本数据类型在赋值时是直接复制值，修改新变量不会影响原变量。 2. 浅拷贝（Shallow Copy）： - 只复制对象的第一层属性。 - 如果属性是基本类型，则复制其值；如果是引用类型，则复制其内存地址（即指针），因此新旧对象共享同一块内存。 - 修改新对象的引用类型属性会影响到原对象，因为两者指向同一个内存地址。 - 可能引发内存重复释放等问题（例如在C++等语言中）。 3. 深拷贝（Deep Copy）： - 递归复制对象的所有层级，直到所有属性都是基本类型为止。 - 为新对象创建新的内存空间，新旧对象完全独立，互不影响。 - 修改新对象的任何属性都不会影响原对象。 - 实现上比浅拷贝复杂，但更安全。 区别总结： | 特性 | 浅拷贝 | 深拷贝 | |--------------|------------------------------------------|------------------------------------------| | 复制层级 | 仅第一层 | 所有层级（递归复制） | | 引用类型复制 | 复制地址（共享内存） | 创建新内存（独立） | | 修改影响 | 新对象修改引用类型属性会影响原对象 | 新对象修改属性不会影响原对象 | | 实现复杂度 | 简单 | 复杂 | | 内存占用 | 较少（共享部分内存） | 较多（完全独立内存） | | 安全性 | 较低（可能内存共享问题） | 较高 | 实现深拷贝的方法（以JavaScript为例）： 1. 使用JSON序列化和反序列化（但有局限性，如不能复制函数、循环引用会报错等）： ```javascript let newObj = JSON.parse(JSON.stringify(oldObj)); ``` 2. 递归实现： ```javascript function deepClone(obj) { if (obj === null || typeof obj !== 'object') { return obj; } let clone = Array.isArray(obj) ? [] : {}; for (let key in obj) { if (obj.hasOwnProperty(key)) { clone[key] = deepClone(obj[key]); } } return clone; } ``` 3. 使用第三方库（如lodash的`_.cloneDeep`）： ```javascript let newObj = _.cloneDeep(oldObj); ``` 注意事项： - 浅拷贝方法：`Object.assign()`、扩展运算符`...`、数组的`slice()`和`concat()`等。 - 深拷贝需要考虑循环引用、函数、特殊对象（如Date、RegExp）等复杂情况。 在编程中，选择深拷贝还是浅拷贝取决于需求。如果对象结构简单且不需要独立修改，浅拷贝即可；如果对象嵌套复杂且需要完全独立，则使用深拷贝。 相关问题： 1. 在JavaScript中，如何实现一个支持循环引用的深拷贝函数？ 2. 深拷贝和浅拷贝在性能上有什么差异？如何选择？ 3. 在Java语言中，深拷贝和浅拷贝如何实现？ 4. JSON序列化实现深拷贝有哪些局限性？ 5. 如何避免深拷贝过程中出现栈溢出问题？</think>### 深拷贝与浅拷贝的概念解析 #### 一、基本定义 1. **浅拷贝 (Shallow Copy)** - 仅复制对象的**第一层属性值**（包括基本类型值和引用地址） - 当属性为引用类型时，复制的是**内存地址指针**而非实际数据 - 新旧对象**共享**引用类型属性的内存空间[^1][^3] ```javascript // JavaScript浅拷贝示例 const original = { a: 1, b: { c: 2 } }; const shallowCopy = { ...original }; // 扩展运算符实现浅拷贝 shallowCopy.b.c = 99; // 修改会影响原对象 console.log(original.b.c); // 输出99 ``` 2. **深拷贝 (Deep Copy)** - 递归复制对象的**所有层级属性** - 为所有引用类型属性**创建新的内存空间** - 新旧对象**完全独立**，互不影响[^1][^3][^4] ```javascript // JavaScript深拷贝示例（通过JSON方式） const original = { a: 1, b: { c: 2 } }; const deepCopy = JSON.parse(JSON.stringify(original)); deepCopy.b.c = 99; // 修改不影响原对象 console.log(original.b.c); // 输出2 ``` #### 二、核心区别对比 | **特性** | 浅拷贝 | 深拷贝 | |------------------|-------------------------------|-------------------------------| | **复制深度** | 仅第一层属性 | 递归所有层级 | | **引用类型处理** | 复制指针（共享内存） | 创建新内存（独立数据） | | **内存占用** | 较低 | 较高 | | **修改影响** | 影响原对象[^2][^4] | 不影响原对象[^1][^3] | | **实现复杂度** | 简单（Object.assign等） | 复杂（需递归/序列化） | | **适用场景** | 简单对象、无嵌套引用 | 复杂嵌套对象、需完全隔离 | #### 三、内存模型图解 ``` 浅拷贝内存模型： 原始对象 ───┬───> 基本类型值 └───> 引用类型地址 ───> [共享内存块] 拷贝对象 ───┘ 深拷贝内存模型： 原始对象 ───> 基本类型值 └──> 引用类型地址 ───> [独立内存块A] 拷贝对象 ───> 复制的基本类型值 └──> 新引用地址 ─────> [独立内存块B]（内容与A相同） ``` #### 四、关键应用场景 1. **必须使用深拷贝的情况**： - 需要完全隔离的配置对象 - 包含状态的历史记录保存 - 跨线程/进程数据传输（如Web Worker） - 避免循环引用导致的无限递归[^3] 2. **浅拷贝的适用场景**： - 简单数据传输（无嵌套引用） - 高性能要求的临时对象复制 - 不可变对象（如String, Number等包装类） #### 五、深拷贝实现方案 1. **JSON序列化法**（简易但有限制）： ```javascript function simpleDeepClone(obj) { return JSON.parse(JSON.stringify(obj)); } // 限制：无法复制函数、undefined、循环引用 ``` 2. **递归克隆法**（通用实现）： ```javascript function deepClone(obj, map = new WeakMap()) { if (obj === null || typeof obj !== 'object') return obj; if (map.has(obj)) return map.get(obj); // 解决循环引用 const clone = Array.isArray(obj) ? [] : {}; map.set(obj, clone); for (let key in obj) { if (obj.hasOwnProperty(key)) { clone[key] = deepClone(obj[key], map); } } return clone; } ``` 3. **特殊对象处理**（补充方案）： ```javascript // 处理Date/RegExp等内置对象 if (obj instanceof Date) return new Date(obj); if (obj instanceof RegExp) return new RegExp(obj); ``` > **本质区别**： > 浅拷贝如同复印名片——复印件和原件指向同一个电话号码（共享资源）；深拷贝如同新建电话号码——双方完全独立通信[^2][^4]。选择取决于是否需要真正的数据隔离。 --- ### 相关问题 1. 如何处理深拷贝过程中的循环引用问题？ 2. JSON序列化实现深拷贝有哪些局限性？如何解决？ 3. 在Java/Python等语言中如何实现深拷贝？ 4. 深拷贝和浅拷贝在内存管理上有哪些性能差异？ 5. 如何为包含函数的对象实现深拷贝？
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值