跳转至

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 == ba 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

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

精选留言(15)
  • Jingxiao 👍(112) 💬(0)

    关于思考题: SCAR说的很对,程序会报错:'RecursionError: maximum recursion depth exceeded in comparison'。因为x是一个无限嵌套的列表,y深度拷贝x也是一个无限嵌套的列表,理论上x==y应该返回True,但是x==y内部执行是会递归遍历列表x和y中每一个元素的值,由于x和y是无限嵌套的,因此会stack overflow,报错

    2019-06-17

  • 🍎🍎 👍(11) 💬(1)

    小结: 1. ‘==’ 用于比较值的大小,‘is’用于比较对象的内存地址是否相同,指向同一个内存地址 2. 对与整数型,范围在(-5 ~ 256 )之间的整形数,‘==’ 与 ‘is’ 结果相同,原因在于python建立了一个数组缓存,创建对象时直接引用缓存 3. 浅拷贝:定义:重新分配一片内存,生成新的对象,里面的元素是原对象中子对象的引用。 生成方法: 可以通过数据构造器(list、set)完成浅拷贝,对于可变序列可以使用切片完成浅拷贝,对于元组而言,tupletuple()和切片不创建浅拷贝,指向相同元组的引用,还可以使用import copy, 使用copy.copy()来进行浅拷贝。 浅拷贝是对元素的引用,所以对于子对象,如果子对象是不可变,没有影响,如果是可变的序列,会带来一些影响 4. 深拷贝,重新分配一块内存,创建一个新的对象,将原对象中的元素以递归的方式全部拷贝。深拷贝中会维持一个字典,记录已经拷贝的对象以及对象的ID,防止出现无限递归。

    2019-06-20

  • 酸葡萄 👍(0) 💬(3)

    老师 你好 浅拷贝指向的应该也不是同一块内存吧,如果是的话为什么 is 在浅拷贝中会返回False呢? is比较的不是地址吗?比如下面的例子 l1 = [1, 2, 3] l2 = l1[:] l1 == l2 True l1 is l2 False

    2019-12-16

  • SCAR 👍(171) 💬(4)

    应该会出错,因为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层左右,我的服务就挂了。

    2019-06-12

  • 瞳梦 👍(122) 💬(12)

    这节没讲好,其实可以简单归纳的: 一、赋值: 在 Python 中,对象的赋值就是简单的对象引用,这点和 C++不同 二、浅拷贝(shallow copy): 浅拷贝会创建新对象,其内容非原对象本身的引用,而是原对象内第一层对象的引用。浅拷贝有三种形式:切片操作、工厂函数、copy 模块中的 copy 函数。 三、深拷贝(deep copy): 深拷贝只有一种形式,copy 模块中的 deepcopy()函数。深拷贝和浅拷贝对应,深拷贝拷贝了对象的所有元素,包括多层嵌套的元素。因此,它的时间和空间开销要高。 四、拷贝的注意点: 1、对于非容器类型,如数字、字符,以及其他的“原子”类型,没有拷贝一说,产生的都是原对象的引用。 2、如果元组变量值包含原子类型对象,即使采用了深拷贝,也只能得到浅拷贝。

    2019-07-08

  • yshan 👍(71) 💬(0)

    浅拷贝,不可变的不可变,可变的依旧可变 深拷贝,都不可变

    2019-06-12

  • Jason 👍(18) 💬(3)

    x.append(x)为什么会产生无限嵌套的列表呢?

    2019-06-12

  • 张丽娜 👍(12) 💬(4)

    a = 257 b = 257 print(id(a)) print(id(b)) 在pycharm中运行结果中一致

    2019-06-12

  • hlz-123 👍(12) 💬(1)

    # 以下命令的输出是? x == y 1. 出现如下错误信息,推测原因是x与y的列表进行一项一项比较,因无限嵌套,导致递归深度失败。 RecursionError: maximum recursion depth exceeded in comparison 2. 两个问题,需要老师解答 既然是无限嵌套,为什么x.append(x)没有报错? 运行len(x),结果为2,更是不可理解

    2019-06-12

  • 随风の 👍(7) 💬(0)

    看到文章中对于元组的拷贝, 这里进行一下补充~. 某些情况浅/深拷贝会失效: import copy x = 1 y = copy.deepcopy(x) x is y # failed True x = '1' y = copy.deepcopy(x) x is y # failed True x = (1) y = copy.deepcopy(x) x is y # failed True x = (1,[]) y = copy.deepcopy(x) x is y # succeed False 当对数值、字符串、仅包含数值/字符串的元组进行浅/深拷贝会失效。 也就是文中所提到的, 会返回一个指向相同数值、字符串、元组的引用~

    2019-06-12

  • 明月 👍(4) 💬(1)

    我的x超过256的还是is或者==为true 不知道是不是版本和机器的原因 我的是python3.5.3

    2019-06-12

  • Dynasterran 👍(3) 💬(0)

    没看源码,猜的: 1. 为什么 len(x) 是 2。 >> x = [1] >> id(x) 4378931848 >> x.append(x) >> id(x) 4378931848 >> id(x[0]) 4304870656 >> id(x[1]) 4378931848 >> x[1] is x True >> len(x) 2 2. 为什么 x == y 会报错。 ‘==’ 搜到 x[1] 时发现 x[1] 指向一个列表 x',又去遍历这个列表 x' 的每个值,然后发现这个列表里的 x'[1] 又指向一个列表 x'', ... 实际上 x, x', x'' 都是同一个,无限循环。

    2019-06-18

  • Jon徐 👍(3) 💬(1)

    a = 258 b = 258 在python解释器中使用id查看确实内存地址不同,但是使用vs code同样也是python解释器,内存地址是相同的。 思考题中 x 是循环嵌套的列表,比较时超过了递归限制报错

    2019-06-12

  • 小池 👍(2) 💬(1)

    x.append(x)会产生递归是因为list对象的append方法本质上是在list末尾追加x的引用,而不是直接添加x指向的实例。但为什么这样不会报栈溢出呢?请问老师,python支持[1, [...]]这种写法的机制是什么?

    2019-06-28

  • 路伴友行 👍(2) 💬(0)

    这样看就明白了: print(id(x[1][1])) print(id(x[1][1][1][1][1][1][1][1])) x 和 y 各自形成了一个闭环

    2019-06-12