深拷贝和浅拷贝

最新推荐文章于 2024-09-16 21:40:59 发布
最新推荐文章于 2024-09-16 21:40:59 发布
阅读量224 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： python 文章标签： 深拷贝 浅拷贝
alenzhang
本文链接：https://blog.youkuaiyun.com/qq_44401643/article/details/96440057
本文深入探讨了Python中拷贝的概念，包括六种基本数据类型的浅拷贝与深拷贝的区别，以及不同拷贝方式对可变类型和不可变类型的影响，并介绍了除copy模块外的其他拷贝方法。

1. 铺垫知识：

Python3中，有6个标准的数据类型，他们又分为可变和不可变。

1.1 不可变数据（3个）：

  • Number（数字）
  • String（字符串）
  • Tuple（元组）

1.2可变数据（3个）：

  • List（列表）
  • Dictionary（字典）
  • Set（集合）

2. 浅拷贝和深度拷贝

2.1浅拷贝

2.1.1 copy模块里面的copy方法实现
  1. 对于不可变类型 Number、String、Tuple,浅复制仅仅是地址指向，不会开辟新空间。
  2. 列表项对于可变类型List、Dictionary、Set，浅复制会开辟新的空间地址(仅仅是最顶层开辟了新的空间，里层的元素地址还是一样的)，进行浅拷贝
  3. 浅拷贝后，改变原始对象中为可变类型的元素的值，会同时影响拷贝对象的；改变原始对象中为不可变类型的元素的值，只有原始类型受影响。（操作拷贝对象对原始对象的也是同理）

2.2 深拷贝

2.2.1 copy模块里面的deepcopy方法实现
  1. 深拷贝，除了顶层拷贝，还对子元素也进行了拷贝（本质上递归浅拷贝）
  2. 经过深拷贝后，原始对象和拷贝对象所有的元素地址都没有相同的了
  3. 可以用切片表达式进行浅拷贝
  4. 字典的copy方法可以拷贝一个字典
  5. 深拷贝内部子元素如果是不可变类型，但内部子元素的子元素存在可变类型，则按照可变类型的递归浅拷贝对子元素进行拷贝

3. 可变类型和不可变类型在浅拷贝中的区别

3.1 不可变类型 Number String Tuple

对于不可 变类型 Number String Tuple,浅复制仅仅是地址指向，不会开辟新空间拷贝值

import copy
num1 = 17
num2 = copy.copy(num1)

print("num1:" + str(id(num1)))
print("num2:" + str(id(num1)))
# num1和num2的地址都相同


str1 = "hello"
str2 = copy.copy(str1)
print("str1:" + str(id(str1)))
print("str2:" + str(id(str2)))
# str1和str2的地址都相同

tup1 = (18, "tom")
tup2 = copy.copy(tup1)
print("tup1:" + str(id(tup1)))
print("tup2:" + str(id(tup2)))
# tup1和tup2的地址都相同

print("="*20)

3.2 可变类型 List、Dictionary、Set

对于可变类型 List、Dictionary、Set，浅复制会开辟新的空间地址(仅仅是最顶层开辟了新的空间)，进行浅拷贝

list1 = [11,12]
list2 = copy.copy(list1)
print("list1:" + str(id(list1)))
print("list2:" + str(id(list2)))
# list1和list2的地址不相同


dic1 = [11,12,"hi"]
dic2 = copy.copy(dic1)
print("dic1:" + str(id(dic1)))
print("dic2:" + str(id(dic2)))
# dic1和dic2的地址不相同

set1 = {"AA","BB"}
set2 = copy.copy(set1)
print("set1:" + str(id(set1)))
print("set2:" + str(id(set2)))
# set1和set2的地址不相同

3.3 对于不可变类型被修改后造成的影响，我们用一个更加简单的例子便可更好理解：

num = 123
print(str(id(num)))

num = 666
print(str(id(num)))

console：

4348603632
4350009296

4. 深拷贝对6种基本类型的影响

我们对3种可变类型3种不可变类型进行深拷贝。
结果发现，和浅拷贝几乎一致。
其实这也好理解，因为深拷贝对比浅拷贝，强调的是递归，强调的是子元素。
对顶层的操作，深浅拷贝无异。

4.1 不可变类型 Number String Tuple

对于不可 变类型 Number String Tuple,深复制依然是地址指向，不会开辟新空间拷贝值

import copy
num1 = 17
num2 = copy.deepcopy(num1) # 深拷贝

print("num1:" + str(id(num1)))
print("num2:" + str(id(num1)))
# num1和num2的地址都相同


str1 = "hello"
str2 = copy.deepcopy(str1)  # 深拷贝
print("str1:" + str(id(str1)))
print("str2:" + str(id(str2)))
# str1和str2的地址都相同

tup1 = (18, "tom")
tup2 = copy.deepcopy(tup1) # 深拷贝
print("tup1:" + str(id(tup1)))
print("tup2:" + str(id(tup2)))
# tup1和tup2的地址都相同

print("="*20)

4.2可变类型 List、Dictionary、Set

对于可变类型 List、Dictionary、Set，深拷贝会开辟新的空间地址，进行拷贝


list1 = [11,12]
list2 = copy.deepcopy(list1) # 深拷贝
print("list1:" + str(id(list1)))
print("list2:" + str(id(list2)))
# list1和list2的地址不相同


dic1 = [11,12,"hi"]
dic2 = copy.deepcopy(dic1) # 深拷贝
print("dic1:" + str(id(dic1)))
print("dic2:" + str(id(dic2)))
# dic1和dic2的地址不相同

set1 = {"AA","BB"}
set2 = copy.deepcopy(set1) # 深拷贝
print("set1:" + str(id(set1)))
print("set2:" + str(id(set2)))
# set1和set2的地址不相同

4.3浅拷贝的会对子元素也进行拷贝

import copy

l1 = [11, 12]
l2 = [21, 22]
num = 555

allOne = [l1, l2,num]


# 深拷贝，除了顶层拷贝，还对子元素也进行了拷贝（本质上递归浅拷贝）
# 经过深拷贝后，原始对象和拷贝对象所有的元素地址都没有相同的了

allOne2 = copy.deepcopy(allOne) # copy.deepcopy 深拷贝

allOne[1] = [113,114]
allOne2[2] = [227,228]

print(allOne)
print(allOne2)

print("id allOne:"+str(id(allOne)))
print("id allOne[0]:"+str(id(allOne[0])))
print("id allOne[1]:"+str(id(allOne[1])))
print("id allOne[2]:"+str(id(allOne[2])))

print("===")
print("id allOne2:"+str(id(allOne2)))
print("id allOne2[0]:"+str(id(allOne2[0])))
print("id allOne2[1]:"+str(id(allOne2[1])))
print("id allOne2[2]:"+str(id(allOne2[2])))

console

[[11, 12], [113, 114], 555]
[[11, 12], [21, 22], [227, 228]]
id allOne:4549589640
id allOne[0]:4554067720
id allOne[1]:4554067848
id allOne[2]:4548329424
===
id allOne2:4554067912
id allOne2[0]:4554067784
id allOne2[1]:4554067592
id allOne2[2]:4554100808

本例是跟浅拷贝做对比的。
在之前的浅拷贝中，子元素是不会开辟新空间做拷贝的。
而在深拷贝中，子元素也进行了拷贝。

5. 其他拷贝方式

除了copy模块的中的copy和deepcopy，还有其他自带的方式可实现拷贝。

  1. 分片表达式进行浅拷贝
  2. 字典的copy方法可以拷贝一个字典

5.1 分片表达式拷贝

l1 = [11, 12]
l2 = [21, 22]
num = 555
orgi = [l1, l2, num]
nList = orgi[:]
print("orgi:"+str(id(orgi)))
print("orgi[0]:"+str(id(orgi[0])))
print("orgi[1]:"+str(id(orgi[1])))
print("orgi[2]:"+str(id(orgi[2])))
print("*"*30)
print("nList:"+str(id(nList)))
print("nList[0]:"+str(id(nList[0])))
print("nList[1]:"+str(id(nList[1])))
print("nList[2]:"+str(id(nList[2])))

用分片表达式进行的拷贝，是浅拷贝。

5.2 字典自带的copy方法可实现深拷贝

dic = {"key": "hello", "num": 18}

dic2 = dic.copy()

dic["key"] = "one"
dic2["key"] = "two"

print(dic)
print("dic:" + str(id(dic)))

print(dic2)
print("dic2:" + str(id(dic2)))

console:
{'key': 'one', 'num': 18}
dic:4382946792
{'key': 'two', 'num': 18}
dic2:4382946864
python3浅拷贝与深拷贝的区别和理解
10-19 412
首先，我们知道Python3中，有6个标准的数据类型，他们又分为可变和不可变。 不可变数据（3个）： Number（数字） String（字符串） Tuple（元组） 可变数据（3个）： List（列表） Dictionary（字典） Set（集合） 浅拷贝和深度拷贝 总结 浅拷贝 copy模块里面的copy方法实现 1、对于不可变类型 Number String Tuple,浅复制仅仅是地址指向，不会开辟新空间。但是如果改变了值就会创建新地址 2、对于可变类型 List、Dictio
Python3学习笔记之浅拷贝与深拷贝
chenf1999的博客
07-28 2814
Python3中的直接赋值、浅拷贝、深拷贝 参考链接：这里写链接内容 Python3中的直接赋值、浅拷贝、深拷贝 直接赋值 浅拷贝 深拷贝 实例代码 直接赋值 直接赋值就相当于对象的引用，例如a = b，就是把a指向b指向的那个对象，这个对象发生变化时，a和b对应的值都会发生变化 解析： 浅拷贝 当使用copy()函数时就是进行了浅拷贝，它拷贝...
python3之深拷贝与浅拷贝
Quincy.Coder的博客
10-17 661
浅拷贝 a=[1,2,3] b=a 下图表示浅拷贝： 该种情况属于浅拷贝，浅拷贝只拷贝引用，不拷贝内容。深拷贝（利用copy模块）copy.copy()copy会根据数据类型为可变还是不可变进行判断：如果是不可变类型，和浅拷贝相同；如果是可变类型，只是拷贝第一层。copy.deepcopy()deepcopy会把内容进行递归拷贝，当然也包括引用都会全部拷贝。 深拷贝会把内容
python列表复制的差异_python3之深浅copy对比
weixin_39915668的博客
12-22 342
一、赋值对比1、列表l1=[1,2,3]l2=l1l1.append('a')print(l1,l2)#[1,2,3,'a'][1,2,3,'a']print(id(l1),id(l2))#4349984843499848#可以看到两个列表的值以及id值相同，对应的是同一个内存地址2、字典dic={'name':'bar...
Python3之浅拷贝和深拷贝
piyiyao4484的博客
06-30 166
Python3之浅拷贝和深拷贝 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写作体验； 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高
JavaScript深拷贝和浅拷贝概念与用法实例分析
01-19
js中的浅拷贝和深拷贝，只是针对复杂数据类型(Objcet，Array)的复制问题。简单来讲浅拷贝和深拷贝都可以实现在原有对象的基础上再生成一份的作用。但是根据新生成的对象能否影响到原对象可以分为浅拷贝和深拷贝。 ...
java，深拷贝和浅拷贝
水w的博客
09-16 1344
深拷贝和浅拷贝
Python中的深拷贝和浅拷贝详解
12-25
变量-引用-对象(可变对象，不可变对象)-切片-拷贝(浅拷贝，深拷贝) 【变量-对象-引用】 在Python中一切都是对象，比如说:3, 3.14, ‘Hello’, [1,2,3,4],{‘a’:1}…… 甚至连type其本身都是对象，type对象 Python...
Python 深拷贝和浅拷贝详解
03-09
对于不可变类型（如整数、字符串、元组），浅拷贝和深拷贝没有实质区别，因为这些类型不可变，所以拷贝后的新对象和原对象是等价的，但不一定是同一对象（即`is`操作符可能返回`False`）。 总之，深拷贝和浅拷贝的...
Python3入门之——浅拷贝和深拷贝
肥叔菌的博客
09-09 5759
由于Python使用了对象引用，因此在使用赋值操作符(=)时，并没有进行赋值操作。如果右边的操作数是字面值，比如字符串或数字，那么左边的操作数被设置为一个对象引用，该对象引用将指向存放字面值的内存对象。如果右边的操作数是一个对象引用，那么左边的操作数将设置为一个对象引用，并与右边的操作数指向相同的对象。 浅拷贝 如果需要组合类型数据（或其他可变对象）的一个单独副本。对于序列，在提取数据片时，数据片总是取自某个数据项的一个单独副本。 对于字典与集合而言，这种复制操作可以使用dict.copy()与set
Python3的深拷贝与浅拷贝
yhhuang17的博客
12-08 3545
1. 可变类型与不可变类型 在理解深拷贝和前拷贝之前，首先要了解python的可变类型和不可变类型： 可变类型：list、dict 不可变类型：number、str、bool、tuple python中的不可变数据类型，不允许变量的值 原地 发生变化，一但值发生了变化，则相当于新建了一个对象，id会变。 所以，可变类型：值变化，id不变化；不可变类型：值变化，id变化。 2. 指向 当 变量 = xx 时，认为该变量指向了xx的内存空间 >>> a = [11, 22] >&
Python3 之深拷贝和浅拷贝
qq_26948143的博客
03-06 432
讲一下变量赋值过程: 对于 x = [1,2,3,4] 首先把1，2，3，4这四个对象在内存中依次创建出来，1,2,3,4这都是字值 对于变量x其实就好像c语言中的指针一样，变量实际上是不存储数据的 他只是绑定数据，所以在python文档中成为bound 我们把列表的赋值实际上就是实现列表与数据的绑定我们在del(x)时并不是删除处列表 而是删除的变量x 此时此时列表与变量x没有的绑定关系，...
Python3中的浅拷贝和深拷贝 【详细解读】
NO FATE
02-23 460
我的原书链接：点击传送 3.6.3. 浅拷贝 与 深拷贝 理解 (浅层复制 与 深层复制 理解) 浅拷贝 shallow copy 深拷贝 deep copy 总结： 浅拷贝: 是指在复制过程中，只复制一层变量绑定关系，不会复制深层变量绑定的对象的复制过程 深拷贝: 对所有可变对象进行层层复制,实现对象的各自独立。 3.6.3.1. 语法及使用方法： 基本语法： import copy #...
python3的深拷贝与浅拷贝
qq_37876289的博客
09-08 159
temp = [1,2] op.append(temp[:])为传值拷贝 op.append(temp)类似于C的指针，temp后面改变的话，op的内容也会随着改变
Python3 深拷贝浅拷贝
AsynSpace的博客
12-25 478
感觉对深拷贝浅拷贝有一点混淆。特地写了几行，方便自己查看一下他们的区别  import copy if __name__ == "__main__": str = "\nn={0}\taddr:{4}\na={1}\taddr:{5}\nb={2}\taddr:{6}\nc={3}\taddr:{7}\n" # 基数 n = [100,101,[200,201]] ...
python3中的浅拷贝与深拷贝
qq_26972735的博客
05-05 226
import copy def f(x): return x a = [["a", "b"],1,2,3, "d"] b = copy.copy(a) c = copy.deepcopy(a) d = a.copy() e = f(a) a[0].append("c") a[1] = 0 a[-1] = a[-1].upper() print(a) #...
Python3 深拷贝与浅拷贝总结
zhouzhiwengang的专栏
08-13 247
拷贝简介 浅拷贝:引用不同内存地址,仅仅值相同 深拷贝:引用同一个内存地址,且值相同。 eg: # 深拷贝:引用同一个内存地址,且值相同。 宿主值发生改变,不会影响拷贝者的值 a = 10 b = copy.copy(a) print("a 内存地址: %d" % id(a)) print("b 内存地址: %d" % id(b)) a = 100 print("a 值为： %d" % a) print("b 值为： %d" %
深拷贝和浅拷贝cpp
最新发布
05-10
<think>嗯，用户想了解C++中的深拷贝和浅拷贝的区别以及实现方法。首先，我需要回忆一下这两个概念的基本定义。浅拷贝应该是指简单的复制指针，导致两个对象指向同一块内存，而深拷贝则是复制指针所指向的数据本身，这样两个对象就独立了。 根据用户提供的引用内容，引用[1]里提到浅拷贝只拷贝指针，深拷贝会拷贝内容，默认的拷贝构造函数是浅拷贝，需要自己实现深拷贝。引用[2]和[3]给出了具体的代码示例，展示了如何通过自定义拷贝构造函数来实现深拷贝，比如在Person类中为Name或m_height重新分配内存并复制数据。引用[4]中的Array类也演示了类似的深拷贝实现，即在拷贝构造函数中新建内存空间并复制数据。 接下来，我需要将这些信息组织成一个清晰的回答。首先解释两者的区别，用比喻的话，浅拷贝像快捷方式，深拷贝像复制文件，这样用户容易理解。然后，说明默认拷贝构造函数的问题，比如会导致重复释放内存，出现错误。接着，用用户提供的代码例子来说明如何手动实现深拷贝，比如在拷贝构造函数中分配新内存，并复制数据。可能还需要提到析构函数的重要性，确保深拷贝的对象能正确释放内存。 用户可能还关心什么时候需要深拷贝，应该是在类中有指针成员指向动态分配的内存时。这时候必须自己实现深拷贝，否则会出现问题。同时，需要注意在实现深拷贝时，除了拷贝构造函数，可能还需要重载赋值运算符，但用户的问题可能没有提到，所以可能暂时不需要展开，但如果有相关问题可以提到。 最后，生成的相关问题需要围绕实现深拷贝的方法、常见错误场景以及如何避免等问题。这样用户如果有进一步的问题，可以继续查阅相关内容。确保回答中正确引用提供的资料，比如引用[1]、[3]中的例子来说明浅拷贝的问题和深拷贝的实现步骤。</think>### C++深拷贝与浅拷贝的区别及实现方式 #### 一、核心概念 1. **浅拷贝** - 仅复制对象的指针成员变量，拷贝后新旧对象的指针**指向同一块内存地址**，例如： ```cpp //示例代码片段 m_height = p.m_height; //浅拷贝直接复制指针[^3] ``` - 类似文件快捷方式，多个指针共享同一资源，可能导致**重复释放内存**的崩溃问题[^1] 2. **深拷贝** - 为指针成员**创建独立的内存空间**，完全复制原对象的数据内容： ```cpp m_height = new int(*p.m_height); //新建堆空间并复制数据[^3] ``` - 类似完整文件复制，新旧对象完全独立，避免资源冲突[^1] #### 二、实现方式对比 | 特征 | 浅拷贝 | 深拷贝 | |--------------|---------------------------|---------------------------| | 内存分配 | 共享原对象内存 | 新建独立内存空间 | | 实现复杂度 | 编译器默认提供 | 需手动实现拷贝构造函数 | | 资源管理风险 | 易出现重复释放 | 内存管理安全 | | 典型应用场景 | 无指针成员的简单对象 | 包含指针/动态资源的对象 | #### 三、关键实现步骤（以类`person`为例） 1. **定义深拷贝构造函数** ```cpp person(const person& p) { m_age = p.m_age; m_height = new int(*p.m_height); //关键：新建堆内存并复制数据 } ``` 2. **配套析构函数** ```cpp ~person() { delete m_height; //确保正确释放深拷贝分配的内存 m_height = nullptr; } ``` 3. **错误示例（浅拷贝陷阱）** 若直接使用默认拷贝构造函数： ```cpp person p2(p1); //此时p2.m_height与p1.m_height指向同一地址 ``` 析构时会导致**重复释放同一内存地址**，引发程序崩溃[^1] #### 四、应用场景分析 - **必须使用深拷贝**：类包含指针成员且指向动态分配内存时（如字符串、数组等） - **可使用浅拷贝**：仅包含基本数据类型或没有资源所有权的指针时 - **典型案例**：自定义容器类（如动态数组`Array`类[^4]）、包含文件句柄的类
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值