比尔云BierYun--阿里云最新优惠活动
阿里云优惠码丨阿里云代金券

Python学习(21)–深拷贝与浅拷贝

Python学习(21)–深拷贝与浅拷贝http://www.bieryun.com/2366.html

这一节我们来介绍下Python中的深拷贝和浅拷贝,这一篇涉及到的是Python在内存中对数据的存储以及搬运的机制,了解这些机制为我们以后在编程中合理的规划数据和充分利用内存,提升程序性能都大有裨益。下面主要分为以下3个模块来介绍:

1.对象赋值

2.浅拷贝

3.深拷贝

(1)对象赋值

在介绍对象赋值之前,我们先来介绍下Python在内存中存储数据的机制。在Python中,基本数据类型相同的值只占有一份内存空间。体现在程序中就是如果多个变量的基本数据类型和值都相同,那么这些变量引用的存储空间的地址相同。如下代码可以证明:

 

[python] view plain copy

  1. a=4
  2. b=4
  3. c=4
  4. print(id(4))
  5. print(id(a))
  6. print(id(b))
  7. print(id(c))

 

如上,变量a,b,c的值都为4,打印4,a,b,c在内存空间中的地址,如下:

如上,打印出的地址都是相同的,这说明4在内存中占有的存储空间只有一份。从而证明,对于基本数据类型,相同的值在内存空间中只有一份。可以通过如下图简单明了的了解这一机制:

所谓对象赋值,即把一个对象赋值给另一个对象,就是赋值语句。下面我们通过列表对象的赋值,来了解Python中赋值的机制。如下:

 

[python] view plain copy

  1. a=[1,2,“a”,“b”]
  2. b=a
  3. print(b)
  4. print(a)
  5. print(id(a))
  6. print(id(b))

 

打印结果如下:

如上,赋值语句b=a,就是把a对象赋值给b对象,通过打印结果可以发现,对象赋值后,两个对象元素值相同,指向的内存空间也相同。

对象赋值的过程实质就是一个对象把引用的内存空间地址赋值给另一个对象,对象赋值后,两个对象指向了同一块内存空间。因此,内存空间存储的元素发生的任何变化,程序中的对象元素也会发生相应的改变。如下:

 

[python] view plain copy

  1. a=[1,2,“a”,“b”]
  2. b=a
  3. a.append(“c”)
  4. print(a)
  5. print(b)
  6. b.append(3)
  7. print(a)
  8. print(b)

 

代码打印结果如下:

如上,我们在列表a中添加了一个元素”c”,打印列表a和b,发现两个列表都增加了元素”c”;同样,在列表b后增添元素3,列表a中也增加了元素3。其中的原因就是两个对象引用了同一块地址空间,两个对象的操作也是在同一块地址空间上进行的。对象的赋值机制如下图:

(2)浅拷贝

对象赋值后,两个对象引用同一块内存空间;而浅拷贝并不拷贝对象在内存空间的地址,拷贝的是对象中的子元素的内存地址.浅拷贝需要导入模块copy,该模块中的方法copy(x)会对对象x发生浅拷贝。代码例子如下:

 

[python] view plain copy

  1. import copy
  2. a=[1,2,[‘a’,‘b’]]
  3. b=copy.copy(a)
  4. print(id(a))
  5. print(id(b))
  6. for aele in a:
  7.     print(id(aele))
  8. for bele in b:
  9.     print(id(bele))

 

如上,使用模块copy的方法copy(x)浅拷贝对象a并赋给对象b,打印结果如下:

如上,列表a=[1,2,[‘a’,’b’]],拷贝后的对象为b.打印a和b的内存地址,发现并不相同,这说明内存中重新开辟出一块空间来存储b。通过对比,可以发现列表a中的元素空间地址与列表b中对应的元素空间地址是相同的。这说明,浅拷贝不拷贝对象的空间地址,但却拷贝对象中子元素的空间地址。既然a和b位于不同的地址空间中,那么两个对象对元素的操作是不是互不影响呢?如下:

 

[python] view plain copy

  1. import copy
  2. a=[1,2,[‘a’,‘b’]]
  3. b=copy.copy(a)
  4. b[0]=5
  5. print(a)
  6. print(b)
  7. print(id(a[0]))
  8. print(id(b[0]))

 

代码打印结果如下:

如上,修改b中元素b[0]=5,对象a中的元素a[0]并没有发生改变,原因就是a和b并没有处于同一地址空间中,导致修改两者的元素并不会同步,通过打印a[0]和b[0]也发现,修改元素后两者的内存地址也不相同了。但是修改两个对象的所有子元素都是如此吗?答案是否定的,如果被修改的子元素是一个基本数据类型,那么如上,两个对象互不影响。但是如果修改的子元素为一个序列,那么情况就不同了。

先介绍下两者的不同,如果列表对象的子元素是一个基本数据类型,那么其在内存空间的地址指向的就是子元素的值,如a[0]=1,内存地址id(a[0])指向的就是数值1;但是,如果列表对象的子元素是一个序列,那么,子元素地址指向的是另一块地址空间,如a[2]=[‘a’,’b’],地址id(a[2])指向的是另一块地址空间,这块空间存储着序列[‘a’,’b’]。如下代码:

 

[python] view plain copy

  1. import copy
  2. a=[1,2,[‘a’,‘b’]]
  3. b=copy.copy(a)
  4. a[2].append(“d”)
  5. print(a)
  6. print(b)
  7. print(id(a[2]))
  8. print(id(b[2]))

 

打印结果如下:

如果打印可以发现,在列表a[2]中添加元素”d”,b[2]中也增加了元素”d”。这是因为,虽然对象a和对象b的处于不同的地址空间,但是a[2]和b[2]指向的是同一块地址空间,因为浅拷贝是对子元素地址的拷贝。这一点也可以通过如上打印a[2]和b[2]的地址,发现两者相同证明,所以在对a[2]的修改也会反映到b[2]中,这一点与修改基本数据类型子元素是不同的。如下图为浅拷贝的内存分配图:

(3)深拷贝

深拷贝与浅拷贝的相同之处在于,拷贝之后的两个对象使用不同的地址空间。不同之处在于,浅拷贝时对象的子元素如果是引用型数据(如列表或者字典),那么两个对象的子元素在浅拷贝后会使用相同的地址空间。而对于深拷贝,对象的子元素如果是引用型数据,那么两个对象的子元素在深拷贝后会使用不同的地址空间。这个结论,可以使用如下代码得到证明:

 

[python] view plain copy

  1. import copy
  2. a=[1,2,[‘a’,‘b’]]
  3. b=copy.deepcopy(a)
  4. print(id(a))
  5. print(id(b))
  6. for aele in a:
  7.     print(id(aele))
  8. for bele in b:
  9.     print(id(bele))

 

打印结果如下:

如上,发生深拷贝后,对象a和对象b的内存地址并不同,这说明发生深拷贝后,两个对象指向不同的地址空间。再观察两个对象子元素的地址空间,a[0],a[1]作为基本数据类型与b[0],b[1]地址空间是相同的。而a[2],b[2]作为引用型数据指向不同的地址空间,这也是之前介绍到的浅拷贝与深拷贝的不同之处。即对基本数据类型的拷贝,对象子元素所指向的地址空间是相同的,这与我们在介绍对象赋值之前,所讲到的Python数据存储机制是相符的;而对引用型数据的拷贝,对象子元素所指向的地址空间是不同的。如下我们修改列表a[2]中的数据,发现b对象的数据并不会受到影响。如下:

 

[python] view plain copy

  1. import copy
  2. a=[1,2,[‘a’,‘b’]]
  3. b=copy.deepcopy(a)
  4. a[2].append(‘d’)
  5. print(a)
  6. print(b)

 

打印结果如下:

如上,列表a[2]添加字符元素‘d’,列表b[2]中的数据并没有发生同步.其原因就是在深拷贝后,列表a[2]和列表b[2]指向不同的存储空间。如下图,为深拷贝后的数据在内存中的存储:

最后,有关对象赋值,浅拷贝,深拷贝的内容我们就介绍完了。下一节我们来介绍文件,敬请期待。

未经允许不得转载:比尔云 » Python学习(21)–深拷贝与浅拷贝
分享到: 更多 (0)

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

强烈推荐

高性能SSD云服务器ECS抗攻击,高可用云数据库RDS