Python中的深浅拷贝

在讲深浅拷贝之前，咱们先重温一下 is 和==的区别。

在判断对象是否相等比拟的时候咱们能够用is 和 ==

  • is：比拟两个对象的援用是否雷同，即 它们的id 是否一样
  • == ： 比拟两个对象的值是否雷同。
id() ，是Python的一个内置函数，返回对象的惟一标识，用于获取对象的内存地址。

如下

首先，会为整数1调配一个内存空间。 变量a 和 b 都指向了这个内存空间（内存地址相等），所以他们的id相等。

即 a is b 为 True

然而，真的所有整数数字都这样吗？ 答案是：不是！ 只有在 -25 ~ 256范畴中的整数才不会重新分配内存空间。

如下所示：

因为257 超出了范畴，所以id不雷同，所以a is b返回的值为False。

>>> a = 257>>> b = 257>>> print(id(a))20004752>>> print(id(b))20001312>>> print(a is b)False>>> print(a == b)True

这样做是思考到性能，Python对-5 到 256 的整数保护了一个数组，相当于一个缓存， 当数值在这个范畴内，间接就从数组中返回绝对应的援用地址了。如果不在这个范畴内，会从新开拓一个新的内存空间。

is 和 == 哪个效率高？

相比之下，is比拟的效率更高，因为它只须要判断两个对象的id是否雷同即可。

而== 则须要重载__eq__ 这个函数，遍历变量中的所有元素内容，逐次比拟是否雷同。因而效率较低

浅拷贝 深拷贝

给变量进行赋值，有两种办法 间接赋值，拷贝

间接赋值就 = 就能够了。而拷贝又分为浅拷贝和深拷贝

先说论断吧：

  • 浅拷贝：拷贝的是对象的援用，如果原对象扭转，相应的拷贝对象也会产生扭转
  • 深拷贝：拷贝对象中的每个元素，拷贝对象和原有对象不在有关系，两个是独立的对象

光看下面的概念，对老手来讲可能不太好了解。来看上面的例子吧

赋值

a = [1, 2, 3]b = aprint(id(a)) # 52531048print(id(b)) # 52531048

定义变量a，同时将a赋值给b。打印之后发现他们的id是雷同的。阐明指向了同一个内存地址。

而后批改a的值，再查看他们的id

a = [1, 2, 3]b = aprint(id(a))  # 46169960a[1] = 0print(a, b)  # [1, 0, 3] [1, 0, 3]print(id(a))  # 46169960print(id(b))  # 46169960

这时候发现批改后的a和b以及最开始的a的内存地址是一样的。也就是说a和b还是指向了那一块内存，只不过内存外面的[1, 2, 3] 变成了[1, 0, 3]

因为每次从新执行的时候内存地址都是产生扭转的，此时的id(a) 的值46169960与52531048是一样的

所以咱们就能够判断出，b和a的援用是雷同的，当a产生扭转的时候，b也会产生扭转。

赋值就是：你a无论怎么变，你指向谁，我b就跟着你指向谁。

拷贝

提到拷贝就防止不了可变对象和不可变对象。

  • 可变对象：当有须要扭转对象外部的值的时候，这个对象的id不发生变化。
  • 不可变对象：当有须要扭转对象外部的值的时候，这个对象的id会发生变化。
a = [1, 2, 3]print(id(a)) # 56082504a.append(4)# 批改列表a之后 id没产生扭转，可变对象print(id(a)) # 56082504a = 'hello'print(id(a)) # 59817760a = a + ' world'print(id(a)) # 57880072# 批改字符串a之后，id产生了变动。不可变对象print(a) # hello world

浅拷贝

拷贝的是不可变对象，肯定水平上来讲等同于赋值操作。然而对于多层嵌套构造，浅拷贝只拷贝父对象，不拷贝外部的子对象。

应用copy模块的 copy.copy 进行浅拷贝。

import copya = [1, 2, 3]b = copy.copy(a)print(id(a))  # 55755880print(id(b))  # 55737992a[1] = 0print(a, b) # [1, 0, 3] [1, 2, 3]

艰深的讲，我将当初的a 复制一份重新分配了一个内存空间。前面你a怎么扭转，那跟我b是没有任何关系的。

对于列表的浅拷贝还能够通过list()， list[:] 来实现

然而！我后面提到了对于多层嵌套的构造，须要留神

看上面的例子

import copya = [1, 2, [3, 4]]b = copy.copy(a)print(id(a)) # 23967528print(id(b)) # 21738984# 扭转a中的子列表a[-1].append(5)print(a) # [1, 2, [3, 4, 5]]print(b) # [1, 2, [3, 4, 5]]  ？？ 为什么不是[1, 2, [3, 4]]呢？

b是由a浅拷贝失去的。我批改了a中嵌套的列表，发现b也跟着批改了？

如果还是不太了解，能够参考下图。LIST就是一个嵌套的子对象，指向了另外一个内存空间。所以浅拷贝只是拷贝了元素1， 2 和子对象的援用！

另外一种状况，如果嵌套的是一个元组呢？

import copya = [1, 2, (3, 4)]b = copy.copy(a)# 扭转a中的元组a[-1] += (5,)print(a) # [1, 2, (3, 4, 5)]print(b) # [1, 2, (3, 4)]

咱们发现浅拷贝得来的b并没有产生扭转。因为元组是不可变对象。扭转了元组就会生成新的对象。b中的元组援用还是指向了旧的元组。

深拷贝

所谓深拷贝呢，就是重新分配一个内存空间（新对象），将原对象中的所有元素通过递归的形式进行拷贝到新对象中。

在Python中 通过copy.deepcopy() 来实现深拷贝。

import copya = [1, 2, [3, 4]]b = copy.deepcopy(a)print(id(a)) # 66587176print(id(b)) # 66587688# 扭转a中的可变对象a[-1].append(5)print(a) # [1, 2, [3, 4, 5]]print(b) # [1, 2, [3, 4]]  深拷贝之后字列表不会受原来的影响

结语

1、深浅拷贝都会对源对象进行复制，占用不同的内存空间

2、如果源对象没有子目录，则浅拷贝只能拷贝父目录，改变子目录时会影响浅拷贝的对象

3、列表的切片实质就是浅拷贝

史上最全Python材料汇总（长期更新）。隔壁小孩都馋哭了 --- 点击支付