原因是如果操作的 * 一 * 方不能（或不愿意）提供答案，另一方就有发言权来处理这个比较，一个常见的例子是float/int比较：

>>> 1 == 1.0
True
>>> (1).__eq__(1.0)
NotImplemented
>>> (1.0).__eq__(1)
True

对于int和float，它们都不是对方的子类，并且int对于它是否等于某个float没有任何表示，相等性比较由float类型处理。
如果您为左侧和右侧设置不同的类型，并在钩子中添加一些调试输出，则会更容易理解：

class Left:
    def __eq__(self, other):
        print("trying Left.__eq__")
        return NotImplemented

class Right:
    def __eq__(self, other):
        print("trying Right.__eq__")
        return True

演示：

>>> d1 = Left()
>>> d2 = Right()
>>> d1.__eq__(d2)
trying Left.__eq__
NotImplemented
>>> d2.__eq__(d1)
trying Right.__eq__
True
>>> d1 == d2  # Left.__eq__ "opts out" of the comparison, Python asks other side
trying Left.__eq__
trying Right.__eq__
True
>>> d2 == d1  # Right.__eq__ returns a result first, Left.__eq__ isn't considered
trying Right.__eq__
True

左边的type(d1).__eq__通过返回NotImplemented选择退出，这给了右边一个“第二次机会”来处理这个操作，如果左边返回的是False而不是NotImplemented，Python根本不会尝试右边，d1 == d2的结果将是False，如果两边都返回NotImplemented，就像在Dummy示例中一样，除非对象完全相同（即相同的示例），否则它们将被视为不相等。

这里的文档不是很清楚，肯定需要改进。
当一个Python的“内部”方法返回NotImplemented时，它通常意味着“找一些其他的方法来做这个操作”。当它找不到“一些其他的方法......”时，Python会做什么取决于操作，并且没有像它应该做的那样被很好地记录下来。因此，例如，如果x.__lt__(y)返回NotImplemented，Python可能会尝试调用y.__gt__(x)。
在==的情况下，如果x.__eq__(y)和y.__eq__(x)都返回NotImplemented，Python返回False，这应该被更好地记录下来。

如果左操作数未实现.__eq__()，则==测试右操作数.__eq__()

如果左操作数.__eq__()未实现.__eq__()，则由==测试右操作数.__eq__();如果两者都返回NotImplemented，则==返回false。
您可以通过更改类来查看此行为：

class Dummy():
    def __eq__(self, o):
        print(f'{id(self)} eq')
        return NotImplemented

d1 = Dummy()
d2 = Dummy()
print(d1 == d2)
# 2180936917136 eq
# 2180936917200 eq
# False

这是操作符的常见行为，Python测试左操作数是否有实现，如果没有，Python调用右操作数的相同或反射（例如，如果x.__lt__(y)没有实现，则调用y.__gt__(x)）操作符。

class Dummy:
    def __eq__(self, o):
        print(f"{id(self)} eq")
        return NotImplemented

    def __lt__(self, o):
        """reflexion of gt"""
        print(f"{id(self)} lt")
        return NotImplemented

    def __gt__(self, o):
        """reflexion of lt"""
        print(f"{id(self)} gt")
        return False

    def __le__(self, o):
        """reflexion of ge"""
        print(f"{id(self)} le")
        return NotImplemented

    def __ge__(self, o):
        """reflexion of le"""
        print(f"{id(self)} ge")
        return False


d1 = Dummy()
d2 = Dummy()

print(d1 == d2)
# 2480053379984 eq
# 2480053380688 eq
# False

print(d1 < d2)
# 2480053379984 lt
# 2480053380688 gt
# False

print(d1 <= d2)
# 2480053379984 le
# 2480053380688 ge
# False

**！**右前左例外：

如果操作数属于不同类型，并且右操作数的类型是左操作数类型的直接或间接子类，则右操作数的反射方法具有优先级，否则左操作数的方法具有优先级。