关于python:通俗易懂搞定Python中的深浅拷贝

Python中的深浅拷贝

在讲深浅拷贝之前，想先讲一下 is 和==的区别。

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

• is：比拟两个对象的援用是否雷同，即 它们的id 是否一样
• == ： 比拟两个对象的值是否雷同。

id() ，是Python的一个内置函数，返回对象的惟一标识，用于获取对象的内存地址。

如下

a = 1
b = 1

print(id(a)) # 2057422768
print(id(b)) # 2057422768
print(a is b) # True

首先，会为整数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__ 这个函数，遍历变量中的所有元素内容，逐次比拟是否雷同。因而效率较低

浅拷贝 深拷贝

简略的理解了is， ==， 上面咱们一起来看看Python中的深浅拷贝。

先说论断吧：

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

浅拷贝

a = [1, 2, 3]
b = list(a)  # 能够通过list 对列表进行浅拷贝
c = a.copy() # 也能够通过copy函数进行拷贝

# 浅拷贝后，a/b/c的id 各不相同，阐明指向了不同的内存地址-- 即 生成了新的对象
print(id(a)) # 16301992
print(b, "id:", id(b)) # id:16562024
print(c, "id:", id(c)) # id:16561960

print(a == b) # True  值雷同 返回True
print(a is b) # False  id不同所以 is比拟返回False

# 给列表a 增加元素4
a.append(4)
print(a) # [1, 2, 3, 4]
print(b, c) # [1, 2, 3] [1, 2, 3]  b和c 不受影响

以上能够看出，浅拷贝会调配一个新的内存空间，创立一个新的对象。然而如果被拷贝对象中有可变对象会怎么样呢？ 看上面的代码

a = [1, 2, [3, 4]]
b = a.copy()

print(id(a)) # 23967528
print(id(b)) # 21738984
# 扭转a中的可变对象
a[-1].append(5)
print(a)

# 在给a新增元素6
a.append(6)

# [1, 2, [3, 4, 5], 6]
print(a)

# [1, 2, [3, 4, 5]]
print(b)

能够看出，在列表a中新增的元素6，并没有影响b。然而在a的嵌套列表中新增的元素5，却影响了元素b。

起因在于：对于a和b都指向了同一个列表[3, 4]。 所以当a中在列表新增元素5的时候，扭转了那个列表的值，b也指向了那个列表，所以也会产生扭转。

再看看上面的代码

a = [1, 2, (3, 4)]
b = a.copy()

print(id(a)) # 59162536
print(id(b)) # 60143400
# 扭转a中的可变对象
a[-1] += (5, )

# [1, 2, (3, 4, 5)]
print(a)

# [1, 2, (3, 4)]
print(b)

对于元组（3, 4），因为元组不可变，所以在元组中新增了元素5，实际上是生成了新的元组对象。而b列表中的元组援用并没有产生扭转。

通过下面的两个例子能够看出浅拷贝可能会带来的弊病，在应用中须要大家进行相应的判断。或者去残缺的拷贝某个对象，即 深拷贝。

深拷贝

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

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

import copy
a = [1, 2, (3, 4)]
# 深拷贝
b = copy.deepcopy(a)

# 因为生成了新的对象所以，返回False
print(a is b)


a[-1] += (5,)
a.append(6)

print(a) # [1, 2, (3, 4, 5), 6]
print(b) # [1, 2, (3, 4)] 深拷贝后的对象，基本不受原对象的任何影响

…

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

喜欢 (0)赏

[搞代码]

分享 (0)