下载APP
关闭
讲堂
算法训练营
前端训练营
客户端下载
兑换中心
企业版
渠道合作
推荐作者

15 | Python对象的比较、拷贝

2019-06-12 景霄
Python核心技术与实战
进入课程

讲述：冯永吉

时长10:41大小8.57M

你好，我是景霄。

在前面的学习中，我们其实已经接触到了很多 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
复制代码

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

© 版权归极客邦科技所有，未经许可不得传播售卖。 页面已增加防盗追踪，如有侵权极客邦将依法追究其法律责任。
上一篇
14 | 答疑（一）：列表和元组的内部实现是怎样的？
下一篇
16 | 值传递，引用传递or其他，Python里参数是如何传递的？
 写留言

精选留言(23)

  • SCAR
    2019-06-12
    17
    应该会出错，因为x是一个无限嵌套的列表，y深拷贝于x，按道理来讲 x == y应该是True的，但进行比较操作符“==”的时候，'=='操作符则会递归地遍历对象的所有值，并逐一比较。而python为了防止栈崩溃，递归的层数是要限定的，不会无休下去，所以到了限定的层数，python解释器会跳出错误。执行了一下代码，也的确是跳出了 RecursionError: maximum recursion depth exceeded in comparison。
    之前课中做阶乘的例子，如果大于一定的整数，也是会出现递归错误，究其原因也是python的递归层数是有限定的。
    def factorial(n):
        return 1 if n <=1 else n*factorial(n-1)
    factorial(5000)
    RecursionError: maximum recursion depth exceeded in comparison
    在sys模块中有个方法可以得到递归的层数:
    import sys
    sys.getrecursionlimit()
    3000
    当然你也可以重新设定递归的层数：
    sys.setrecursionlimit(10000)
    那是不是可以设定无穷大呢？理论上可以，但你的程序崩溃也是一定的，我的mac内存是16G，如果把递归层数设定到1百万，大概跑到35000层左右，我的服务就挂了。
    展开
  • hlz-123
    2019-06-12
    7
    # 以下命令的输出是？
    x == y
    1. 出现如下错误信息，推测原因是x与y的列表进行一项一项比较，因无限嵌套，导致递归深度失败。
       RecursionError: maximum recursion depth exceeded in comparison
    2. 两个问题，需要老师解答
        既然是无限嵌套，为什么x.append(x)没有报错？
        运行len(x),结果为2,更是不可理解
      
    展开
  • yshan
    2019-06-12
    5
    浅拷贝，不可变的不可变，可变的依旧可变
    深拷贝，都不可变
    展开
  • Jason
    2019-06-12
    1
    x.append(x)为什么会产生无限嵌套的列表呢？
  • Hoo-Ah
    2019-06-12
    1
    使用列表append自身的时候，没有报递归深度达到最大值的错误，然后我看了list类append方法的源码，里面有这句话Note: new_allocated won't overflow because the largest possible value is PY_SSIZE_T_MAX * (9 / 8) + 6 which always fits in a size_t. 翻译过来就是新的重载方法不会溢出。使用深拷贝也不会溢出，看源码没看懂。出现错误的原因是因为使用了“==”操作符，因为该操作符会递归的比较里面的值。
  • 明月
    2019-06-12
    1
    我的x超过256的还是is或者==为true 不知道是不是版本和机器的原因 我的是python3.5.3
  • KaitoShy
    2019-06-12
    1
    有几个问题：
    1）a = 257
    b = 257
    print(id(a))
    print(id(b))
    ---------
    4526886832
    4526886832 这个和环境有关么？我用VsCode编辑运行和jupter运行的结果不一致。juterNotebook返回的不一样的
    展开
  • farFlight
    2019-06-12
    1
    deepcopy创建一个新的对象，并且将原对象中的元素，以递归的方式，通过创建新的子对象拷贝到新对象中。因此'x == y'会无限递归对比，出现stack overflow。

    实际运行：
    x == y
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    RecursionError: maximum recursion depth exceeded in comparison
    展开
  • pyhhou
    2019-06-12
    1
    思考题：
    一开始猜想是 print True，因为当 x append 自身的时候，程序是没有报错的，返回的结果是：[1, [...]]，我想程序既然没有报错，则 [...] 表示的应该是对应的一个最大限度的值，只是这里它没有将其表示出来；当我们 deepcopy 的时候 y 获得了同样的结果，表示深度拷贝成功；用 == 来比较两个 list 其实是比较里面的值是否相等，所以应该返回 True。

    当然尝试的结果是报错 “RecursionError: maximum recursion depth exceeded in comparison”，我想应该是内部的比较函数递归比较的时候递归深度过长，也就是列表的递归嵌套超过了其限度
    展开
  • 小侠龙旋风
    2019-06-14
    1.比较操作符'is'的速度效率，通常要优于'=='。因为'is'操作符不能被重载，这样，Python 就不需要去寻找，程序中是否有其他地方重载了比较操作符，并去调用。执行比较操作符'is'，就仅仅是比较两个变量的 ID 而已。
    2.list的切片和list()构造函数都是常见的浅拷贝；
    另外，import copy调用copy.copy(xxx)同样也能做到浅拷贝。
    tuple是个例外，浅拷贝不会重新分配内存，结果会指向同一份引用，id比较返回True。
    这是因为上节课中所说的，Python对tuple的缓存优化导致的现象吗？
    3.文中说到，“深度拷贝...将原对象中的元素，以递归的方式，通过...”。
    关于deepcopy源码，我是这样理解的：
    因为Python的递归深度是有限的，超出递归深度会引发RuntimeError异常，为了防止这种不必要的拷贝，做了查询字典检查已存对象的判断。

    思考题：
    >>> import copy
    >>> x = [1]
    >>> x.append(x)
    >>> x
    [1, [...]]
    >>> y=copy.deepcopy(x)
    >>> x==y
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    RecursionError: maximum recursion depth exceeded in comparison
    展开
  • Lone
    2019-06-13
    浅拷贝的例子 让我想起了《流畅的Python》
  • Wing·三金
    2019-06-13
    # == VS is
    - == 符号调用的是 __eq__ 函数，用于递归地比较对象之间的值是否相等
    - is 的结果取决于 id，即是否指向同一对象
    - is 操作符无法重载，速度快；== 操作符每次使用 Python 内部需要寻找是否有其他地方重载了比较操作符，而且重载一般会伴随着更复杂的比较处理操作

    ## 特殊情况
    - 出于对性能优化的考虑，-5~256 的整型数字在首次创建时会开辟数组型的缓存，以便重复返回相同的引用
    ```python
    a = 10
    b = 10
    a == b # True
    a is b # True

    a = 257
    b = 257
    a == b # True
    a is b # False
    ```
    - 比较变量与单例（Singleton）时通常使用 is，如 if a is None
    - 通常对于不可变的变量，==/is 的结果是固定的，但是如果子变量是可变的（如 (1,2, [3, 4]) ），那么有可能改变变量
    ```python
    t1 = (1, [2, 3])
    t2 = (1, [2, 3])
    t1 == t2 # True

    t1[1].append(5)
    t1 == t2 # False
    ```

    # 浅拷贝 VS 深拷贝
    - 浅拷贝重新分配一块内存并创建新对象，但只拷贝对子对象的引用
    - 深拷贝同样分配新的内存，但是递归地对子对象都分配新的内存，保证不会与原对象“藕断丝连”
    - 浅拷贝方式：list/set/dict/tuple; :（切片）; copy.copy()
    ```python
    l1 = [1, 2]
    l2 = list(l1)
    l1 == l2 # True
    l1 is l2 # False

    s1 = {1, 2}
    s2 = set(s1)
    s1 == s2 # True
    s1 is s2 # False

    l1 = [1, 2]
    l2 = l1[:]
    l1 == l2 # True
    l1 is l2 # False

    import copy
    l1 = [1, 2]
    l2 = copy.copy(l1)
    ```
    - 子对象可变时，最好用 copy.deepcopy()
    ```python
    # shallow
    l1 = [[1, 2], (30, )]
    l2 = list(l1)
    l1.append(100) # 对 l2 无影响
    l1[0].append(3) # 对 l2 有影响！
    l1[1] += (50, ) # + 表示元组拼接，对 l2 无影响

    # deep
    import copy
    l1 = [[1, 2], (30, )]
    l2 = copy.deepcopy(l1) # 任意操作，能互相伤害算我输
    ```

    ## 特殊情况
    - 对于 tuple，使用 tuple() 或切片不会创建浅拷贝
    ```python
    t1 = (1, 2)
    t2 = tuple(t1)
    t1 == t2 # True
    t1 is t2 # True!!!
    ```
    - 对于深度拷贝，如果被拷贝对象中存在指向自身的引用，拷贝容易造成无限循环
    ```python
    x = [1]
    x.append(x) # x = [1, [...]]

    y = copy.deepcopy(x) # y = [1, [...]]

    # 上面这一步事实上不会出现 stack overflow 或程序运行停不下来的情况，why?
    # 原因是 deepcopy 会维护一个字典用于记录已经拷贝的【对象+id】，若字典中已经存储了将要拷贝的对象则直接从字典返回

    x is y # False
    x == y # RecursionError: maximum recursion depth exceeded in comparison

    z = x
    z is x # True
    ```
    展开
  • code2
    2019-06-13
    递归不能拷贝？
  • 程序员人生
    2019-06-13
    def example2():
        print('example2')
        c = 257
        d = 257

        print(c==d)
        print(c is d)
        print(id(c))
        print(id(d))

    example2（）

    执行结果：
    example2
    True
    True
    2224777146224
    2224777146224

    老师，老师，为什么这段代码的执行效果跟文章里面的不一样？？
    python3.7.2 pycharm
    展开
  • 大斌
    2019-06-13
    超出递归深度，报错：RecursionError: maximum recursion depth exceeded in comparison
    展开
  • NG
    2019-06-12
    运行代码时报错。原因是进行"=="时需要递归对比每一个元素，该循环是一个无限循环（无限个元素）。然而python专门设置的一种机制用来防止无限递归造成Python溢出崩溃，换句话说不能遍历比较到所有值，所以报错“RecursionError: maximum recursion depth exceeded in comparison”
    展开
  • 路伴友行
    2019-06-12
    这样看就明白了：
    print(id(x[1][1]))
    print(id(x[1][1][1][1][1][1][1][1]))
    x 和 y 各自形成了一个闭环
    展开
  • Jon徐
    2019-06-12
    a = 258
    b = 258
    在python解释器中使用id查看确实内存地址不同，但是使用vs code同样也是python解释器，内存地址是相同的。

    思考题中 x 是循环嵌套的列表，比较时超过了递归限制报错
    展开
  • YSS
    2019-06-12
    if y is not _nil：
    老师，请问这是什么意思呢，_nil是个list，为什么不用y not in _nil?
    展开
  • John Si
    2019-06-12
    由于 '==' 是递归地遍历对象的所有值，并一一比较，而x, y 对像均是一个无限嵌套列表，所以会进行无数次比较，故会出现stack overflow 错误
    展开