在 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) 预计。

documentation州(强调):

• For objects x and y, first x.__op__(y) is tried. If this is not implemented or returns NotImplemented, y.__rop__(x) is tried. If this is also not implemented or returns NotImplemented, a TypeError exception is raised. But see the following exception:

• Exception to the previous item: if the left operand is an instance of a built-in type or a new-style class, and the right operand is an instance of a proper subclass of that type or class and overrides the base’s __rop__() method, the right operand’s __rop__() method is tried before the left operand’s __op__() method.

  This is done so that a subclass can completely override binary operators. Otherwise, the left operand’s __op__() method would always accept the right operand: when an instance of a given class is expected, an instance of a subclass of that class is always acceptable.

由于子类 B 没有覆盖 __eq__ 运算符，所以不应该 a.__eq__(b) 被调用而不是 b.__eq__(a)? 这是预期的行为，还是错误？这与我阅读的文档相反:我是误读了文档还是遗漏了其他内容？

一些相关问题:

• This answer引用我上面引用的文档。在那种情况下，最后一个问题涉及内置类型 (1) 的对象和实例之间的比较 一个新的风格类。在这里，我专门比较一个父类的实例 带有一个子类的实例，该实例不覆盖其 rop() 方法 父级(在这种情况下，__eq__ 既是 op() 又是 rop())。

  在这种情况下，python 实际上确实首先调用 b.__eq__(a) 而不是 a.__eq__(b)，即使类 B 没有显式覆盖 A。

最佳答案

似乎子类被认为“覆盖”了父类(super class)的行为，即使它所做的只是继承父类(super class)的行为。这在 __eq__ 的情况下是很难看出来的，因为 __eq__ 是它自己的反射，但是如果你使用不同的操作符，例如 __lt__ 和 __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

然后:

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

注意 A.__gt__ 没有被调用；而是调用了 B.__lt__。

Python 3 documentation是说明性的，因为它用不同的词来说明规则，这些词在技术上更准确(强调):

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.

子类确实“提供”了反射方法，它只是通过继承提供它。如果您实际上删除了子类中的反射方法行为(通过返回 NotImplemented)，则正确调用了父类(super class)方法(在子类之后):

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'>

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

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

关于对于没有覆盖的子类，python 的 a==b 调用 b.__eq__(a)，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/24919375/