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

简介: 直接赋值: 其实就是指向对象的引用(别名)。浅拷贝(copy):拷贝父对象,不会拷贝对象的内部的子对象。但对于不可变数据类型,不会拷贝,仅仅是指向深拷贝(deepcopy):`copy` 模块的 `deepcopy` 方法,完全拷贝了父对象及其子对象。拷贝 就是把原数据复制一份,在复制的数据上随意改动不会影响到其原数据。也就是这里讲的深拷贝。

简述

  • 直接赋值: 其实就是指向对象的引用(别名)。
  • 浅拷贝(copy): 拷贝父对象,不会拷贝对象的内部的子对象。但对于不可变数据类型,不会拷贝,仅仅是指向
  • 深拷贝(deepcopy): copy 模块的 deepcopy 方法,完全拷贝了父对象及其子对象。

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

<br/>

直接赋值


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() 取得内存地址都一样,它们指向的都是同一个对象。画张图就好理解。

直接赋值

<br/>

浅拷贝

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

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 = copy.copy(c)

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 对象依然内容一致。

直接赋值与浅拷贝对比

<br/>

深拷贝

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

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 做任何操作都互不影响。

深拷贝

<br/>

三者对比

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

深浅拷贝理解图1

<br/>

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

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

<br/>

所谓的不可变指的是所指向的内存中的内容不可变。

同一份内存地址,其内容发生了改变,但地址依旧不变。说明是可变数据类型例如 list, set, dict

数据类型 是否可变
整型 不可变
字符串 str 不可变
元组 tuple 不可变
列表 list 可变
集合 set 可变
字典 dict 可变

<br/>

不可变数据类型测试

In [15]: a = 5
​
In [16]: id(a)
Out[16]: 140712197127360
​
In [17]: a = 6
​
In [18]: id(a)
Out[18]: 140712197127392
    

首先 a=5,地址为 140712197127360,当我让 a=6 把里面值改变时,它并不是说把 a地址 里面值从 5 改成 6, 而是说又开辟了一块新的内存地址140712197127392 里面存储 6,然后让 a 指向 6 的那份内存地址。所以称 a 这种数据类型为不可变数据类型

可变数据类型更改图示

可变数据类型测试

In [31]: li = [1, 2, 3]
​
In [32]: id(li)
Out[32]: 2365035049224
​
In [33]: li[0] = 5
​
In [34]: li
Out[34]: [5, 2, 3]
​
In [35]: id(li)
Out[35]: 2365035049224

li 首先存储了 [1, 2, 3], 后来变成了 [5, 2, 3],但 li 的地址依旧不变,因此称 li 这种数据类型为 可变数据类型

<br/>

浅拷贝测试

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的内存地址都一样,说明仅是指向。

<br/>

深拷贝测试

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

<br/>

公众号

新建文件夹X

大自然用数百亿年创造出我们现实世界,而程序员用几百年创造出一个完全不同的虚拟世界。我们用键盘敲出一砖一瓦,用大脑构建一切。人们把1000视为权威,我们反其道行之,捍卫1024的地位。我们不是键盘侠,我们只是平凡世界中不凡的缔造者 。
相关文章
|
22天前
|
存储 安全 测试技术
Python面试题精选及解析
本文详解Python面试中的六大道经典问题,涵盖列表与元组区别、深浅拷贝、`__new__`与`__init__`、GIL影响、协程原理及可变与不可变类型,助你提升逻辑思维与问题解决能力,全面备战Python技术面试。
|
24天前
|
数据采集 数据挖掘 测试技术
Go与Python爬虫实战对比:从开发效率到性能瓶颈的深度解析
本文对比了Python与Go在爬虫开发中的特点。Python凭借Scrapy等框架在开发效率和易用性上占优,适合快速开发与中小型项目;而Go凭借高并发和高性能优势,适用于大规模、长期运行的爬虫服务。文章通过代码示例和性能测试,分析了两者在并发能力、错误处理、部署维护等方面的差异,并探讨了未来融合发展的趋势。
96 0
|
17天前
|
安全 JavaScript Java
Python中None与NoneType的真相:从单例对象到类型系统的深度解析
本文通过10个真实场景,深入解析Python中表示“空值”的None与NoneType。从单例模式、函数返回值,到类型注解、性能优化,全面揭示None在语言设计与实际编程中的核心作用,帮助开发者正确高效地处理“无值”状态,写出更健壮、清晰的Python代码。
100 3
|
1月前
|
数据采集 存储 Web App开发
Python爬虫库性能与选型实战指南:从需求到落地的全链路解析
本文深入解析Python爬虫库的性能与选型策略,涵盖需求分析、技术评估与实战案例,助你构建高效稳定的数据采集系统。
190 0
|
23天前
|
存储 程序员 数据处理
Python列表基础操作全解析:从创建到灵活应用
本文深入浅出地讲解了Python列表的各类操作,从创建、增删改查到遍历与性能优化,内容详实且贴近实战,适合初学者快速掌握这一核心数据结构。
104 0
|
23天前
|
存储 小程序 索引
Python变量与基础数据类型:整型、浮点型和字符串操作全解析
在Python编程中,变量和数据类型是构建程序的基础。本文介绍了三种基本数据类型:整型(int)、浮点型(float)和字符串(str),以及它们在变量中的使用方式和常见操作。通过理解变量的动态特性、数据类型的转换与运算规则,初学者可以更高效地编写清晰、简洁的Python代码,为后续学习打下坚实基础。
122 0
|
24天前
|
并行计算 算法 Java
Python3解释器深度解析与实战教程:从源码到性能优化的全路径探索
Python解释器不止CPython,还包括PyPy、MicroPython、GraalVM等,各具特色,适用于不同场景。本文深入解析Python解释器的工作原理、内存管理机制、GIL限制及其优化策略,并介绍性能调优工具链及未来发展方向,助力开发者提升Python应用性能。
95 0
|
1月前
|
存储 监控 安全
Python剪贴板监控实战:clipboard-monitor库的深度解析与扩展应用
本文介绍了基于Python的剪贴板监控技术,结合clipboard-monitor库实现高效、安全的数据追踪。内容涵盖技术选型、核心功能开发、性能优化及实战应用,适用于安全审计、自动化办公等场景,助力提升数据管理效率与安全性。
73 0
|
2月前
|
JSON 数据挖掘 API
闲鱼商品列表API响应数据python解析
闲鱼商品列表API(Goodfish.item_list)提供标准化数据接口,支持GET请求,返回商品标题、价格、图片、卖家信息等。适用于电商比价、数据分析,支持多语言调用,附Python示例代码,便于开发者快速集成。
|
2月前
|
JSON 自然语言处理 API
闲鱼商品详情API响应数据python解析
闲鱼商品详情API(goodfish.item_get)通过商品ID获取标题、价格、描述、图片等信息,支持Python等多语言调用。本文提供Python请求示例,包含请求构造与数据处理方法。

热门文章

最新文章

推荐镜像

更多