Python浅拷贝copy()与深拷贝deepcopy()区别
其实呢,浅拷贝copy()与深拷贝deepcopy()之间的区分必须要涉及到python对于数据的存储方式。
首先直接上结论:
—–我们寻常意义的复制就是深复制,即将被复制对象完全再复制一遍作为独立的新个体单独存在。所以改变原有被复制对象不会对已经复制出来的新对象产生影响。
—–而浅复制并不会产生一个独立的对象单独存在,他只是将原有的数据块打上一个新标签,所以当其中一个标签被改变的时候,数据块就会发生变化,另一个标签也会随之改变。这就和我们寻常意义上的复制有所不同了。对于简单的 object,用 shallow copy 和 deep copy 没区别
复杂的 object, 如 list 中套着 list 的情况,shallow copy 中的 子list,并未从原 object 真的「独立」出来。也就是说,如果你改变原 object 的子 list 中的一个元素,你的 copy 就会跟着一起变。这跟我们直觉上对「复制」的理解不同。
看不懂文字没关系我们来看代码:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | >>> import copy >>> origin = [ 1 , 2 , [ 3 , 4 ]] #origin 里边有三个元素:1, 2,[3, 4] >>> cop1 = copy.copy(origin) >>> cop2 = copy.deepcopy(origin) >>> cop1 = = cop2 True >>> cop1 is cop2 False #cop1 和 cop2 看上去相同,但已不再是同一个object >>> origin[ 2 ][ 0 ] = "hey!" >>> origin [ 1 , 2 , [ 'hey!' , 4 ]] >>> cop1 [ 1 , 2 , [ 'hey!' , 4 ]] >>> cop2 [ 1 , 2 , [ 3 , 4 ]] #把origin内的子list [3, 4] 改掉了一个元素,观察 cop1 和 cop2 |
可以看到 cop1,也就是 shallow copy 跟着 origin 改变了。而 cop2 ,也就是 deep copy 并没有变。
似乎 deep copy 更加符合我们对「复制」的直觉定义: 一旦复制出来了,就应该是独立的了。如果我们想要的是一个字面意义的「copy」,那就直接用 deep_copy 即可。
那么为什么会有 shallow copy 这样的「假」 copy 存在呢? 这就是有意思的地方了。
先看一个例子
对于数字和字符串来说,深拷贝和浅拷贝内纯地址都相同
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | #!/usr/bin/python3 import copy #浅拷贝copy #深拷贝deepcopy a = 1233456 a1 = 1233456 a2 = a print ( id (a)) print ( id (a1)) print ( id (a2)) print ( "-----------" ) a3 = copy.copy(a) print ( id (a3)) |
执行结果:
1 2 3 4 5 | 31100688 31100688 31100688 - - - - - - - - - - - 31100688 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | #!/usr/bin/python3 import copy #浅拷贝copy #深拷贝deepcopy a = 1233456 a1 = 1233456 a2 = a print ( id (a)) print ( id (a1)) print ( id (a2)) print ( "-----deepcopy------" ) a3 = copy.deepcopy(a) print ( id (a3)) |
执行结果:
1 2 3 4 5 | 31035152 31035152 31035152 - - - - - deepcopy - - - - - - 31035152 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | #!/usr/bin/python3 import copy #浅拷贝copy #深拷贝deepcopy a = "QQ603374730" a1 = "QQ603374730" a2 = a print ( id (a)) print ( id (a1)) print ( id (a2)) print ( "-----deepcopy------" ) a3 = copy.deepcopy(a) print ( id (a3)) |
执行结果:
1 2 3 4 5 | 41768368 41768368 41768368 - - - - - deepcopy - - - - - - 41768368 |
对于 数字 和 字符串 而言,赋值、浅拷贝和深拷贝无意义,因为其永远指向同一个内存地址。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | import copy # ######### 数字、字符串 ######### n1 = 123 # n1 = "i am alex age 10" print ( id (n1)) # ## 赋值 ## n2 = n1 print ( id (n2)) # ## 浅拷贝 ## n2 = copy.copy(n1) print ( id (n2)) # ## 深拷贝 ## n3 = copy.deepcopy(n1) print ( id (n3)) |
对于字典、元祖、列表 而言,进行赋值、浅拷贝和深拷贝时,其内存地址的变化是不同的。
赋值,只是创建一个变量,该变量指向原来内存地址,如:
1 2 3 4 5 | n1 = { "k1" : "wu" , "k2" : 123 , "k3" : [ "alex" , 456 ]} n2 = n1 print ( id (n1)) print ( id (n2)) |
执行结果:
1 2 | 31222520 31222520 |
浅拷贝,在内存中只额外创建第一层数据
1 2 3 4 5 6 7 8 9 | import copy n1 = { "k1" : "wu" , "k2" : 123 , "k3" : [ "alex" , 456 ]} n3 = copy.copy(n1) print ( id (n1)) print ( id (n3)) print ( id (n1[ "k3" ])) print ( id (n3[ "k3" ])) |
1 2 3 4 | 34827000 34827072 42225224 42225224 |
深拷贝,在内存中将所有的数据重新创建一份(排除最后一层,即:python内部对字符串和数字的优化)
1 2 3 4 5 6 7 8 9 | import copy n1 = { "k1" : "wu" , "k2" : 123 , "k3" : [ "alex" , 456 ]} n4 = copy.deepcopy(n1) print ( id (n1)) print ( id (n4)) print ( id (n1[ "k3" ])) print ( id (n4[ "k3" ])) |
执行结果:
1 2 3 4 | 31222520 41688304 41963080 41962504 |
python的数据存储方式
变量的方法跟其他 OOP 语言不同。它与其说是把值赋给变量,不如说是给变量建立了一个到具体值的 reference。
当在 Python 中 a = something 应该理解为给 something 贴上了一个标签 a。当再赋值给 a 的时候,就好象把 a 这个标签从原来的 something 上拿下来,贴到其他对象上,建立新的 reference。 这就解释了一些 Python 中可能遇到的诡异情况:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | >> a = [ 1 , 2 , 3 ] >>> b = a >>> a = [ 4 , 5 , 6 ] / / 赋新的值给 a >>> a [ 4 , 5 , 6 ] >>> b [ 1 , 2 , 3 ] # a 的值改变后,b 并没有随着 a 变 >>> a = [ 1 , 2 , 3 ] >>> b = a >>> a[ 0 ], a[ 1 ], a[ 2 ] = 4 , 5 , 6 / / 改变原来 list 中的元素 >>> a [ 4 , 5 , 6 ] >>> b [ 4 , 5 , 6 ] # a 的值改变后,b 随着 a 变了 |
上面两段代码中,a 的值都发生了变化。区别在于,第一段代码中是直接赋给了 a 新的值(从 [1, 2, 3] 变为 [4, 5, 6]);而第二段则是把 list 中每个元素分别改变。
而对 b 的影响则是不同的,一个没有让 b 的值发生改变,另一个变了。怎么用上边的道理来解释这个诡异的不同呢?
首次把 [1, 2, 3] 看成一个物品。a = [1, 2, 3] 就相当于给这个物品上贴上 a 这个标签。而 b = a 就是给这个物品又贴上了一个 b 的标签。
第一种情况:
a = [4, 5, 6] 就相当于把 a 标签从 [1 ,2, 3] 上撕下来,贴到了 [4, 5, 6] 上。
在这个过程中,[1, 2, 3] 这个物品并没有消失。 b 自始至终都好好的贴在 [1, 2, 3] 上,既然这个 reference 也没有改变过。 b 的值自然不变。
第二种情况:
a[0], a[1], a[2] = 4, 5, 6 则是直接改变了 [1, 2, 3] 这个物品本身。把它内部的每一部分都重新改装了一下。内部改装完毕后,[1, 2, 3] 本身变成了 [4, 5, 6]。
而在此过程当中,a 和 b 都没有动,他们还贴在那个物品上。因此自然 a b 的值都变成了 [4, 5, 6]。
搞明白这个之后就要问了,对于一个复杂对象的浅copy,在copy的时候到底发生了什么?
再看一段代码:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | >>> import copy >>> origin = [ 1 , 2 , [ 3 , 4 ]] #origin 里边有三个元素:1, 2,[3, 4] >>> cop1 = copy.copy(origin) >>> cop2 = copy.deepcopy(origin) >>> cop1 = = cop2 True >>> cop1 is cop2 False #cop1 和 cop2 看上去相同,但已不再是同一个object >>> origin[ 2 ][ 0 ] = "hey!" >>> origin [ 1 , 2 , [ 'hey!' , 4 ]] >>> cop1 [ 1 , 2 , [ 'hey!' , 4 ]] >>> cop2 [ 1 , 2 , [ 3 , 4 ]] #把origin内的子list [3, 4] 改掉了一个元素,观察 cop1 和 cop2 |
学过Docker的人应该对镜像这个概念不陌生,我们可以把镜像的概念套用在copy上面。
概念图如下:
copy对于一个复杂对象的子对象并不会完全复制,什么是复杂对象的子对象呢?就比如序列里的嵌套序列,字典里的嵌套序列等都是复杂对象的子对象。对于子对象,python会把它当作一个公共镜像存储起来,所有对他的复制都被当成一个引用,所以说当其中一个引用将镜像改变了之后另一个引用使用镜像的时候镜像已经被改变了。
所以说看这里的origin[2],也就是 [3, 4] 这个 list。根据 shallow copy 的定义,在 cop1[2] 指向的是同一个 list [3, 4]。那么,如果这里我们改变了这个 list,就会导致 origin 和 cop1 同时改变。这就是为什么上边 origin[2][0] = “hey!” 之后,cop1 也随之变成了 [1, 2, [‘hey!’, 4]]。
而deepcopy概念图如下:
deepcopy的时候会将复杂对象的每一层复制一个单独的个体出来。
这时候的 origin[2] 和 cop2[2] 虽然值都等于 [3, 4],但已经不是同一个 list了。即我们寻常意义上的复制。
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】凌霞软件回馈社区,博客园 & 1Panel & Halo 联合会员上线
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】博客园社区专享云产品让利特惠,阿里云新客6.5折上折
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步