未知

13.5　众多比较运算符

Python 解释器对众多比较运算符（==、!=、>、<、>=、<=）的处理与前文类似，不过在两个方面有重大区别。

正向和反向调用使用的是同一系列方法。这方面的规则如表 13-2 所示。例如，对 == 来说，正向和反向调用都是 __eq__ 方法，只是把参数对调了；而正向的 __gt__ 方法调用的是反向的 __lt__ 方法，并把参数对调。
对 == 和 != 来说，如果反向调用失败，Python 会比较对象的 ID，而不抛出 TypeError。

表13-2：众多比较运算符：正向方法返回NotImplemented的话，调用反向方法

分组	中缀运算符	正向方法调用	反向方法调用	后备机制
相等性	`a == b`	`a.__eq__(b)`	`b.__eq__(a)`	返回 `id(a) == id(b)`
	`a != b`	`a.__ne__(b)`	`b.__ne__(a)`	返回 `not (a == b)`
排序	`a > b`	`a.__gt__(b)`	`b.__lt__(a)`	抛出 `TypeError`
	`a < b`	`a.__lt__(b)`	`b.__gt__(a)`	抛出 `TypeError`
	`a >= b`	`a.__ge__(b)`	`b.__le__(a)`	抛出 `TypeError`
	`a <= b`	`a.__le__(b)`	`b.__ge__(a)`	抛出T `ypeError`

　Python 3 的新行为

Python 2 之后的比较运算符后备机制都变了。对于 __ne__，现在 Python 3 返回结果是对 __eq__ 结果的取反。对于排序比较运算符，Python 3 抛出 TypeError，并把错误消息设为 'unorderable types: int() < tuple()'。在 Python 2 中，这些比较的结果很怪异，会考虑对象的类型和 ID，而且无规律可循。然而，比较整数和元组确实没有意义，因此此时抛出 TypeError 是这门语言的一大进步。

了解这些规则之后，我们来分析并改进 Vector.__eq__ 方法的行为。这个方法在 vector_v5.py 中是这样定义的：

class Vector:
    # 省略了很多行

    def __eq__(self, other):
        return (len(self) == len(other) and
                all(a == b for a, b in zip(self, other)))

这个方法的行为如示例 13-12 所示。

示例 13-12　Vector 实例与 Vector 实例、Vector2d 实例和元组比较

>>> va = Vector([1.0, 2.0, 3.0])
>>> vb = Vector(range(1, 4))
>>> va == vb  # ➊
True
>>> vc = Vector([1, 2])
>>> from vector2d_v3 import Vector2d
>>> v2d = Vector2d(1, 2)
>>> vc == v2d  # ➋
True
>>> t3 = (1, 2, 3)
>>> va == t3  # ➌
True

❶ 两个具有相同数值分量的 Vector 实例是相等的。

❷ 如果 Vector 实例的分量与 Vector2d 实例的分量都相等，那么两个实例相等。7

7实际运行时会抛出异常：TypeError: object of type 'Vector2d' has no len()，因为 Vector2d 没有实现 __len__ 特殊方法。如果改为 vc == set(v2d) 就会返回 True。——编者注

❸ Vector 实例的分量与元组或其他任何可迭代对象的元素相等，那么对象也相等。

示例 13-12 中的最后一个结果可能不是很理想。我对这一点没有强制规则，要由应用上下文决定。不过，“Python 之禅”说道：

如果存在多种可能，不要猜测。

对操作数过度宽容可能导致令人惊讶的结果，而程序员讨厌惊喜。

从 Python 自身来找线索，我们发现 [1,2] == (1, 2) 的结果是 False。因此，我们要保守一点，做些类型检查。如果第二个操作数是 Vector 实例（或者 Vector 子类的实例），那么就使用 __eq__ 方法的当前逻辑。否则，返回 NotImplemented，让 Python 处理。参见示例 13-13。

示例 13-13　vector_v8.py：改进 Vector 类的 __eq__ 方法

def __eq__(self, other):
    if isinstance(other, Vector):  ➊
        return (len(self) == len(other) and
                all(a == b for a, b in zip(self, other)))
    else:
        return NotImplemented  ➋

❶ 如果 other 操作数是 Vector 实例（或者 Vector 子类的实例），那就像之前那样比较。

❷ 否则，返回 NotImplemented。

如果使用示例 13-13 中的新版 Vector.__eq__ 方法运行示例 13-12 中的测试，得到的结果如示例 13-14 所示。

示例 13-14　与示例 13-12 一样的测试：最后一个结果变了

>>> va = Vector([1.0, 2.0, 3.0])
>>> vb = Vector(range(1, 4))
>>> va == vb  # ➊
True
>>> vc = Vector([1, 2])
>>> from vector2d_v3 import Vector2d
>>> v2d = Vector2d(1, 2)
>>> vc == v2d  # ➋
True
>>> t3 = (1, 2, 3)
>>> va == t3  # ➌
False

❶ 结果与之前一样，与预期相符。

❷ 结果与之前一样，但是为什么呢？稍后解释。8

8这次不抛出异常，而是返回 True。请参阅前一个编者注。——编者注

❸ 结果不同了，这才是我们想要的。但是为什么会这样？请往下读……

在示例 13-14 中的三个结果里，第一个没变，但是后两个变了，这是因为示例 13-13 中的 __eq__ 方法返回了 NotImplemented。Vector 实例与 Vector2d 实例比较时，具体步骤如下。

(1) 为了计算 vc == v2d，Python 调用 Vector.__eq__(vc, v2d)。

(2) 经 Vector.__eq__(vc, v2d) 确认，v2d 不是 Vector 实例，因此返回 NotImplemented。

(3) Python 得到 NotImplemented 结果，尝试调用 Vector2d.__eq__(v2d, vc)。

(4) Vector2d.__eq__(v2d, vc) 把两个操作数都变成元组，然后比较，结果是 True（Vector2d.__eq__ 方法的代码在示例 9-9 中）。

在示例 13-14 中，Vector 实例和元组比较时，具体步骤如下。

(1) 为了计算 va == t3，Python 调用 Vector.__eq__(va, t3)。

(2) 经 Vector.__eq__(va, t3) 确认，t3 不是 Vector 实例，因此返回 NotImplemented。

(3) Python 得到 NotImplemented 结果，尝试调用 tuple.__eq__(t3, va)。

(4) tuple.__eq__(t3, va) 不知道 Vector 是什么，因此返回 NotImplemented。

(5) 对 == 来说，如果反向调用返回 NotImplemented，Python 会比较对象的 ID，作最后一搏。

那么 != 运算符呢？我们不用实现它，因为从 object 继承的 __ne__ 方法的后备行为满足了我们的需求：定义了 __eq__ 方法，而且它不返回 NotImplemented，__ne__ 会对 __eq__ 返回的结果取反。

也就是说，对示例 13-14 中的对象来说，使用 != 运算符比较的结果是一致的：

>>> va != vb
False
>>> vc != v2d
False
>>> va != (1, 2, 3)
True

从 object 中继承的 __ne__ 方法，运作方式与下述代码类似，不过原版是用 C 语言实现的：9

9object.__eq__ 和 object.__ne__ 的逻辑在 object_richcompare 函数中，位于 CPython 源码的 Objects/typeobject.c 文件（https://hg.python.org/cpython/file/c0e311e010fc/Objects/typeobject.c）中。

def __ne__(self, other):
    eq_result = self == other
    if eq_result is NotImplemented:
        return NotImplemented
    else:
        return not eq_result

　Python 3 文档的缺陷 10

写作本书时，众多比较方法的文档（https://docs.python.org/3/reference/datamodel. html）说：“x==y 成立不代表 x!=y 不成立。据此，如果定义 __eq__() 方法，也要定义 __ne__() 方法，这样运算符的行为才能符合预期。”对 Python 2 来说，确实是这样。但对 Python 3 而言，这不是好的建议，因为从 object 类继承的 __ne__ 实现够用了，几乎不用重载。Guido 在他写的“What's New in Python 3.0”一文（https://docs.python.org/3/whatsnew/3.0.html#operators-and-special-methods）中说明了这个新行为，在“Operators And Special Methods”一节中。文档的这个缺陷在 issue 4395（http://bugs.python.org/issue4395）中做了记录。

10这个缺陷现在已经修正了。——编者注

讨论完重要的中缀运算符重载之后，下面换一类运算符：增量赋值运算符。

13.5 众多比较运算符

13.5　众多比较运算符