python的a==b调用b.__eq__(a)，对于没有覆盖的子类[重复]

在 python 2.7.6 中，假设我有一个类定义__eq__和一个子类 其中：

>>> class A(object):
...     def __eq__(self,other):
...         print self.__class__,other.__class__
...         return True
... 
>>> class B(A):
...     pass
... 

现在我创建每个类的一个对象，并想要比较它们：

>>> a = A()
>>> b = B()
>>> a==b

我得到的结果：

<class '__main__.B'> <class '__main__.A'>

这表明解释器正在调用b.__eq__(a)， 代替a.__eq__(b)作为 预期的。

The 文档 https://docs.python.org/release/2.7.6/reference/datamodel.html#coercion-rules%20documentation状态（强调）：

• 对于物体x and y, first x.__op__(y)已尝试。如果未实现或返回NotImplemented, y.__rop__(x)已尝试。如果这也没有实现或返回NotImplemented, a TypeError引发异常。但看到以下异常：

• 上一项的例外情况：如果左操作数是内置类型或新式类的实例，而右操作数是该类型或类的真子类的实例并覆盖基地的__rop__() method, 右操作数的__rop__()在左操作数之前尝试方法__op__() method.

  这样做是为了让子类可以完全重写二元运算符。否则，左操作数的__op__()方法将始终接受正确的操作数：当需要给定类的实例时，该类的子类的实例始终是可接受的。

自从有了子类B不覆盖__eq__运营商，不应该a.__eq__(b)被称为而不是b.__eq__(a)?这是预期的行为还是错误？这与我阅读的文档相反：我是否误读了文档或遗漏了其他内容？

一些相关问题：

• 这个答案 https://stackoverflow.com/a/2282795/407588引用我上面引用的文档。在这种情况下，最后一个问题涉及内置类型 (1) 的对象和实例之间的比较 一个新风格的班级。在这里，我专门比较父类的实例 与一个子类的实例does not覆盖rop()其方法 父级（在本例中，__eq__既是op() and rop()).

  在这种情况下，python 实际上确实调用了b.__eq__(a)代替a.__eq__(b)首先，尽管上课B没有显式覆盖A.

看起来子类被认为“覆盖”超类行为，即使它所做的只是继承超类行为。这在__eq__案例因为__eq__是它自己的反射，但是如果使用不同的运算符，你可以更清楚地看到它，例如__lt__ and __gt__，这是彼此的反射：

class A(object):
    def __gt__(self,other):
        print "GT", self.__class__, other.__class__

    def __lt__(self,other):
        print "LT", self.__class__, other.__class__

class B(A):
    pass

Then:

>>> A() > B()
LT <class '__main__.B'> <class '__main__.A'>

注意A.__gt__没有被叫到；反而，B.__lt__被称为。

The Python 3 文档 https://docs.python.org/3/reference/datamodel.html#object.__ror__是说明性的，因为它用不同的词语陈述了规则，这些词语在技术上更准确（强调是添加的）：

如果右操作数的类型是左操作数类型的子类并且该子类provides该操作的反射方法，该方法将在左操作数的非反射方法之前被调用。这种行为允许子类覆盖其祖先的操作。

子类确实“提供”了反射方法，它只是通过继承提供它。如果您实际上删除了子类中反射的方法行为（通过返回 NotImplemented），则超类方法将被正确调用（在子类方法之后）：

class A(object):
    def __gt__(self,other):
        print "GT", self.__class__, other.__class__

    def __lt__(self,other):
        print "LT", self.__class__, other.__class__

class B(A):
    def __lt__(self, other):
        print "LT", self.__class__, other.__class__
        return NotImplemented

>>> A() > B()
LT <class '__main__.B'> <class '__main__.A'>
GT <class '__main__.A'> <class '__main__.B'>

所以基本上这似乎是一个文档错误。应该说子类反射的方法是always首先尝试（对于比较运算符），无论子类是否显式覆盖超类实现。 （不过，正如 Mark Dickinson 在评论中指出的那样，它仅适用于比较运算符，不适用于数学运算符对，例如__add__/__radd__.)

在实践中，这不太重要，因为您唯一注意到它是当子类doesn't覆盖超类。但在这种情况下，子类的行为根据定义与超类的行为相同，因此调用哪一个并不重要（除非您正在做一些危险的事情，例如从比较方法中改变对象，在这种情况下无论如何你应该保持警惕）。