写点什么

一文了解 Python 中的对象比较方法 is 和 == 及其本质

作者:宇宙之一粟
  • 2022 年 10 月 10 日
    中国香港
  • 本文字数:3750 字

    阅读完需:约 12 分钟

一文了解 Python 中的对象比较方法 is 和 ==及其本质

1 Python 中的对象 ID

我们在学习基础的时候没听说 Python 有 C 或 C++ 中的指针啊,Python 中指针是什么?


先把指针这个概念放一放,一提到指针可能初学 C 和 C++ 的人都害怕(本人也害怕),先来理解一下 Python 里面对象的本质。


比如下面的代码,当声明 a = 100b = 100 的时候,能发现 id(a) == id(b),为什么 a 和 b 的 id 值是一样的呢?


>>> a = 100>>> b = 100>>> id(a)4343720720>>> id(b)4343720720>>>
复制代码


我们来看一下这个图:


利用上图来打一个比喻,可能不是很准确但方便我们进行理解。如果计算机被当成是一栋楼,那么内存空间就相当楼中的每个房间,内存地址就是这个房间的门牌号,这个房间内可以存储数据(比如数字 100 ,数字 10 或者其他类型)。


假如有一天,来了个要租房的小 a,小 a 说:“我看中了门牌号为(内存地址 4343720720 )的这个房间”,并且放心的租用了这个房,所以 a = 100。小 a 就住在了这个房间里,当我们查询 id(a)的时候,计算机就返回给我们这个房间的门牌号(也就是内存地址 4343720720 )。


同理,小 b 也看中了这个房子,并且也放心的住了下来。而且因为房间里存储的数据都是 100,即使虽然 a 和 b 的名字不同,但他们住同一房间,所以内存地址就相同。


再看如下的代码:

>>> a, b = 10, 20>>> id(a)4343717840>>> id(b)4343718160>>> a, b = b, a>>> id(a)4343718160>>> id(b)4343717840>>>
复制代码


当声明 a = 10b = 20 的时候,情况发生了改变,这个过程其实也好理解,就是相当于小 a 和小 b 分别看中了不同的房间(小 a 看中的是门牌号 4343717840 的房间,小 b 看中的是门牌号 4343718160 ),当他们住下来后,这个房间存着不同数据( a=10, b=20 )。


当他们进行交换的时候a, b = b, a,就相当于交换了房间,但是房间里的数据是没有变。最后a=20, b =10,因为内存地址 4343717840 存的数字就是 10, 内存地址 4343718160 存的数字是 20。


2 is 比较符

如上图的例子,我们可以看到,如何确定 a 和 b 是否是一致的呢?通过:


>>> a is b
复制代码


如果这两个对象确实是内存中的同一个对象将返回 True, 否则不一致就会返回 False 。


什么是对象 id


在 Python 中我们可以通过 id() 函数查看每个对象的内存 id。


  • id(x) 是一个整数

  • id(x) == id(y) 当且仅当 x 和 y 在内存中引用相同的对象时才为真

  • id(x) 在 x 的生命周期内是恒定的,也就说,只要 x 存在,这个内存 id 也是不变的


Python 解释器有许多语言的实现,虽然以上三点在每一种实现的 id() 函数都是正确的,但它们背后的实现方式并不相同。例如 CPython (用 C 语言编写的 Python 解释器),使用对象的内存地址作为它的 id --但不要认为所有的实现都会这样做!


例如,另一个 Python 实现是 Skulpt,这是一个 Python 到 JavaScript 的编译器,Anvil 使用它来在浏览器中运行 Python 客户端代码(这样您就可以为 Web 开发而无需编写 JavaScript)。 JavaScript 中的对象没有稳定的内存地址,JavaScript 也没有为每个对象公开一个稳定的标识符。所以,Skulpt 不能使用对象在内存中的地址作为它的 id。


在本文的其余部分,我们将使用使用 CPython 生成的示例,它确实使用对象的内存地址作为其 id。 CPython 能够做到这一点,因为一旦 CPython 中的对象存在,它就不能在内存中移动。这意味着使用对象的地址作为其 id 将保证该对象的生命周期内的稳定值,不像(例如)Skulpt。


我们来看一个列表的例子:


>>> a = ["Learning", "Python"]>>> id(a)1769202632064>>> b = a>>> id(a), id(b)(1769202632064, 1769202632064)>>> 
复制代码


我们定义了一个 a 列表,然后通过 b = a 建立指向 a 的新指针,当我们检查他们的 id 时,发现它们的结果是相同的 —— 1769202632064。


接下来,我们使用 copy() 函数来看一下会不会有不同的结果:


>>> c = a.copy()>>> id(a), id(c)(1769202632064, 1769171462656)>>> 
复制代码


如上所示,a 和 c 有着不同的 id,说明调用 copy() 函数完全生成了一个全新的列表对象。

a is b 的本质

所以本质上来说,说 a is b 直接相当于说 id(a) == id(b) 。当你在两个对象上调用 is 时,Python 会获取它们的 id 并直接比较它们。而已!


>>> a is bTrue>>> 
复制代码


然而,这还不是故事的结局。 Python 有另一种更灵活的方式来定义对象相等性。

3 == 比较符

在 Python 中,想知道 “a 和 b 是否相同” 的另一种方法是使用如下的代码:


>>> a == bTrue>>> 
复制代码


就和 is 一样,== 比较符也是返回 True 或 False。但是 Python 决定返回哪个的方式与 is 运算符不同,这意味着 ==is 可以为相同的对象提供不同的结果。


用同样的例子来看结果:


>>> a = ["Learning", "Python"]>>> b = a>>> c = a.copy()
>>> a == bTrue>>> a is bTrue>>> a == cTrue>>> a is cFalse>>>
复制代码


将看到 a ==c 为 True, 反而 a is c 为 False。为什么?原因是:


  • is 用于两个指针是否指向内存中完全相同的对象

  • == 用于两个对象是否是被看做是相等的

== 运算符的本质

当您编写 a == b 时,实际上是在调用一个魔术方法(magic method),也称为 dunder 方法(函数名的两边的都有下划线,the double-underscore)。日常学习中你看能已经见过一些魔术方法,例如:


  • __init__ 方法:在初始化 Python 类的实例时调用

  • __str__ 方法:使用 str 函数时调用,例如 str(xxx)

  • __repr__ 方法,类似于 __str__ 但在其他情况下也会调用,例如错误消息


感兴趣可以跳转看我的这篇文章:一文让你彻底搞懂Python中__str__和__repr__?


魔术方法只是 Python 类上的方法,双下划线表示它们与内置的 Python 函数交互。例如,在 Python 类上重写 __str__ 方法会改变 str 函数在该修改类的实例上调用时的行为方式。


当谈到 == 和 __eq__ 时,通过一些例子最容易理解。让我们来看看!

重写 __eq_ 方法

下面,我们用自己的 __eq__ 方法定义一个类。每个 __eq__ 方法都有两个参数:


  • self,所讨论的类的实例

  • 第二个参数(在下面的代码片段中,我们定义为 other),它是与 self 进行比较的任何对象。


class MyEqualClass:  def __eq__(self, other):        return self is other
复制代码


然后进行测试:


>>> class MyEqualClass:  def __eq__(self, other):            return self is other
>>> a = MyEqualClass()>>> a == 'Hello World'False>>>
复制代码


然后这会调用 MyEqualClass 的 __eq__ 方法,其中 a 作为 self 参数,字符串 'Hello World' 作为另一个参数。


在上面的例子中,MyClass.__eq__ 使用了 is 比较器,相当于比较每个对象的 id。这实际上是 Python 中任何用户定义类的默认行为。


如果我们想自定义一个类,所以对比的对象都相等,就可以这样写:


class MyAlwaysTrueClass:    def __init__(self, name):        self.name = name        def __eq__(self, other):      return True
复制代码


因为我们重写了 __eq__ 方法以始终返回 True,这意味着在 == 比较器下,此类的所有实例都将被视为相等,即使它们的名称具有不同的值!


>>> jane = MyAlwaysTrueClass("Jane")>>> bob = MyAlwaysTrueClass("Bob")>>> jane.name == bob.nameFalse
>>> jane == bobTrue
复制代码


此外,与不同类型的对象相比,我们还可以看到 MyAlwaysTrueClass 的实例表现得很奇怪:


>>> jane = MyAlwaysTrueClass("Jane")
>>> jane == "some string"True>>> jane == NoneTrue>>> jane == TrueTrue
复制代码


当将 MyAlwaysTrueClass 的实例与任何东西(不仅仅是同一个类的实例)进行比较时,它将返回 True。这是因为,正如我们之前所说,__eq__ 方法默认情况下不检查被比较对象的类型。


那如果我们写一个功能相反的 __eq__ 的 MyAlwaysFalseClass 呢?


class MyAlwaysFalseClass:    def __init__(self, name):      self.name = name
def __eq__(self, other): return False
复制代码


你可能觉得这很合理,但是:


>>> class MyAlwaysFalseClass:    def __init__(self, name):      self.name = name
def __eq__(self, other): return False
>>> a = MyAlwaysFalseClass("name")>>> a == aFalse
复制代码


上述的列子,a == a 的结果是 False,那是因为我们在任何类型作对比中都会返回 Flase


此外,由于 __eq__ 的行为取决于哪个对象是 self 哪个是 other,我们可以通过使用 MyAlwaysTrueClass 的一个实例和一个 MyAlwaysFalseClass 的实例来获得以下行为:


>>> jane = MyAlwaysTrueClass("Jane")>>> bob = MyAlwaysFalseClass("Bob")>>> jane == bobTrue>>> bob == janeFalse>>> 
复制代码


这是因为我们比较 jane 和 bob 的顺序很重要。当我们执行 jane == bob 时,我们使用 MyAlwaysTrueClass 中定义的 __eq__ 方法:jane 是 self 而 bob 是 other,并且该方法总是返回 True。当我们写 bob == jane 时,情况正好相反,所以我们得到该表达式的 False 值。


总而言之:魔术方法是一种有趣的方式,它可以让 Python 做一些看起来很奇怪的事情,并且应该自行承担修改的风险!

4 总结

所以我们学了什么?我们已经介绍了 is== 这两个 Python 中的相等概念,并了解到


  • is 的本质使用对象 id;

  • == 使用 __eq__ 魔术方法。


我们还探索了如何覆盖 __eq__ 来自定义相等概念,并了解为什么这样做会导致一些奇怪的行为。


灵感来源:Memory Management in Python - Part 2: Equality (anvil.works)

发布于: 刚刚阅读数: 4
用户头像

宇宙古今无有穷期,一生不过须臾,当思奋争 2020.05.07 加入

🏆InfoQ写作平台-签约作者 🏆 混迹于江湖,江湖却没有我的影子 热爱技术,专注于后端全栈,轻易不换岗 拒绝内卷,工作于外企开发,弹性不加班 热衷分享,执着于阅读写作,佛系不水文 同名公众号:《宇宙之一粟》

评论

发布
暂无评论
一文了解 Python 中的对象比较方法 is 和 ==及其本质_Python_宇宙之一粟_InfoQ写作社区