深拷贝和浅拷贝

最新推荐文章于 2021-12-08 23:16:42 发布
最新推荐文章于 2021-12-08 23:16:42 发布
阅读量168 收藏
点赞数 1
分类专栏： python 文章标签： 深拷贝 浅拷贝
alenzhang
本文链接：https://blog.csdn.net/qq_44401643/article/details/96440057
版权

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
alenzzzhang
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python3浅拷贝与深拷贝的区别和理解
10-19 349
首先，我们知道Python3中，有6个标准的数据类型，他们又分为可变和不可变。 不可变数据（3个）： Number（数字） String（字符串） Tuple（元组） 可变数据（3个）： List（列表） Dictionary（字典） Set（集合） 浅拷贝和深度拷贝 总结 浅拷贝 copy模块里面的copy方法实现 1、对于不可变类型 Number String Tuple,浅复制仅仅是地址指向，不会开辟新空间。但是如果改变了值就会创建新地址 2、对于可变类型 List、Dictio
Python3学习笔记之浅拷贝与深拷贝
chenf1999的博客
07-28 2765
Python3中的直接赋值、浅拷贝、深拷贝 参考链接：这里写链接内容 Python3中的直接赋值、浅拷贝、深拷贝 直接赋值 浅拷贝 深拷贝 实例代码 直接赋值 直接赋值就相当于对象的引用，例如a = b，就是把a指向b指向的那个对象，这个对象发生变化时，a和b对应的值都会发生变化 解析： 浅拷贝 当使用copy()函数时就是进行了浅拷贝，它拷贝...
python3之深拷贝与浅拷贝
Quincy.Coder的博客
10-17 620
浅拷贝 a=[1,2,3] b=a 下图表示浅拷贝： 该种情况属于浅拷贝，浅拷贝只拷贝引用，不拷贝内容。深拷贝（利用copy模块）copy.copy()copy会根据数据类型为可变还是不可变进行判断：如果是不可变类型，和浅拷贝相同；如果是可变类型，只是拷贝第一层。copy.deepcopy()deepcopy会把内容进行递归拷贝，当然也包括引用都会全部拷贝。 深拷贝会把内容
python列表复制的差异_python3之深浅copy对比
weixin_39915668的博客
12-22 291
一、赋值对比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 124
Python3之浅拷贝和深拷贝 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写作体验； 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高
JavaScript深拷贝和浅拷贝概念与用法实例分析
01-19
js中的浅拷贝和深拷贝，只是针对复杂数据类型(Objcet，Array)的复制问题。简单来讲浅拷贝和深拷贝都可以实现在原有对象的基础上再生成一份的作用。但是根据新生成的对象能否影响到原对象可以分为浅拷贝和深拷贝。 ...
Python中的深拷贝和浅拷贝详解
12-25
变量-引用-对象(可变对象，不可变对象)-切片-拷贝(浅拷贝，深拷贝) 【变量-对象-引用】 在Python中一切都是对象，比如说:3, 3.14, ‘Hello’, [1,2,3,4],{‘a’:1}…… 甚至连type其本身都是对象，type对象 Python...
Python 深拷贝和浅拷贝详解
03-09
对于不可变类型（如整数、字符串、元组），浅拷贝和深拷贝没有实质区别，因为这些类型不可变，所以拷贝后的新对象和原对象是等价的，但不一定是同一对象（即`is`操作符可能返回`False`）。 总之，深拷贝和浅拷贝的...
Java Clone深拷贝与浅拷贝的两种实现方法
08-26
Java Clone 深拷贝与浅拷贝的两种实现方法 Java Clone 是 Java 语言中的一种复制对象的机制，它可以将一个对象的所有属性和状态复制到另一个对象中，实现对象的深拷贝和浅拷贝。下面我们将讨论 Java 中的深拷贝和浅...
Python3入门之——浅拷贝和深拷贝
肥叔菌的博客
09-09 5722
由于Python使用了对象引用，因此在使用赋值操作符(=)时，并没有进行赋值操作。如果右边的操作数是字面值，比如字符串或数字，那么左边的操作数被设置为一个对象引用，该对象引用将指向存放字面值的内存对象。如果右边的操作数是一个对象引用，那么左边的操作数将设置为一个对象引用，并与右边的操作数指向相同的对象。 浅拷贝 如果需要组合类型数据（或其他可变对象）的一个单独副本。对于序列，在提取数据片时，数据片总是取自某个数据项的一个单独副本。 对于字典与集合而言，这种复制操作可以使用dict.copy()与set
Python3的深拷贝与浅拷贝
yhhuang17的博客
12-08 3461
1. 可变类型与不可变类型 在理解深拷贝和前拷贝之前，首先要了解python的可变类型和不可变类型： 可变类型：list、dict 不可变类型：number、str、bool、tuple python中的不可变数据类型，不允许变量的值 原地 发生变化，一但值发生了变化，则相当于新建了一个对象，id会变。 所以，可变类型：值变化，id不变化；不可变类型：值变化，id变化。 2. 指向 当 变量 = xx 时，认为该变量指向了xx的内存空间 >>> a = [11, 22] >&
Python3 之深拷贝和浅拷贝
qq_26948143的博客
03-06 384
讲一下变量赋值过程: 对于 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 353
我的原书链接：点击传送 3.6.3. 浅拷贝 与 深拷贝 理解 (浅层复制 与 深层复制 理解) 浅拷贝 shallow copy 深拷贝 deep copy 总结： 浅拷贝: 是指在复制过程中，只复制一层变量绑定关系，不会复制深层变量绑定的对象的复制过程 深拷贝: 对所有可变对象进行层层复制,实现对象的各自独立。 3.6.3.1. 语法及使用方法： 基本语法： import copy #...
python3的深拷贝与浅拷贝
qq_37876289的博客
09-08 119
temp = [1,2] op.append(temp[:])为传值拷贝 op.append(temp)类似于C的指针，temp后面改变的话，op的内容也会随着改变
Python3 深拷贝浅拷贝
AsynSpace的博客
12-25 423
感觉对深拷贝浅拷贝有一点混淆。特地写了几行，方便自己查看一下他们的区别  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 182
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 213
拷贝简介 浅拷贝:引用不同内存地址,仅仅值相同 深拷贝:引用同一个内存地址,且值相同。 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" %
java深拷贝和浅拷贝区别
最新发布
08-23
在Java中，深拷贝和浅拷贝是指创建新对象时对原始对象数据结构的不同复制方式。 **浅拷贝**： - 当我们通过复制构造函数、`clone()`方法或者数组赋值等方式创建一个新的对象时，默认的是浅拷贝。 - 浅拷贝会逐个复制引用类型的成员变量，如对象、数组等。新的对象和原对象共享这些引用，所以修改其中一个对象会影响另一个。 - 对于基本类型，浅拷贝是真正的副本。 **深拷贝**： - 深拷贝会递归地创建新对象，并对所有成员变量（包括引用类型和基本类型）都进行完整的复制。 - 如果对象中有其他对象或数组，这些都会被独立地复制一次，形成完全隔离的对象树。 - 使用序列化和反序列化，或者第三方库如`java.beans.BeanUtils.copyProperties()`也是实现深拷贝的方式之一。 总结来说，浅拷贝只复制了引用层级的第一层，而深拷贝则完整复制了整个数据结构，使得对象之间彼此独立。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值