15-Python 对象的比较、拷贝
你好,我是悦创。
在前面的学习中,我们其实已经接触到了很多 Python 对象比较和复制的例子,比如下面这个,判断 a 和 b 是否相等的 if 语句:
if a == b:
...
再比如第二个例子,这里 l2 就是 l1 的拷贝。
l1 = [1, 2, 3]
l2 = list(l1)
但你可能并不清楚,这些语句的背后发生了什么。比如,
- l2 是 l1 的浅拷贝(shallow copy)还是深度拷贝(deep copy)呢?
a == b
是比较两个对象的值相等,还是两个对象完全相等呢?
关于这些的种种知识,我希望通过这节课的学习,让你有个全面的了解。
1. '==' VS 'is'
等于(==
)和 is 是 Python 中对象比较常用的两种方式。简单来说,'=='
操作符比较对象之间的值是否相等,比如下面的例子,表示比较变量 a 和 b 所指向的值是否相等。
a == b
而 'is'
操作符比较的是对象的身份标识是否相等,即它们是否是同一个对象,是否指向同一个内存地址。
在 Python 中,每个对象的身份标识,都能通过函数 id(object)
获得。因此,'is'
操作符,相当于比较对象之间的 ID 是否相等,我们来看下面的例子:
a = 10
b = 10
a == b
True
id(a)
4427562448
id(b)
4427562448
a is b
True
这里,首先 Python 会为 10 这个值开辟一块内存,然后变量 a 和 b 同时指向这块内存区域,即 a 和 b 都是指向 10 这个变量,因此 a 和 b 的值相等,id 也相等,a == b
和 a is b
都返回 True。
不过,需要注意,对于整型数字来说,以上 a is b
为 True 的结论,只适用于 -5 到 256 范围内的数字。比如下面这个例子:
a = 257
b = 257
a == b
True
id(a)
4473417552
id(b)
4473417584
a is b
False
这里我们把 257 同时赋值给了 a 和 b,可以看到 a == b
仍然返回 True,因为 a 和 b 指向的值相等。但奇怪的是,a is b
返回了 false,并且我们发现,a 和 b 的 ID 不一样了,这是为什么呢?
事实上,出于对性能优化的考虑,Python 内部会对 -5 到 256 的整型维持一个数组,起到一个缓存的作用。这样,每次你试图创建一个 -5 到 256 范围内的整型数字时,Python 都会从这个数组中返回相对应的引用,而不是重新开辟一块新的内存空间。
但是,如果整型数字超过了这个范围,比如上述例子中的 257,Python 则会为两个 257 开辟两块内存区域,因此 a 和 b 的 ID 不一样,a is b
就会返回 False 了。
通常来说,在实际工作中,当我们比较变量时,使用 '=='
的次数会比 'is'
多得多,因为我们一般更关心两个变量的值,而不是它们内部的存储地址。但是,当我们比较一个变量与一个单例(singleton)时,通常会使用 'is'
。一个典型的例子,就是检查一个变量是否为 None:
if a is None:
...
if a is not None:
...
这里注意,比较操作符 'is'
的速度效率,通常要优于 '=='
。因为 'is'
操作符不能被重载,这样,Python 就不需要去寻找,程序中是否有其他地方重载了比较操作符,并去调用。执行比较操作符 'is'
,就仅仅是比较两个变量的 ID 而已。
但是 '=='
操作符却不同,执行 a == b
相当于是去执行 a.__eq__(b)
,而 Python 大部分的数据类型都会去重载 __eq__
这个函数,其内部的处理通常会复杂一些。比如,对于列表,__eq__
函数会去遍历列表中的元素,比较它们的顺序和值是否相等。
不过,对于不可变(immutable)的变量,如果我们之前用 '=='
或者 'is'
比较过,结果是不是就一直不变了呢?
答案自然是否定的。我们来看下面一个例子:
t1 = (1, 2, [3, 4])
t2 = (1, 2, [3, 4])
t1 == t2
True
t1[-1].append(5)
t1 == t2
False
我们知道元组是不可变的,但元组可以嵌套,它里面的元素可以是列表类型,列表是可变的,所以如果我们修改了元组中的某个可变元素,那么元组本身也就改变了,之前用 'is'
或者 '=='
操作符取得的结果,可能就不适用了。
这一点,你在日常写程序时一定要注意,在必要的地方请不要省略条件检查。
2. 浅拷贝和深度拷贝
接下来,我们一起来看看 Python 中的浅拷贝(shallow copy)和深度拷贝(deep copy)。
对于这两个熟悉的操作,我并不想一上来先抛概念让你死记硬背来区分,我们不妨先从它们的操作方法说起,通过代码来理解两者的不同。
先来看浅拷贝。常见的浅拷贝的方法,是使用数据类型本身的构造器,比如下面两个例子:
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
这里,l2 就是 l1 的浅拷贝,s2 是 s1 的浅拷贝。当然,对于可变的序列,我们还可以通过切片操作符 ':'
完成浅拷贝,比如下面这个列表的例子:
l1 = [1, 2, 3]
l2 = l1[:]
l1 == l2
True
l1 is l2
False
当然,Python 中也提供了相对应的函数 copy.copy()
,适用于任何数据类型:
import copy
l1 = [1, 2, 3]
l2 = copy.copy(l1)
不过,需要注意的是,对于元组,使用 tuple()
或者切片操作符 ':'
不会创建一份浅拷贝,相反,它会返回一个指向相同元组的引用:
t1 = (1, 2, 3)
t2 = tuple(t1)
t1 == t2
True
t1 is t2
True
这里,元组 (1, 2, 3)
只被创建一次,t1 和 t2 同时指向这个元组。
到这里,对于浅拷贝你应该很清楚了。浅拷贝,是指重新分配一块内存,创建一个新的对象,里面的元素是原对象中子对象的引用。因此,如果原对象中的元素不可变,那倒无所谓;但如果元素可变,浅拷贝通常会带来一些副作用,尤其需要注意。我们来看下面的例子:
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, 3], (30, 40)]
l1[1] += (50, 60)
l1
[[1, 2, 3], (30, 40, 50, 60), 100]
l2
[[1, 2, 3], (30, 40)]
这个例子中,我们首先初始化了一个列表 l1,里面的元素是一个列表和一个元组;然后对 l1 执行浅拷贝,赋予 l2。因为浅拷贝里的元素是对原对象元素的引用,因此 l2 中的元素和 l1 指向同一个列表和元组对象。
接着往下看。l1.append(100)
,表示对 l1 的列表新增元素 100。这个操作不会对 l2 产生任何影响,因为 l2 和 l1 作为整体是两个不同的对象,并不共享内存地址。操作过后 l2 不变,l1 会发生改变:
[[1, 2, 3], (30, 40), 100]
再来看,l1[0].append(3)
,这里表示对 l1 中的第一个列表新增元素 3。因为 l2 是 l1 的浅拷贝,l2 中的第一个元素和 l1 中的第一个元素,共同指向同一个列表,因此 l2 中的第一个列表也会相对应的新增元素 3。操作后 l1 和 l2 都会改变:
l1: [[1, 2, 3], (30, 40), 100]
l2: [[1, 2, 3], (30, 40)]
最后是 l1[1] += (50, 60)
,因为元组是不可变的,这里表示对 l1 中的第二个元组拼接,然后重新创建了一个新元组作为 l1 中的第二个元素,而 l2 中没有引用新元组,因此 l2 并不受影响。操作后 l2 不变,l1 发生改变:
l1: [[1, 2, 3], (30, 40, 50, 60), 100]
通过这个例子,你可以很清楚地看到使用浅拷贝可能带来的副作用。因此,如果我们想避免这种副作用,完整地拷贝一个对象,你就得使用深度拷贝。
所谓深度拷贝,是指重新分配一块内存,创建一个新的对象,并且将原对象中的元素,以递归的方式,通过创建新的子对象拷贝到新对象中。因此,新对象和原对象没有任何关联。
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)]
我们可以看到,无论 l1 如何变化,l2 都不变。因为此时的 l1 和 l2 完全独立,没有任何联系。
不过,深度拷贝也不是完美的,往往也会带来一系列问题。如果被拷贝对象中存在指向自身的引用,那么程序很容易陷入无限循环:
import copy
x = [1]
x.append(x)
x
[1, [...]]
y = copy.deepcopy(x)
y
[1, [...]]
上面这个例子,列表 x 中有指向自身的引用,因此 x 是一个无限嵌套的列表。但是我们发现深度拷贝 x 到 y 后,程序并没有出现 stack overflow 的现象。这是为什么呢?
其实,这是因为深度拷贝函数 deepcopy 中会维护一个字典,记录已经拷贝的对象与其 ID。拷贝过程中,如果字典里已经存储了将要拷贝的对象,则会从字典直接返回,我们来看相对应的源码就能明白:
def deepcopy(x, memo=None, _nil=[]):
"""Deep copy operation on arbitrary Python objects.
See the module's __doc__ string for more info.
"""
if memo is None:
memo = {}
d = id(x) # 查询被拷贝对象x的id
y = memo.get(d, _nil) # 查询字典里是否已经存储了该对象
if y is not _nil:
return y # 如果字典里已经存储了将要拷贝的对象,则直接返回
...
3. 总结
今天这节课,我们一起学习了 Python 中对象的比较和拷贝,主要有下面几个重点内容。
- 比较操作符
'=='
表示比较对象间的值是否相等,而'is'
表示比较对象的标识是否相等,即它们是否指向同一个内存地址。 - 比较操作符
'is'
效率优于'=='
,因为'is'
操作符无法被重载,执行'is'
操作只是简单的获取对象的 ID,并进行比较;而'=='
操作符则会递归地遍历对象的所有值,并逐一比较。 - 浅拷贝中的元素,是原对象中子对象的引用,因此,如果原对象中的元素是可变的,改变其也会影响拷贝后的对象,存在一定的副作用。
- 深度拷贝则会递归地拷贝原对象中的每一个子对象,因此拷贝后的对象和原对象互不相关。另外,深度拷贝中会维护一个字典,记录已经拷贝的对象及其 ID,来提高效率并防止无限递归的发生。
4. 思考题
最后,我为你留下一道思考题。这节课我曾用深度拷贝,拷贝过一个无限嵌套的列表。那么。当我们用等于操作符 '=='
进行比较时,输出会是什么呢?是 True 或者 False 还是其他?为什么呢?建议你先自己动脑想一想,然后再实际跑一下代码,来检验你的猜想。
import copy
x = [1]
x.append(x)
y = copy.deepcopy(x)
# 以下命令的输出是?
x == y
欢迎在留言区写下你的答案和学习感想,也欢迎你把这篇文章分享给你的同事、朋友。我们一起交流,一起进步。
关于思考题: SCAR 说的很对,程序会报错:'RecursionError: maximum recursion depth exceeded in comparison'。因为x是一个无限嵌套的列表,y深度拷贝x也是一个无限嵌套的列表,理论上 x==y
应该返回 True,但是 x==y
内部执行是会递归遍历列表x和y中每一个元素的值,由于 x 和 y 是无限嵌套的,因此会stack overflow,报错
欢迎关注我公众号:AI悦创,有更多更好玩的等你发现!
公众号:AI悦创【二维码】
AI悦创·编程一对一
AI悦创·推出辅导班啦,包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发」,全部都是一对一教学:一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然,还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线,随时响应!微信:Jiabcdefh
C++ 信息奥赛题解,长期更新!长期招收一对一中小学信息奥赛集训,莆田、厦门地区有机会线下上门,其他地区线上。微信:Jiabcdefh
方法一:QQ
方法二:微信:Jiabcdefh
- 0
- 0
- 0
- 0
- 0
- 0