__ne__ 应该作为 __eq__ 的否定来实现吗？

Question

我有一个类，我想重写 __eq__ 方法。我也应该重写 __ne__ 方法，这似乎是有道理的。我应该将 __ne__ 实现为 __eq__ 的否定，还是一个坏主意？

class A:

    def __init__(self, state):
        self.state = state

    def __eq__(self, other):
        return self.state == other.state

    def __ne__(self, other):
        return not self.__eq__(other)

Answer 1

Python，我应该基于 __eq__ 实现 __ne__() 运算符吗？

简短回答：不要实现它，但如果必须，请使用 ==，而不是 __eq__

在 Python 3 中，!= 是否定默认情况下为 ==，因此您甚至不需要编写 __ne__，并且文档不再坚持编写一个。

一般来说，对于仅 Python 3 的代码，不要编写代码，除非您需要掩盖父实现（例如，对于内置对象）。

也就是说，请记住Raymond Hettinger 的评论：

仅当满足以下条件时，__ne__ 方法才会自动遵循 __eq__
__ne__ 尚未在超类中定义。所以，如果你是
从内置继承，最好覆盖两者。

如果您需要代码在 Python 2 中工作，请遵循 Python 2 的建议，它将在 Python 3 中正常工作。

在 Python 2 中，Python 本身不会自动实现任何根据另一个操作的操作 - 因此，您应该根据 == 定义 __ne__ 而不是 __eq__ 。
EG

class A(object):
    def __eq__(self, other):
        return self.value == other.value

    def __ne__(self, other):
        return not self == other # NOT `return not self.__eq__(other)`

请参阅以下证明，证明

• 基于 __eq__ 实现 __ne__() 运算符，并且
• 在 Python 2 中根本不实现 __ne__

会提供不正确的行为。

长答案

Python 2 的 文档 说：

比较运算符之间没有隐含关系。这
x==y 为真并不意味着 x!=y 为假。因此，当
定义__eq__()，还应该定义__ne__()，以便
操作员将按预期行事。

因此，这意味着如果我们根据 __eq__ 的逆定义 __ne__，我们可以获得一致的行为。

文档的这一部分已针对 Python 3： 进行了更新

默认情况下，__ne__() 委托给 __eq__() 并反转结果
除非它是NotImplemented。

在“新增内容”部分中，我们看到这种行为已经改变：

• != 现在返回与 == 相反的内容，除非 == 返回 NotImplemented。

为了实现__ne__，我们更喜欢使用==运算符而不是直接使用__eq__方法，这样如果子类的 self.__eq__(other) 对于检查的类型返回 NotImplemented，Python 将适当地检查 other.__eq__(self) 来自文档：

NotImplemented 对象

该类型只有一个值。有一个具有该值的对象。通过内置名称访问该对象
未实现。数值方法和丰富的比较方法可能会返回
如果他们没有实现操作数的操作，则为该值
假如。 （然后解释器将尝试反射操作，或者
其他一些后备，取决于操作员。）它的真值是
正确。

当给定丰富的比较运算符时，如果它们不是同一类型，Python 会检查 other 是否是子类型，如果定义了该运算符，则使用 other > 的方法优先（与 <、<=、>= 和 > 相反） 。如果返回NotImplemented，则它使用相反的方法。 （它不会检查同一个方法两次。）使用== 运算符可以实现此逻辑。

---

期望

从语义上讲，您应该根据相等性检查来实现 __ne__ ，因为您的类的用户将期望以下函数对于 A 的所有实例都是等效的：

def negation_of_equals(inst1, inst2):
    """always should return same as not_equals(inst1, inst2)"""
    return not inst1 == inst2

def not_equals(inst1, inst2):
    """always should return same as negation_of_equals(inst1, inst2)"""
    return inst1 != inst2

也就是说，上述两个函数都应该总是返回相同的结果。但这取决于程序员。

基于 __eq__ 定义 __ne__ 时意外行为的演示：

首先设置：

class BaseEquatable(object):
    def __init__(self, x):
        self.x = x
    def __eq__(self, other):
        return isinstance(other, BaseEquatable) and self.x == other.x

class ComparableWrong(BaseEquatable):
    def __ne__(self, other):
        return not self.__eq__(other)

class ComparableRight(BaseEquatable):
    def __ne__(self, other):
        return not self == other

class EqMixin(object):
    def __eq__(self, other):
        """override Base __eq__ & bounce to other for __eq__, e.g. 
        if issubclass(type(self), type(other)): # True in this example
        """
        return NotImplemented

class ChildComparableWrong(EqMixin, ComparableWrong):
    """__ne__ the wrong way (__eq__ directly)"""

class ChildComparableRight(EqMixin, ComparableRight):
    """__ne__ the right way (uses ==)"""

class ChildComparablePy3(EqMixin, BaseEquatable):
    """No __ne__, only right in Python 3."""

实例化非等效实例：

right1, right2 = ComparableRight(1), ChildComparableRight(2)
wrong1, wrong2 = ComparableWrong(1), ChildComparableWrong(2)
right_py3_1, right_py3_2 = BaseEquatable(1), ChildComparablePy3(2)

预期行为：（

注意：当以下每项的每一个断言与之前的实例是等价的，因此在逻辑上是多余的，我将它们包括在内是为了证明当一个实例是另一个实例的子类时，顺序并不重要。）

这些实例具有 __ne__== 实现的 code>：

assert not right1 == right2
assert not right2 == right1
assert right1 != right2
assert right2 != right1

这些实例在 Python 3 下测试，也可以正常工作：

assert not right_py3_1 == right_py3_2
assert not right_py3_2 == right_py3_1
assert right_py3_1 != right_py3_2
assert right_py3_2 != right_py3_1

并且回想一下，这些实例已经使用 __eq__ 实现了 __ne__ -虽然这是预期的行为，但实现是不正确的：

assert not wrong1 == wrong2         # These are contradicted by the
assert not wrong2 == wrong1         # below unexpected behavior!

意外的行为：

请注意，此比较与上面的比较相矛盾（不是错误 1 ​​== 错误 2）。

>>> assert wrong1 != wrong2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError

并且，

>>> assert wrong2 != wrong1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError

不要在 Python 2 中跳过 __ne__

有关您不应在 Python 2 中跳过实现 __ne__ 的证据，请参阅这些等效对象：

>>> right_py3_1, right_py3_1child = BaseEquatable(1), ChildComparablePy3(1)
>>> right_py3_1 != right_py3_1child # as evaluated in Python 2!
True

上面的结果应该是 错误！

Python 3 源

__ne__ 的默认 CPython 实现位于 object_richcompare中的typeobject.c：

case Py_NE:
    /* By default, __ne__() delegates to __eq__() and inverts the result,
       unless the latter returns NotImplemented. */
    if (Py_TYPE(self)->tp_richcompare == NULL) {
        res = Py_NotImplemented;
        Py_INCREF(res);
        break;
    }
    res = (*Py_TYPE(self)->tp_richcompare)(self, other, Py_EQ);
    if (res != NULL && res != Py_NotImplemented) {
        int ok = PyObject_IsTrue(res);
        Py_DECREF(res);
        if (ok < 0)
            res = NULL;
        else {
            if (ok)
                res = Py_False;
            else
                res = Py_True;
            Py_INCREF(res);
        }
    }
    break;

但是默认的__ne__使用__eq__？

Python 3 在 C 级别的默认 __ne__ 实现细节使用 __eq__ 因为更高级别的 == (PyObject_RichCompare) 效率较低 - 因此它还必须处理 NotImplemented 。

如果 __eq__ 正确实现，那么 == 的否定也是正确的 - 它允许我们避免 __ne__ 中的低级实现细节。

使用 == 允许我们将低级逻辑保留在一个位置，并避免在 中处理 NotImplemented >__ne__。

人们可能会错误地认为 == 可能返回 NotImplemented。

它实际上使用与 __eq__ 的默认实现相同的逻辑，该实现检查身份（请参阅do_richcompare 以及下面的证据）

class Foo:
    def __ne__(self, other):
        return NotImplemented
    __eq__ = __ne__

f = Foo()
f2 = Foo()

以及比较：

>>> f == f
True
>>> f != f
False
>>> f2 == f
False
>>> f2 != f
True

性能

不要相信我的话，让我们看看什么性能更好：

class CLevel:
    "Use default logic programmed in C"

class HighLevelPython:
    def __ne__(self, other):
        return not self == other

class LowLevelPython:
    def __ne__(self, other):
        equal = self.__eq__(other)
        if equal is NotImplemented:
            return NotImplemented
        return not equal

def c_level():
    cl = CLevel()
    return lambda: cl != cl

def high_level_python():
    hlp = HighLevelPython()
    return lambda: hlp != hlp

def low_level_python():
    llp = LowLevelPython()
    return lambda: llp != llp

我认为这些性能数字不言而喻：

>>> import timeit
>>> min(timeit.repeat(c_level()))
0.09377292497083545
>>> min(timeit.repeat(high_level_python()))
0.2654011140111834
>>> min(timeit.repeat(low_level_python()))
0.3378178110579029

当您考虑到 low_level_python 正在 Python 中执行原本在 C 级别处理的逻辑时，这是有道理的。

对一些批评的回应

另一位回答者写道：

Aaron Hall 的 __ne__ 方法的实现 not self == other 是不正确的，因为它永远无法返回 NotImplemented （not NotImplemented 为 False），因此具有优先级的 __ne__ 方法永远不会依赖于不具有优先级的 __ne__ 方法。

让 __ne__ 永远不会返回 NotImplemented 并不意味着它不正确。相反，我们通过检查 == 的相等性来处理 NotImplemented 的优先级。假设 == 已正确实现，我们就完成了。

not self == other 曾经是 __ne__ 方法的默认 Python 3 实现，但它是一个错误，并于 2015 年 1 月在 Python 3.4 中得到纠正，正如 ShadowRanger 注意到的那样（请参阅问题 #21408）。

好吧，让我们解释一下。

如前所述，Python 3 默认情况下通过首先检查 self.__eq__(other) 是否返回 NotImplemented （单例）来处理 __ne__ - 这应该使用 is 进行检查，如果是则返回，否则应返回相反值。这是作为类 mixin 编写的逻辑：

class CStyle__ne__:
    """Mixin that provides __ne__ functionality equivalent to 
    the builtin functionality
    """
    def __ne__(self, other):
        equal = self.__eq__(other)
        if equal is NotImplemented:
            return NotImplemented
        return not equal

这对于 C 级 Python API 的正确性是必要的，它是在 Python 3 中引入的，使得

• 此补丁中的 __ne__ 方法 用于关闭 问题 21408 和
• 中的 __ne__ 方法后续清理删除了此处的

多余内容。所有相关的 __ne__ 方法都被删除，包括实现自己检查的方法以及直接或通过 == 委托给 __eq__ 的方法 - 和 < code>== 是最常见的方法。

对称性重要吗？

我们坚持不懈的批评家提供了一个病态的例子来证明在 __ne__ 中处理 NotImplemented 的情况，重视对称性高于一切。让我们用一个清晰​​的例子来论证这个论点：

class B:
    """
    this class has no __eq__ implementation, but asserts 
    any instance is not equal to any other object
    """
    def __ne__(self, other):
        return True

class A:
    "This class asserts instances are equivalent to all other objects"
    def __eq__(self, other):
        return True

>>> A() == B(), B() == A(), A() != B(), B() != A()
(True, True, False, True)

所以，按照这个逻辑，为了保持对称性，我们需要编写复杂的__ne__，无论Python版本如何。

class B:
    def __ne__(self, other):
        return True

class A:
    def __eq__(self, other):
        return True
    def __ne__(self, other):
        result = other.__eq__(self)
        if result is NotImplemented:
            return NotImplemented
        return not result

>>> A() == B(), B() == A(), A() != B(), B() != A()
(True, True, True, True)

显然，我们不应该介意这些实例既相等又不相等。

我认为对称性不如合理代码的假设和遵循文档的建议重要。

但是，如果 A 有一个 __eq__ 的合理实现，那么我们仍然可以遵循我的方向，并且仍然具有对称性：

class B:
    def __ne__(self, other):
        return True

class A:
    def __eq__(self, other):
        return False         # <- this boolean changed... 

>>> A() == B(), B() == A(), A() != B(), B() != A()
(False, False, True, True)

结论

对于 Python 2 兼容代码，使用 == 实现 __ne__。更重要的是：

• 正确的
• 简单
• 性能

仅在 Python 3 中，在 C 级别上使用低级否定 - 它甚至更简单且性能更高（尽管程序员有责任确定它是 >正确）。

再次强调，不要用高级 Python 编写低级逻辑。

Answer 2

是的，那很好。事实上，文档敦促您定义__ne__ 当您定义 __eq__ 时：

没有任何隐含的关系
比较运算符之间。这
x==y 的真实性并不意味着 x!=y
是假的。因此，在定义时
__eq__()，还应该定义__ne__()，以便运算符的行为符合预期。

在很多情况下（例如本例），它就像否定 __eq__ 的结果一样简单，但并非总是如此。

Answer 3

仅供记录，规范正确且跨 Py2/Py3 可移植的 __ne__ 看起来像：

import sys

class ...:
    ...
    def __eq__(self, other):
        ...

    if sys.version_info[0] == 2:
        def __ne__(self, other):
            equal = self.__eq__(other)
            return equal if equal is NotImplemented else not equal

这适用于您可能定义的任何 __eq__：

• 与 not (self = = other)，不会干扰一些涉及比较的恼人/复杂的情况，其中涉及的类之一并不意味着 __ne__ 的结果与 的结果相同not on __eq__ （例如 SQLAlchemy 的 ORM，其中 __eq__ 和 __ne__ 返回特殊代理对象，而不是 True 或 False，并且尝试不 __eq__ 的结果将返回 False，而不是正确的代理对象）。
• 与 not self.__eq__(other) 不同，当 self.__eq__ 返回 NotImplemented< 时，这会正确委托给另一个实例的 __ne__ /code> (not self.__eq__(other) 会是额外的错误，因为 NotImplemented 是真的，所以当 __eq__ 不知道如何时要执行比较，__ne__ 将返回 False，这意味着两个对象相等，而实际上唯一询问的对象并不知道，这意味着默认值不相等）

如果您的 __eq__ 不使用 NotImplemented 返回，则此方法有效（具有无意义的开销），如果它有时确实使用 NotImplemented ，则此方法可以处理它适当地。 Python 版本检查意味着，如果该类在 Python 3 中被 import-ed，则 __ne__ 未定义，从而允许 Python 原生、高效的回退 __ne__ 实现（上述的 C 版本）接管。

---

为什么需要这样做

Python 重载规则

为什么这样做而不是其他解决方案的解释有点神秘。 Python 对于重载运算符（尤其是比较运算符）有一些一般规则：（

1. 适用于所有运算符）运行 LHS OP RHS 时，尝试 LHS.__op__(RHS)，如果返回 NotImplemented，请尝试 RHS.__rop__(LHS)。例外：如果 RHS 是 LHS 类的子类，则先测试 RHS.__rop__(LHS) 首先 。对于比较运算符，__eq__ 和 __ne__ 是它们自己的“rop”（因此 __ne__ 的测试顺序是 LHS .__ne__(RHS)，然后是 RHS.__ne__(LHS)，如果 RHS 是 LHS 类的子类，则相反）
2. 除了“交换”运算符的想法之外，运算符之间没有隐含的关系。即使对于同一类的实例，LHS.__eq__(RHS) 返回 True 并不意味着 LHS.__ne__(RHS) 返回 False（事实上，运算符甚至不需要返回布尔值；像 SQLAlchemy 这样的 ORM 故意不这样做，从而允许更具表现力的查询语法）。从 Python 3 开始，默认的 __ne__ 实现就以这种方式运行，但它不是契约性的；您可以以与 __eq__ 不严格相反的方式覆盖 __ne__。

这如何适用于重载比较器

因此，当您重载运算符时，您有两项工作：

1. 如果您知道如何自己实现该操作，则仅使用您自己关于如何进行比较的知识来实现​​该操作（永远不要隐式或显式地委托给操作的另一方；这样做可能会导致错误和/或无限递归，具体取决于您的操作方式）
2. 如果您不知道如何实现该操作总是返回NotImplemented，因此Python可以委托给其他操作数的实现

not self.__eq__(other)的问题

def __ne__(self, other):
    return not self.__eq__(other)

永远不会委托给另一侧（如果__eq__正确返回NotImplemented，则不正确）。当 self.__eq__(other) 返回 NotImplemented （即“truthy”）时，您会默默返回 False，因此 A() != something_A_knows_nothing_about 返回 False，而它应该检查 something_A_knows_nothing_about 是否知道如何与 A 的实例进行比较，以及如果没有，它应该返回 True （因为如果双方都不知道如何与另一方进行比较，则它们被认为彼此不相等）。如果 A.__eq__ 未正确实现（当无法识别另一端时，返回 False 而不是 NotImplemented），那么这是“正确的” " 从 A 的角度来看，返回 True （因为 A 认为它不相等，所以它不相等），但它可能是从 something_A_knows_nothing_about 的角度来看，这是错误的，因为它甚至从未询问过 something_A_knows_nothing_about； A() != Something_A_knows_nothing_about 最终为 True，但 something_A_knows_nothing_about != A() 可能 False，或任何其他返回值。

not self == other 的问题

def __ne__(self, other):
    return not self == other

更加微妙。它对于 99% 的类都是正确的，包括所有 __ne__ 是 __eq__ 逻辑逆的类。但是 not self == other 违反了上面提到的两条规则，这意味着对于 __ne__ 不是 __eq__，结果再次是非对称的，因为其中一个操作数从未被询问是否可以实现 __ne__，即使另一个操作数不能。最简单的例子是一个奇怪的类，它对所有比较返回False，因此A() == Incomparable()和A( ) != Incomparable() 均返回 False。通过正确实现 A.__ne__（当不知道如何进行比较时返回 NotImplemented），这种关系是对称的； A() != Incomparable() 和 Incomparable() != A() 就结果达成一致（因为在前一种情况下，A.__ne__ code> 返回 NotImplemented，然后 Incomparable.__ne__ 返回 False，而后者返回 Incomparable.__ne__ <直接代码>False）。但是，当 A.__ne__ 实现为 return not self == other 时，A() != Incomparable() 返回 True< /code> （因为 A.__eq__ 返回，而不是 NotImplemented，然后 Incomparable.__eq__ 返回 False，并且 < code>A.__ne__ 将其反转为 True)，而 Incomparable() != A() 返回 False。

您可以查看实际操作示例 此处。

显然，对于 __eq__ 和 __ne__ 总是返回 False 的类有点奇怪。但如前所述，__eq__ 和 __ne__ 甚至不需要返回 True/False； SQLAlchemy ORM 具有带有比较器的类，该比较器返回用于查询构建的特殊代理对象，而不是 True/False （如果在布尔上下文中评估，它们是“true” ，但它们永远不应该在这样的上下文中进行评估）。

如果无法正确重载 __ne__ ，您将破坏此类类，因为代码：

 results = session.query(MyTable).filter(MyTable.fieldname != MyClassWithBadNE())

将起作用（假设 SQLAlchemy 知道如何插入 MyClassWithBadNE ）完全转换为 SQL 字符串；这可以使用类型适配器来完成，而无需 MyClassWithBadNE 完全配合），将预期的代理对象传递给 filter，而

 results = session.query(MyTable).filter(MyClassWithBadNE() != MyTable.fieldname)

：传递 filter 一个普通的 False，因为 self == other 返回一个代理对象，并且不是 self == other只是将 true 代理对象转换为 False。希望 filter 在处理诸如 False 之类的无效参数时抛出异常。虽然我确信很多人会认为 MyTable.fieldname 应该 始终位于比较的左侧，但事实仍然是，没有任何编程理由来强制执行此操作在一般情况下，正确的通用 __ne__ 可以以任何一种方式工作，而 return not self == other 只能在一种安排中工作。

Answer 4

__ne__ 的正确实现

@ShadowRanger 对特殊方法 __ne__ 的实现是正确的：

def __ne__(self, other):
    result = self.__eq__(other)
    if result is not NotImplemented:
        return not result
    return NotImplemented

它也恰好是特殊方法 __ne__ 的默认实现> 自 Python 3.4 起，如 Python 文档：

默认情况下，__ne__() 委托给 __eq__() 并反转结果，除非它是 NotImplemented。

另请注意，为不支持的操作数返回值 NotImplemented 并不特定于特殊方法 __ne__。事实上，所有特殊比较方法¹和特殊数值方法²都应该针对不支持的操作数返回值NotImplemented ，如 Python 文档中指定：

未实现

该类型只有一个值。有一个具有该值的对象。通过内置名称 NotImplemented 访问该对象。如果数字方法和丰富的比较方法没有实现所提供操作数的操作，则应返回此值。 （解释器然后将尝试反射操作，或其他一些后备，具体取决于操作符。）它的真值是 true。

Python 中给出了特殊数字方法的示例文档：

class MyIntegral(Integral):

    def __add__(self, other):
        if isinstance(other, MyIntegral):
            return do_my_adding_stuff(self, other)
        elif isinstance(other, OtherTypeIKnowAbout):
            return do_my_other_adding_stuff(self, other)
        else:
            return NotImplemented

    def __radd__(self, other):
        if isinstance(other, MyIntegral):
            return do_my_adding_stuff(other, self)
        elif isinstance(other, OtherTypeIKnowAbout):
            return do_my_other_adding_stuff(other, self)
        elif isinstance(other, Integral):
            return int(other) + int(self)
        elif isinstance(other, Real):
            return float(other) + float(self)
        elif isinstance(other, Complex):
            return complex(other) + complex(self)
        else:
            return NotImplemented

---

¹特殊比较方法：__lt__、__le__、__eq__、__ne__ 、__gt__ 和 __ge__。

² 特殊数值方法：__add__、__sub__、__mul__、__matmul__、<代码>__truediv__、__floordiv__、__mod__、__divmod__、__pow__、__lshift__ code>、__rshift__、__and__、__xor__、__or__ 及其 __r*__反射和 __i*__ 就地对应。

__ne__ 的错误实现 #1

@Falmarri 对特殊方法 __ne__ 的实现不正确：

def __ne__(self, other):
    return not self.__eq__(other)

此实现的问题在于它没有依赖于特殊方法 另一个操作数的 __ne__ ，因为它永远不会返回值 NotImplemented （表达式 not self.__eq__(other) 计算结果为值 True 或 False，包括当其子表达式 self.__eq__(other) 计算结果为值 NotImplemented 时，因为表达式 bool(NotImplemented ) 计算结果为值 True)。值 NotImplemented 的布尔计算破坏了比较运算符 != 和 == 之间的补码关系：

class Correct:

    def __ne__(self, other):
        result = self.__eq__(other)
        if result is not NotImplemented:
            return not result
        return NotImplemented


class Incorrect:

    def __ne__(self, other):
        return not self.__eq__(other)


x, y = Correct(), Correct()
assert (x != y) is not (x == y)

x, y = Incorrect(), Incorrect()
assert (x != y) is not (x == y)  # AssertionError

不正确__ne__ 的实现 #2

@AaronHall 对特殊方法 __ne__ 的实现也是不正确的：

def __ne__(self, other):
    return not self == other

这个实现的问题在于它直接依赖于特殊方法 __eq__ 另一个操作数，绕过另一个操作数的特殊方法 __ne__，因为它永远不会返回值 NotImplemented （表达式 not self == other 依靠另一个操作数的特殊方法 __eq__ 并计算出值 True 或 False）。绕过方法是不正确的，因为该方法可能有副作用 就像更新对象的状态：

class Correct:

    def __init__(self):
        self.state = False

    def __ne__(self, other):
        self.state = True
        result = self.__eq__(other)
        if result is not NotImplemented:
            return not result
        return NotImplemented


class Incorrect:

    def __init__(self):
        self.state = False

    def __ne__(self, other):
        self.state = True
        return not self == other


x, y = Correct(), Correct()
assert x != y
assert x.state == y.state

x, y = Incorrect(), Incorrect()
assert x != y
assert x.state == y.state  # AssertionError

理解比较运算

在数学中，二元关系 集合X上的R是一组有序对（x，y >) X²。 R 中的语句 (x,y) 内容为“x 是 R” -与y'相关，并用xRy表示。

集合X上的二元关系R的属性：

• R是自反，对于 X 中的所有 x，xRx >。
• R是非反身（也称为严格），适用于X中的所有x，而不是xRx。
• 对于所有情况，R 是对称 X 中的 x 和 y，如果 xRy 则 yRx。
• 对于所有情况，R 是反对称 x 和 y 在 X 中，如果 xRy 和 yRx 则 x = y。
• R 对于所有人来说都是传递 X 中的 x、y 和 z，如果 xRy 和 yRz 然后xRz。
• R是connex（也称为总计），对于 X、xRy 或 xRy 中的所有 x 和 y >yRx。
• R 是等价关系 R 是自反、对称和传递的。
  例如，=。然而 ≠ 只是对称的。
• R 是一个 顺序关系 R 是自反、反对称和传递的。
  例如，≤和≥。
• R是严格顺序关系 当R 是非自反、反对称和传递时。
  例如，<和>。然而 ≠ 只是非自反的。

集合X上的两个二元关系R和S的运算：

• R 的converse 是二元关系 R^T  = {(y, x) | xRy}超过X 。
• R 的补是二元关系 ØR = {(x, y) | 不是 xRy }超过X。
• R 的联合 S 是二元关系R ∪ S = {(x,  y) | xRy 或 xSy} 超过 X。

始终有效的比较关系之间的关系：

• 2种互补关系：=和≠互为补；
• 6种逆关系：=是自身的逆，≠是自身的逆，<和>互为逆，且 ≤ 和 ≥ 互为逆；
• 2并集关系：≤是<的并集和 =， 和 ≥ 是 > 的并集和=。

仅对connex顺序关系有效的比较关系之间的关系：

• 4种互补关系：和 ≥ 互为补码，并且 >和 ≤ 互为补集。

因此，要在 Python 中正确实现比较运算符 ==、!=、<、>、< code><=、>=分别对应比较关系=、≠、<、>、≤、≥，以上数学性质和关系均应成立。

比较操作x运算符y调用其操作数之一的类的特殊比较方法__operator__：

class X:

    def __operator__(self, other):
        # implementation

因为R是自反< /em> 暗示 xRx，自反比较操作 x 运算符 y (x == y, x <= y code> 和 x >= y) 或自反特殊比较方法调用 x.__operator__(y) (x.__eq__(y),如果 x，则 x.__le__(y) 和 x.__ge__(y)) 的计算结果应为值 True和 y 相同，即如果表达式 x is y 的计算结果为 True。由于R是无反意味着不是xRx，所以无反比较操作x运算符y (x != y、x < y 和 x > y) 或非自反特殊比较方法调用 x.__operator__(y) ( x.__ne__(y)、x.__lt__(y) 和 x.__gt__(y)) 应计算为值 如果 x 和 y 相同，即表达式 x is y 计算结果为 True，则为 False >。 Python 认为比较运算符 == 和关联的特殊比较方法 __eq__ 具有自反属性，但 令人惊讶的是没有考虑比较运算符<=< /code> 和 >= 以及相关的特殊比较方法 __le__ 和 __ge__，并且 Python 认为比较运算符 < 具有非自反属性code>!= 和关联的特殊比较方法 __ne__ 但 令人惊讶的是没有考虑比较运算符<和>以及关联的特殊比较方法 __lt__ 和 __gt__。被忽略的比较运算符会引发异常 TypeError（并且关联的特殊比较方法会返回值 NotImplemented），如 Python 文档：

相等比较（== 和 !=）的默认行为基于
关于对象的身份。因此，平等比较
具有相同身份的实例导致平等，并且平等
具有不同身份的实例的比较结果
不等式。这种默认行为的动机是希望
所有对象都应该是自反的（即x is y意味着x == y）。

默认顺序比较（<、>、<= 和 >= ) 未提供；
尝试引发TypeError。这种默认行为的动机
缺乏与平等类似的不变量。 [这是不正确的，因为 <= 和 >= 是自反的，就像 == 和 < 和 > 是非自反的，就像 !=.]




类 object 提供了特殊比较方法的默认实现，这些方法由其所有子类继承，如 Python 文档：

object.__lt__(self, other)
object.__le__(自身，其他)
object.__eq__(self, other)
object.__ne__(self, other)
object.__gt__(自身，其他)
object.__ge__(self, other)

这就是所谓的“丰富比较”方法。信件往来
运算符符号和方法名称之间的关系如下：x 调用
x.__lt__(y)、x<=y 调用 x.__le__(y)、x==y > 调用x.__eq__(y)，
x!=y 调用 x.__ne__(y)，x>y 调用 x.__gt__(y) ，并且x>=y
调用 x.__ge__(y)。

丰富的比较方法可能会返回单例 NotImplemented 如果
它不实现给定参数对的操作。

[…]

这些方法没有交换参数版本（要使用
当左参数不支持操作但右参数不支持时
论证确实如此）；相反，__lt__() 和 __gt__() 是彼此的
反射，__le__() 和 __ge__() 是彼此的反射，并且
__eq__() 和 __ne__() 是它们自己的反射。如果操作数
属于不同类型，右操作数的类型是直接或
左操作数类型的间接子类，反射方法
右操作数优先，否则左操作数的方法
有优先权。不考虑虚拟子类化。

由于R = (R^T)^T，比较xRy相当于相反比较yR^Tx（在Python文档中非正式地命名为“reflected”）。因此，有两种方法可以计算比较运算 x 运算符 y 的结果：调用 x.__operator__(y) 或 y.__operatorT__(x)< /代码>。 Python 使用以下计算策略：

1. 它调用 x.__operator__(y)，除非右操作数的类是左操作数类的后代，在这种情况下，它调用 y.__operatorT__(x) （允许类覆盖其祖先的反向特殊比较方法）。
2. 如果操作数x和y不受支持（由返回值NotImplemented指示），它将调用相反的特殊比较方法作为第一个后备。
3. 如果操作数 x 和 y 不受支持（由返回值 NotImplemented 指示），则会引发异常 TypeError除了比较运算符 == 和 != 之外，它分别比较操作数 x 和 的同一性和非同一性y 作为第二个后备（利用 == 的自反性属性和 != 的非自反性属性）。
4. 它返回结果。

在 CPython 中 这是用 C 代码实现的，可以翻译成 Python 代码（== 的名称为 eq，!= 的名称为 ne >、lt 表示 <、gt 表示 >、le 表示 < code><= 和 ge（对于 >=）：

def eq(left, right):
    if type(left) != type(right) and isinstance(right, type(left)):
        result = right.__eq__(left)
        if result is NotImplemented:
            result = left.__eq__(right)
    else:
        result = left.__eq__(right)
        if result is NotImplemented:
            result = right.__eq__(left)
    if result is NotImplemented:
        result = left is right
    return result

def ne(left, right):
    if type(left) != type(right) and isinstance(right, type(left)):
        result = right.__ne__(left)
        if result is NotImplemented:
            result = left.__ne__(right)
    else:
        result = left.__ne__(right)
        if result is NotImplemented:
            result = right.__ne__(left)
    if result is NotImplemented:
        result = left is not right
    return result

def lt(left, right):
    if type(left) != type(right) and isinstance(right, type(left)):
        result = right.__gt__(left)
        if result is NotImplemented:
            result = left.__lt__(right)
    else:
        result = left.__lt__(right)
        if result is NotImplemented:
            result = right.__gt__(left)
    if result is NotImplemented:
        raise TypeError(
            f"'<' not supported between instances of '{type(left).__name__}' "
            f"and '{type(right).__name__}'"
        )
    return result

def gt(left, right):
    if type(left) != type(right) and isinstance(right, type(left)):
        result = right.__lt__(left)
        if result is NotImplemented:
            result = left.__gt__(right)
    else:
        result = left.__gt__(right)
        if result is NotImplemented:
            result = right.__lt__(left)
    if result is NotImplemented:
        raise TypeError(
            f"'>' not supported between instances of '{type(left).__name__}' "
            f"and '{type(right).__name__}'"
        )
    return result

def le(left, right):
    if type(left) != type(right) and isinstance(right, type(left)):
        result = right.__ge__(left)
        if result is NotImplemented:
            result = left.__le__(right)
    else:
        result = left.__le__(right)
        if result is NotImplemented:
            result = right.__ge__(left)
    if result is NotImplemented:
        raise TypeError(
            f"'<=' not supported between instances of '{type(left).__name__}' "
            f"and '{type(right).__name__}'"
        )
    return result

def ge(left, right):
    if type(left) != type(right) and isinstance(right, type(left)):
        result = right.__le__(left)
        if result is NotImplemented:
            result = left.__ge__(right)
    else:
        result = left.__ge__(right)
        if result is NotImplemented:
            result = right.__le__(left)
    if result is NotImplemented:
        raise TypeError(
            f"'>=' not supported between instances of '{type(left).__name__}' "
            f"and '{type(right).__name__}'"
        )
    return result

由于 R = Ø(ØR），比较xRy相当于补比较 Ø(xØRy)。 ≠ 是= 的补码，因此默认情况下，特殊方法__ne__ 是根据支持的操作数的特殊方法__eq__ 实现的，而其他特殊比较方法则独立实现默认情况下（事实上 ≤ 是 < 和 = 的并集，≥ 是 > 和 = 的并集 令人惊讶的是没有考虑，这意味着目前特殊方法 __le__ 和 < code>__ge__ 应该由用户实现），如 Python 文档：

默认情况下，__ne__() 委托给 __eq__() 并反转结果
除非它是NotImplemented。没有其他暗示
比较运算符之间的关系，例如真相
(x 并不意味着 x<=y。




在 CPython 中 这是用 C 代码实现的，可以翻译成Python代码：

def __eq__(self, other):
    return self is other or NotImplemented

def __ne__(self, other):
    result = self.__eq__(other)
    if result is not NotImplemented:
        return not result
    return NotImplemented

def __lt__(self, other):
    return NotImplemented

def __gt__(self, other):
    return NotImplemented

def __le__(self, other):
    return NotImplemented

def __ge__(self, other):
    return NotImplemented

所以默认情况下：

• 比较操作x运算符y会引发异常TypeError，比较运算符==<除外/code> 和 != 如果操作数 x 和 <，则分别返回值 True 和 False code>y 分别为相同和不同，否则值为 False 和 True；
• 特殊比较方法调用 x.__operator__(y) 返回值 NotImplemented，特殊比较方法 __eq__ 和 __ne__ 除外如果操作数 x 和 y 分别相同，则它分别返回值 True 和 False不相同，否则值为 NotImplemented。