|
|
51CTO旗下网站
|
|
移动端

一文了解Python深拷贝与浅拷贝问题

在平时工作中,经常涉及到数据的传递,在数据传递使用过程中,可能会发生数据被修改的问题。为了防止数据被修改,就需要在传递一个副本,即使副本被修改,也不会影响原数据的使用。为了生成这个副本,就产生了拷贝。

作者:机器学习与数据挖掘来源:今日头条|2019-02-25 08:58

在平时工作中,经常涉及到数据的传递,在数据传递使用过程中,可能会发生数据被修改的问题。为了防止数据被修改,就需要在传递一个副本,即使副本被修改,也不会影响原数据的使用。为了生成这个副本,就产生了拷贝。今天就说一下Python中的深拷贝与浅拷贝的问题。

概念普及:对象、可变类型、引用

数据拷贝会涉及到Python中对象、可变类型、引用这3个概念,先来看看这几个概念,只有明白了他们才能更好的理解深拷贝与浅拷贝到底是怎么一回事。

Python对象

在Python中,对对象有一种很通俗的说法,万物皆对象。说的就是构造的任何数据类型都是一个对象,无论是数字,字符串,还是函数,甚至是模块,Python都对当做对象处理。

所有Python对象都拥有三个属性:身份、类型、值。

看一个简单的例子:

  1. In [1]: name = "laowang" # name对象 
  2. In [2]: id(name) # id:身份的唯一标识 
  3. Out[2]: 1698668550104 
  4. In [3]: type(name) # type:对象的类型,决定了该对象可以保存什么类型的值 
  5. Out[3]: str 
  6. In [4]: name # 对象的值,表示的数据 
  7. Out[4]: 'laowang' 

可变与不可变对象

在Python中,按更新对象的方式,可以将对象分为2大类:可变对象与不可变对象。

  • 可变对象: 列表、字典、集合
  • 所谓可变是指可变对象的值可变,身份是不变的。
  • 不可变对象:数字、字符串、元组
  • 不可变对象就是对象的身份和值都不可变。新创建的对象被关联到原来的变量名,旧对象被丢弃,垃圾回收器会在适当的时机回收这些对象。
  1. In [7]: var1 = "python" 
  2. In [8]: id(var1) 
  3. Out[8]: 1700782038408 
  4. #由于var1是不可变的,重新创建了java对象,随之id改变,旧对象python会在某个时刻被回收 
  5. In [9]: var1 = "java" 
  6. In [10]: id(var1)  
  7. Out[10]: 1700767578296 

引用

在 Python 程序中,每个对象都会在内存中申请开辟一块空间来保存该对象,该对象在内存中所在位置的地址被称为引用。在开发程序时,所定义的变量名实际就对象的地址引用。

引用实际就是内存中的一个数字地址编号,在使用对象时,只要知道这个对象的地址,就可以操作这个对象,但是因为这个数字地址不方便在开发时使用和记忆,所以使用变量名的形式来代替对象的数字地址。 在 Python 中,变量就是地址的一种表示形式,并不开辟开辟存储空间。

就像 IP 地址,在访问网站时,实际都是通过 IP 地址来确定主机,而 IP 地址不方便记忆,所以使用域名来代替 IP 地址,在使用域名访问网站时,域名被解析成 IP 地址来使用。

通过一个例子来说明变量和变量指向的引用就是一个东西。

  1. In [11]: age = 18 
  2. In [12]: id(age) 
  3. Out[12]: 1730306752 
  4. In [13]: id(18) 
  5. Out[13]: 1730306752 

逐步深入:引用赋值

上边已经明白,引用就是对象在内存中的数字地址编号,变量就是方便对引用的表示而出现的,变量指向的就是此引用。赋值的本质就是让多个变量同时引用同一个对象的地址。 那么在对数据修改时会发生什么问题呢?

  • 不可变对象的引用赋值。
  • 对不可变对象赋值,实际就是在内存中开辟一片空间指向新的对象,原不可变对象不会被修改。

原理图如下:

下面通过案例来理解一下:

a与b在内存中都是指向1的引用,所以a、b的引用是相同的。

  1. In [1]: a = 1 
  2. In [2]: b = a 
  3. In [3]: id(a) 
  4. Out[3]: 1730306496 
  5. In [4]: id(b) 
  6. Out[4]: 1730306496 

现在再给a重新赋值,看看会发生什么变化?

从下面不难看出:当给a 赋新的对象时,将指向现在的引用,不在指向旧的对象引用。

  1. In [1]: a = 1 
  2. In [2]: b = a 
  3. In [5]: a = 2 
  4. In [6]: id(a) 
  5. Out[6]: 1730306816 
  6. In [7]: id(b) 
  7. Out[7]: 1730306496 
  • 可变对象的引用赋值。
  • 可变对象保存的并不是真正的对象数据,而是对象的引用。当对可变对象进行赋值时,只是将可变对象中保存的引用指向了新的对象。

原理图如下:

仍然通过一个实例来体会一下,可变对象引用赋值的过程。

当改变l1时,整个列表的引用会指新的对象,但是l1与l2都是指向保存的同一个列表的引用,所以引用地址不会变。

  1. In [3]: l1 = [1, 2, 3] 
  2. In [4]: l2 = l1 
  3. In [5]: id(l1) 
  4. Out[5]: 1916633584008 
  5. In [6]: id(l2) 
  6. Out[6]: 1916633584008 
  7. In [7]: l1[0] = 11 
  8. In [8]: id(l1) 
  9. Out[8]: 1916633584008 
  10. In [9]: id(l2) 
  11. Out[9]: 1916633584008 

主旨详解:浅拷贝、深拷贝

经过前2部分的解读,大家对对象的引用赋值应该有了一个清晰的认识了。

下面大家思考一个这样的问题:Python中如何解决原始数据在函数传递之后不受影响了?

这个问题Python已经帮我们解决了,使用对象的拷贝或者深拷贝就可以愉快的解决了。

下面具体来看看Python中的浅拷贝与深拷贝是如何实现的。

  • 浅拷贝:

为了解决函数传递后被修改的问题,就需要拷贝一份副本,将副本传递给函数使用,就算是副本被修改,也不会影响原始数据 。

不可变对象的拷贝

不可变对象只在修改的时候才会在内存中开辟新的空间, 而拷贝实际上是让多个对象同时指向一个引用,和对象的赋值没区别。

同样的,通过一个实例来感受一下:不难看出,a与b指向相同的引用,不可变对象的拷贝就是对象赋值。

  1. In [11]: import copy 
  2. In [12]: a = 10 
  3. In [13]: b = copy.copy(a) 
  4. In [14]: id(a) 
  5. Out[14]: 1730306496 
  6. In [15]: id(b) 
  7. Out[15]: 1730306496 

可变对象的拷贝

对于不可变对象的拷贝,对象的引用并没有发生变化,那么可变对象的拷贝会不会和不可变对象一样了?我们接着往下看。

通过下面这个实例可以看出:可变对象的拷贝,会在内存中开辟一个新的空间来保存拷贝的数据。当再改变之前的对象时,对拷贝之后的对象没有任何影响。

  1. In [24]: import copy 
  2. In [25]: l1 = [1, 2, 3] 
  3. In [26]: l2 = copy.copy(l1) 
  4. In [27]: id(l1) 
  5. Out[27]: 1916631742088 
  6. In [28]: id(l2) 
  7. Out[28]: 1916636282952 
  8. In [29]: l1[0] = 11 
  9. In [30]: id(l1) 
  10. Out[30]: 1916631742088 
  11. In [31]: id(l2) 
  12. Out[31]: 1916636282952 

原理图如下:

现在再回到刚才那个问题,是不是浅拷贝就可以解决原始数据在函数传递之后不变的问题了?下面看一个稍微复杂一点的数据结构。

通过下面这个实例可以发现:复杂对象在拷贝时,并没有解决数据在传递之后,数据改变的问题。 出现这种原因,是copy() 函数在拷贝对象时,只是将指定对象中的所有引用拷贝了一份,如果这些引用当中包含了一个可变对象的话,那么数据还是会被改变。 这种拷贝方式,称为浅拷贝。

  1. In [35]: a = [1, 2] 
  2. In [36]: l1 = [3, 4, a] 
  3. In [37]: l2 = copy.copy(l1) 
  4. In [38]: id(l1) 
  5. Out[38]: 1916631704520 
  6. In [39]: id(l2) 
  7. Out[39]: 1916631713736 
  8. In [40]: a[0] = 11 
  9. In [41]: id(l1) 
  10. Out[41]: 1916631704520 
  11. In [42]: id(l2) 
  12. Out[42]: 1916631713736 
  13. In [43]: l1 
  14. Out[43]: [3, 4, [11, 2]] 
  15. In [44]: l2 
  16. Out[44]: [3, 4, [11, 2]] 

原理图如下:

对于上边这种状况,Python还提供了另一种拷贝方式(深拷贝)来解决。

  • 深拷贝

区别于浅拷贝只拷贝顶层引用,深拷贝会逐层进行拷贝,直到拷贝的所有引用都是不可变引用为止。

接下来我们看看,要是将上边的拷贝实例用使用深拷贝的话,原始数据改变的问题还会不会存在了?

下面的实例清楚的告诉我们:之前的问题就可以***解决了。

  1. import copy 
  2. l1 = [3, 4, a] 
  3. In [47]: l2 = copy.deepcopy(li) 
  4. In [48]: id(l1) 
  5. Out[48]: 1916632194312 
  6. In [49]: id(l2) 
  7. Out[49]: 1916634281416 
  8. In [50]: a[0] = 11 
  9. In [51]: id(l1) 
  10. Out[51]: 1916632194312 
  11. In [52]: id(l2) 
  12. Out[52]: 1916634281416 
  13. In [54]: l1 
  14. Out[54]: [3, 4, [11, 2]] 
  15. In [55]: l2 
  16. Out[55]: [1, 2, 3] 

原理图如下:

查漏补缺

为什么Python默认的拷贝方式是浅拷贝?

  • 时间角度:浅拷贝花费时间更少。
  • 空间角度:浅拷贝花费内存更少。
  • 效率角度:浅拷贝只拷贝顶层数据,一般情况下比深拷贝效率高。

本文知识点总结:

  • 不可变对象在赋值时会开辟新空间。
  • 可变对象在赋值时,修改一个的值,另一个也会发生改变。
  • 深、浅拷贝对不可变对象拷贝时,不开辟新空间,相当于赋值操作。
  • 浅拷贝在拷贝时,只拷贝***层中的引用,如果元素是可变对象,并且被修改,那么拷贝的对象也会发生变化。
  • 深拷贝在拷贝时,会逐层进行拷贝,直到所有的引用都是不可变对象为止。
  • Python 中有多种方式实现浅拷贝,copy模块的copy 函数 ,对象的 copy 函数 ,工厂方法,切片等。
  • 大多数情况下,编写程序时,都是使用浅拷贝,除非有特定的需求。
  • 浅拷贝的优点:拷贝速度快,占用空间少,拷贝效率高。

【编辑推荐】

  1. LeCun:Python当死,深度学习新语言当立
  2. 学会Python+Selenium,分分钟搭建Web自动化框架!
  3. Golang与Python,哪种编程语言更适合您?
  4. Python Web 部署方式大全
  5. 为什么Julia比Python快?因为天生理念就更先进啊
【责任编辑:武晓燕 TEL:(010)68476606】

点赞 0
分享:
大家都在看
猜你喜欢

订阅专栏+更多

这就是5G

这就是5G

5G那些事儿
共15章 | armmay

115人订阅学习

16招轻松掌握PPT技巧

16招轻松掌握PPT技巧

GET职场加薪技能
共16章 | 晒书包

371人订阅学习

20个局域网建设改造案例

20个局域网建设改造案例

网络搭建技巧
共20章 | 捷哥CCIE

758人订阅学习

读 书 +更多

网管员必读——网络组建(第2版)

《网管员必读——网络组建(第2版)》仍是以一个中等规模的模拟局域网组建为思路,较全面地介绍了与局域网组建相关的各方面知识和组建、配...

订阅51CTO邮刊

点击这里查看样刊

订阅51CTO邮刊

51CTO服务号

51CTO官微