__le__、__ge__ 的 python 错误？

Question

下面的代码是我还是python搞混了？我希望 __le__由 a <= ab 调用, 不是 __ge__ :

#!/usr/bin/env python2

class B(object):
    def __ge__(self, other):
        print("__ge__ unexpectedly called")

class A(object):
    def __le__(self, other):
        print("__le__ called")

class AB(A, B):
    pass

a = A()
ab = AB()

a <= ab # --> __ge__ unexpectedly called
ab <= a # --> __le__ called

我在 python 2.7、3.2 和 pypy 1.9 中得到了相同的行为。

我该怎么做才能得到 __le__调用而不是 __ge__ ??

Answer 1

简短的回答是他们想要允许 AB覆盖 A 中的行为. Python 无法调用 AB.__lt__(a, ab) ，因为 a可能不是有效的 self对于 AB方法，因此它调用 AB.__gt__(ab, a) , 这是有效的。

长答案有点复杂。

根据 rich comparison operators 的文档:

There are no swapped-argument versions of these methods (to be used when the left argument does not support the operation but the right argument does); rather, __lt__() and __gt__() are each other’s reflection, __le__() and __ge__() are each other’s reflection, and __eq__() and __ne__() are their own reflection.

换句话说，x <= y会调用y.__ge__(x)在完全相同的情况下 x+y会调用y.__radd__(x) .比较:

>>> class X(object):
...     def __add__(self, other):
...         print('X.add')
>>> class Y(object):
...     def __radd__(self, other):
...         print('Y.radd')
>>> class XY(X, Y):
...     pass
>>> x, xy = X(), XY()
>>> x + xy
Y.radd

根据 reflected operators 的文档:

These methods are called to implement the binary arithmetic operations… with reflected (swapped) operands. These functions are only called if the left operand does not support the corresponding operation and the operands are of different types…

Note: If the right operand’s type is a subclass of the left operand’s type and that subclass provides the reflected method for the operation, this method will be called before the left operand’s non-reflected method. This behavior allows subclasses to override their ancestors’ operations.

所以，因为 XY是 X 的子类, XY.__radd__优先于 X.__add__ .同样，因为 AB是 A 的子类, AB.__ge__优先于 A.__le__ .

这可能应该更好地记录下来。要弄清楚，你必须忽略括号“当左参数不支持操作但右参数支持时使用”，猜测你需要查找正常的交换运算符(没有链接，甚至提到，这里)，然后忽略“这些函数仅在左操作数不支持相应操作时调用”的措辞，并查看“注意”，这与上面的内容相矛盾......还要注意文档明确地说，“比较运算符之间没有隐含的关系”，只有在描述交换案例之前的一段，暗示了这种关系……

最后，这个案例看起来很奇怪，因为 AB , 而不是覆盖 __ge__本身，只是继承自 B , 它对 A 一无所知并且与之无关。大概是B不打算让它的子类覆盖 A的行为。但是如果B旨在用作 A 的混音-派生类，也许它会恰好打算进行这样的覆盖。无论如何，该规则可能已经足够复杂，无需深入了解每个方法在 MRO 中的来源。无论推理如何，__ge__ 在哪里来自无关紧要；如果它存在于子类中，它就会被调用。

对于你添加的最后一个问题，“我能做些什么来让 __le__ 被调用而不是 __ge__ ？？”......好吧，你真的不能，就像你可以得到 X.__add__ 一样调用而不是 XY.__radd__ .当然你总是可以实现 AB.__ge__ (或 XY.__radd__ )调用 A.__le__ (或 X.__add__ )，但可能更容易实现 AB.__ge__以这样一种方式，它与 A 一起工作首先作为它的另一个论点。或者，您可以删除继承并找到一些其他方式来建模您正在建模的任何方式。或者您可以显式调用 a.__le__(ab)而不是 a<=ab .但除此之外，如果您以利用“无隐含关系”的方式设计您的类来做一些奇怪的事情，那么您将被文档误导，并且将不得不以某种方式重新设计它们。