前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >​深度解析Python的赋值、浅拷贝、深拷贝

​深度解析Python的赋值、浅拷贝、深拷贝

作者头像
ZackSock
发布2021-04-13 15:11:43
2980
发布2021-04-13 15:11:43
举报
文章被收录于专栏:ZackSockZackSock

简述

  • 直接赋值: 其实就是对象的引用(别名)。
  • 浅拷贝(copy): 拷贝父对象,不会拷贝对象的内部的子对象。
  • 深拷贝(deepcopy): copy 模块的 deepcopy 方法,完全拷贝了父对象及其子对象。

拷贝 就是把原数据复制一份,在复制的数据上随意改动不会影响到其原数据。也就是这里讲的深拷贝。

直接赋值

代码语言:javascript
复制

In [1]: a = [11, 22, 33]

In [2]: b = a

In [3]: b
Out[3]: [11, 22, 33]

In [4]: id(a), id(b)
Out[4]: (2053851155016, 2053851155016)

In [5]: c = {"name": "hui"}

In [6]: d = c

In [7]: id(c), id(d)
Out[7]: (2053851035112, 2053851035112)

    
In [8]: a.append(44)

In [9]: a
Out[9]: [11, 22, 33, 44]

In [10]: b
Out[10]: [11, 22, 33, 44]

In [11]: c["age"] = 21

In [12]: c
Out[12]: {'name': 'hui', 'age': 21}

In [13]: d
Out[13]: {'name': 'hui', 'age': 21}

可以看到当给一个变量直接赋值时,其实就是将对象引用复制了一份,所以 id() 取得内存地址都一样,它们指向的都是同一个对象。画张图就好理解。

直接赋值

浅拷贝

利用内置模块 copy 实现浅拷贝

代码语言:javascript
复制
In [12]: a = [1, 2]

In [13]: b = [3, 4]

In [14]: c = [a, b]

In [15]: d = c

In [16]: id(c),          id(d)
Out[16]: (1409068540040, 1409068540040)

In [17]: import copy

In [18]: e = c.copy()

In [19]: id(c),          id(d),         id(e)
Out[19]: (1409068540040, 1409068540040, 1409070776520) 
# 浅拷贝copy的对象id()不一样

In [20]: id(c[0]), id(c[1])
Out[20]: (1409071493512, 1409071679112)

In [21]: id(e[0]), id(e[1])
Out[21]: (1409071493512, 1409071679112)
# 其子对象则一样

In [22]: a.append(5)

In [23]: b.append(6)

In [24]: c
Out[24]: [[1, 2, 5], [3, 4, 6]]

In [25]: d
Out[25]: [[1, 2, 5], [3, 4, 6]]

In [26]: e
Out[26]: [[1, 2, 5], [3, 4, 6]]
# 内容一致
    
In [28]: c.append(7)

In [29]: c
Out[29]: [[1, 2, 5], [3, 4, 6], 7]

In [30]: e
Out[30]: [[1, 2, 5], [3, 4, 6]]

可以看出直接赋值 cd 是同一对象,而浅拷贝 copyce 是一个分别独立的对象,但他们的子对象 a , b 还是 指向统一对象即引用

因此当 c.append(7) 后,只有 c 对象改变了,而浅拷贝的 e 还是没有变化。

a.append(5), b.append(6) 后,c, d, e 对象依然内容一致。

直接赋值与浅拷贝对比

深拷贝

通过 copy.deepcopy() 来实现深拷贝

代码语言:javascript
复制
In [33]: a = [1, 2]

In [34]: b = [3, 4]

In [35]: c = [a, b]

In [36]: d = copy.deepcopy(c)

In [37]: id(c), id(d)
Out[37]: (1409071919752, 1409071607112)

In [38]: id(c[0]), id(c[1])
Out[38]: (1409071948680, 1409071766216)

In [39]: id(d[0]), id(d[1])
Out[39]: (1409071976328, 1409071919880)
# 完全拷贝了,其子对象的id()都不一样

In [40]: c.append(5)

In [41]: c
Out[41]: [[1, 2], [3, 4], 5]

In [42]: d
Out[42]: [[1, 2], [3, 4]]

In [43]: a.append(3)

In [44]: b.append(5)

In [45]: c
Out[45]: [[1, 2, 3], [3, 4, 5], 5]

In [46]: d
Out[46]: [[1, 2], [3, 4]]
# 因此任c怎么修改,都影响不到d

In [47]: d[0].append(5)

In [48]: d[1].append(6)

In [49]: d
Out[49]: [[1, 2, 5], [3, 4, 6]]

In [50]: d.append(7)

In [51]: d
Out[51]: [[1, 2, 5], [3, 4, 6], 7]

In [52]: c
Out[52]: [[1, 2, 3], [3, 4, 5], 5]
# d怎么修改也影响不到c

深度拷贝, 完全拷贝了父对象及其子对象,两者是完全独立的。因此 c,d 做任何操作都互不影响。

深拷贝

三者对比

  • d = c 赋值引用,cd 都指向同一个对象
  • e = c.copy() 浅拷贝,ce 是一个 独立的对象,但他们的 子对象还是指向统一对象即引用
  • f = copy.deepcopy(c) 深度拷贝,cf 完全拷贝了父对象及其子对象,两者是完全独立的

深浅拷贝理解图1

拷贝对可变类型和不可变类型的区别

  • copy.copy() 对于可变类型,会进行浅拷贝。
  • copy.copy() 对于不可变类型,不会拷贝,仅仅是指向。
  • copy.deepcopy() 深拷贝对可变、不可变类型都一样递归拷贝所有,对象完全独立
  • 所谓的不可变指的是所指向的内存中的内容不可变。

浅拷贝测试

代码语言:javascript
复制
In [54]: # 可变类型list

In [55]: a = [1, 2, 3]

In [56]: b = copy.copy(a)

In [57]: id(a)
Out[57]: 1409069563528

In [58]: id(b)
Out[58]: 1409071719752

In [59]: a.append(4)

In [60]: a
Out[60]: [1, 2, 3, 4]

In [61]: b
Out[61]: [1, 2, 3]

In [63]: # 不可变类型 tuple

In [64]: c = (1, 2, 3)

In [65]: d = copy.copy(c)

In [66]: id(c)
Out[66]: 1409070834456

In [67]: id(d)
Out[67]: 1409070834456

当浅拷贝 copy() 不可变类型元组时 tuplec, d的内存地址都一样,说明仅是指向。

深拷贝测试

代码语言:javascript
复制
In [71]: a = ([1, 2], [3, 4])

In [72]: b = copy.copy(a)

In [73]: c = copy.deepcopy(a)

In [74]: id(a)
Out[74]: 1409068519944

In [75]: id(b)
Out[75]: 1409068519944
# 浅拷贝不可变类型id()一致

In [76]: id(c)
Out[76]: 1409071533448
# 深拷贝不可变类型id()不一致

In [77]: b[0].append(3)

In [78]: b[1].append(5)

In [79]: a
Out[79]: ([1, 2, 3], [3, 4, 5])

In [80]: b
Out[80]: ([1, 2, 3], [3, 4, 5])

In [81]: c
Out[81]: ([1, 2], [3, 4])
# 浅拷贝的子对象引用一致

In [82]: c[0].append(3)

In [83]: c
Out[83]: ([1, 2, 3], [3, 4])

In [84]: b
Out[84]: ([1, 2, 3], [3, 4, 5])

In [85]: a
Out[85]: ([1, 2, 3], [3, 4, 5])
# 深拷贝则是完全拷贝,互不影响

copy.deepcopy() 深拷贝对可变、不可变类型都一样递归拷贝所有,对象完全独立。

深浅拷贝理解图2

公众号

新建文件夹X

大自然用数百亿年创造出我们现实世界,而程序员用几百年创造出一个完全不同的虚拟世界。我们用键盘敲出一砖一瓦,用大脑构建一切。人们把1000视为权威,我们反其道行之,捍卫1024的地位。我们不是键盘侠,我们只是平凡世界中不凡的缔造者 。

本文参与 腾讯云自媒体分享计划,分享自微信公众号。
原始发表:2021-03-31,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 新建文件夹X 微信公众号,前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体分享计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • 简述
  • 直接赋值
  • 浅拷贝
  • 深拷贝
  • 三者对比
  • 拷贝对可变类型和不可变类型的区别
    • 浅拷贝测试
      • 深拷贝测试
      • 公众号
      领券
      问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档