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

1 Python 中的对象 ID

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

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

比如下面的代码，当声明 ​​ a = 100​​ 和 ​​b = 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 = 10​​ 和 ​​b = 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 b
True
>>> 

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

3 ​​==​​ 比较符

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

>>> a == b
True
>>> 

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

用同样的例子来看结果：

>>> a = ["Learning", "Python"]
>>> b = a
>>> c = a.copy()

>>> a == b
True
>>> a is b
True
>>> a == c
True
>>> a is c
False
>>> 

将看到 ​​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.name
False

>>> jane == bob
True

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

>>> jane = MyAlwaysTrueClass("Jane")

>>> jane == "some string"
True
>>> jane == None
True
>>> jane == True
True

当将 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 == a
False

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

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

>>> jane = MyAlwaysTrueClass("Jane")
>>> bob = MyAlwaysFalseClass("Bob")
>>> jane == bob
True
>>> bob == jane
False
>>> 

这是因为我们比较 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)​​