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 是比较两个对象的值相等，还是两个对象完全相等呢？

关于这些的种种知识，我希望通过这节课的学习，让你有个全面的了解。

## ‘==’ 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’ 或者

’==’ 操作符取得的结果，可能就不适用了。

这一点，你在日常写程序时一定要注意，在必要的地方请不要省略条件检查。

浅拷贝和深度拷贝

接下来，我们一起来看看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 /# 如果字典里已经存储了将要拷贝的对象，则直接返回 …

总结

今天这节课，我们一起学习了Python中对象的比较和拷贝，主要有下面几个重点内容。

  • 比较操作符

’==’ 表示比较对象间的值是否相等，而

‘is’ 表示比较对象的标识是否相等，即它们是否指向同一个内存地址。

  • 比较操作符

‘is’ 效率优于

’==’ ，因为

‘is’ 操作符无法被重载，执行

‘is’ 操作只是简单的获取对象的ID，并进行比较；而

’==’ 操作符则会递归地遍历对象的所有值，并逐一比较。

  • 浅拷贝中的元素，是原对象中子对象的引用，因此，如果原对象中的元素是可变的，改变其也会影响拷贝后的对象，存在一定的副作用。
  • 深度拷贝则会递归地拷贝原对象中的每一个子对象，因此拷贝后的对象和原对象互不相关。另外，深度拷贝中会维护一个字典，记录已经拷贝的对象及其ID，来提高效率并防止无限递归的发生。

思考题

最后，我为你留下一道思考题。这节课我曾用深度拷贝，拷贝过一个无限嵌套的列表。那么。当我们用等于操作符

’==’ 进行比较时，输出会是什么呢？是True或者False还是其他？为什么呢？建议你先自己动脑想一想，然后再实际跑一下代码，来检验你的猜想。 import copy x = [1] x.append(x) y = copy.deepcopy(x) /# 以下命令的输出是？ x == y

欢迎在留言区写下你的答案和学习感想，也欢迎你把这篇文章分享给你的同事、朋友。我们一起交流，一起进步。

参考资料

https://learn.lianglianglee.com/%e4%b8%93%e6%a0%8f/Python%e6%a0%b8%e5%bf%83%e6%8a%80%e6%9c%af%e4%b8%8e%e5%ae%9e%e6%88%98/15%20Python%e5%af%b9%e8%b1%a1%e7%9a%84%e6%af%94%e8%be%83%e3%80%81%e6%8b%b7%e8%b4%9d.md