欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

Python核心技术与实战学习笔记(九):Python对象的比较和拷贝

程序员文章站 2022-04-08 17:17:47
...

1. == 与 is

1.1 应用

==:比较对象之间的值是否相等
is:比较对象身份标识是否相等,即是否为同一个对象

a = 10
b = 10

a == b
True

id(a)
4427562448

id(b)
4427562448

a is b
True

python会为10开辟一个内存空间,然后让a,b指向该内存空间;要注意的是,对于整型数字来说,只有当数字为-5到256之间时才会这样。原因在于:python内部维持着一个-5到256的数组,起到缓存的作用。当要创建一个-5到256的整型数字时,python都会从这个数组返回相对应的引用,而不是为该数开辟内存空间
当我们创建的不是-5到256之间的数字时,如:

a = 257
b = 257

a == b
True

id(a)
4473417552

id(b)
4473417584

a is b
False

python为257开辟了两个新的内存空间。

1.2 ==与is的效率比较

比较操作符“is”的速度效率通常要优于“==”。这是因为:

  • is操作符不能被重载,这样python就不用去程序其他地方查找是否重载了此比较符,并去调用。而执行is比较操作符,就仅仅是比较两个变量的ID而已。
  • 对于“==”操作符,执行a==b就相当于去执行a.__eq__(b),而python大部分数据类型都会去重载__eq__这个函数,其内部处理通常更复杂。比如,对于列表,__eq__函数会去遍历列表中的元素,比较它们的顺序和值是否相等。

immutable变量之间的==判断是否永远不变

创建元组之后,由于它immutable,故不可修改。那么,是不是对于两个值相同的元组,==判断永远成立呢?

t1 = (1,2,[3,4])
t2 = (1,2,[3,4])
print(t1 == t2)
============================
true

t1[-1].append(5)
print(t1 == t2)
=============================
false

由于元组是可嵌套的,故元组内部还可以嵌套可变类型,可以对其进行修改,这样元组也变了,==不再成立。

因此,在日常程序中,不要因为是immutable就放松警惕,在必要的地方不要省略条件检查

1.3 浅拷贝与深拷贝

浅拷贝

浅拷贝:拷贝的是原来对象的引用,并开辟新的内存空间存储这些引用

浅拷贝主要有三种方式:工厂函数,切片操作,copy.copy()方法:

  1. 工厂函数:
l1 = [1, 2, 3]
l2 = list(l1)

l2
[1, 2, 3]

l1 == l2
True

l1 is l2
False

s1 = set([1, 2, 3])
s2 = set(s1)

s2
{1, 2, 3}

s1 == s2
True

s1 is s2
False

  1. 切片操作(可变序列):
l1 = [1, 2, 3]
l2 = l1[:]

l1 == l2
True

l1 is l2
False
  1. copy.copy()方法:
import copy
l1 = [1, 2, 3]
l2 = copy.copy(l1)

要注意的是,对于元组,以上三种方式都不会创建浅拷贝,而只是返回指向相同元组的引用:

t1 = (1, 2, 3)
t2 = tuple(t1)

t1 == t2
True

t1 is t2
True

显然,由于浅拷贝里的元素只是对原先对象的引用(实际上都指向了同一块内存区域),故原先对象的改变也会导致浅拷贝元素的改变。

l1 = [[1, 2], (30, 40)]
l2 = list(l1)
l1.append(100)
l1[0].append(3)

l1
[[1, 2, 3], (30, 40), 100]

l2  # 原本为[[1, 2], (30, 40)]
[[1, 2, 3], (30, 40)] # l2的第一个元素是引用,和l1的第一个元素一样指向了同一个列表

l1[1] += (50, 60) # 元组是不可变的,这里表示的是对元组的拼接
l1
[[1, 2, 3], (30, 40, 50, 60), 100]

l2
[[1, 2, 3], (30, 40)]  # 元组不能浅拷贝,l2中没有引用新元组,因此l2不受影响。

因此,若要避免浅拷贝带来的副作用,则要使用深拷贝。

深拷贝的方式

深拷贝是指重新分配一块内存,创建一个新的对象,并且将原对象的元素,以递归的方式,通过创建新的子对象拷贝到新对象中。因此,新对象与原对象没有任何关联。

python中以copy.deepcopy()方法实现对象的深拷贝。如:

import copy
l1 = [[1, 2], (30, 40)]
l2 = copy.deepcopy(l1)
l1.append(100)
l1[0].append(3)

l1
[[1, 2, 3], (30, 40), 100]

l2 
[[1, 2], (30, 40)]

深拷贝会维护一个字典,记录已经拷贝的对象及其ID,来提高效率并防止无限递归的发生。

相关标签: 浅拷贝 深拷贝