这种行为仅适用于 python-2.x，它是丰富的比较在内部工作的一部分（至少是 CPython），但前提是两者都是新型类并且两个参数具有相同的类型！
源 C 代码读取（我突出显示了比较完成和/或跳过的部分）：
PyObject *
PyObject_RichCompare(PyObject *v, PyObject *w, int op)
{
PyObject *res;
assert(Py_LT <= op && op <= Py_GE);
if (Py_EnterRecursiveCall(" in cmp"))
return NULL;
/* If the types are equal, and not old-style instances, try to
get out cheap (don't bother with coercions etc.). */
if (v->ob_type == w->ob_type && !PyInstance_Check(v)) {
cmpfunc fcmp;
richcmpfunc frich = RICHCOMPARE(v->ob_type);
/* If the type has richcmp, try it first. try_rich_compare
tries it two-sided, which is not needed since we've a
single type only. */
if (frich != NULL) {
/****************************************************/
/* 1. This first tries v.__eq__(w) then w.__eq__(v) */
/****************************************************/
res = (*frich)(v, w, op);
if (res != Py_NotImplemented)
goto Done;
Py_DECREF(res);
}
/* No richcmp, or this particular richmp not implemented.
Try 3-way cmp. */
fcmp = v->ob_type->tp_compare;
if (fcmp != NULL)
/***********************************************/
/* Skipped because you don't implement __cmp__ */
/***********************************************/
int c = (*fcmp)(v, w);
c = adjust_tp_compare(c);
if (c == -2) {
res = NULL;
goto Done;
}
res = convert_3way_to_object(op, c);
goto Done;
}
}
/* Fast path not taken, or couldn't deliver a useful result. */
res = do_richcmp(v, w, op);
Done:
Py_LeaveRecursiveCall();
return res;
}
/* Try a genuine rich comparison, returning an object. Return:
NULL for exception;
NotImplemented if this particular rich comparison is not implemented or
undefined;
some object not equal to NotImplemented if it is implemented
(this latter object may not be a Boolean).
*/
static PyObject *
try_rich_compare(PyObject *v, PyObject *w, int op)
{
richcmpfunc f;
PyObject *res;
if (v->ob_type != w->ob_type &&
PyType_IsSubtype(w->ob_type, v->ob_type) &&
(f = RICHCOMPARE(w->ob_type)) != NULL) {
/*******************************************************************************/
/* Skipped because you don't compare unequal classes where w is a subtype of v */
/*******************************************************************************/
res = (*f)(w, v, _Py_SwappedOp[op]);
if (res != Py_NotImplemented)
return res;
Py_DECREF(res);
}
if ((f = RICHCOMPARE(v->ob_type)) != NULL) {
/*****************************************************************/
/** 2. This again tries to evaluate v.__eq__(w) then w.__eq__(v) */
/*****************************************************************/
res = (*f)(v, w, op);
if (res != Py_NotImplemented)
return res;
Py_DECREF(res);
}
if ((f = RICHCOMPARE(w->ob_type)) != NULL) {
/***********************************************************************/
/* 3. This tries the reversed comparison: w.__eq__(v) then v.__eq__(w) */
/***********************************************************************/
return (*f)(w, v, _Py_SwappedOp[op]);
}
res = Py_NotImplemented;
Py_INCREF(res);
return res;
}
有趣的部分是 cmets - 它回答了您的问题：
如果两者是相同的类型和新样式的类，它假定它可以做一个捷径：它会尝试对它们进行丰富的比较。正常和反向返回 NotImplemented 并继续。
它进入try_rich_compare函数，尝试再次比较它们，先正常然后反转。
通过测试反向操作进行最后一次尝试：现在它比较反向操作，然后再次尝试正常（反向操作的反向操作）。
（未显示）最后所有 3 种可能性都失败了，如果对象相同 a1 is a2，则完成最后一次测试，返回观察到的 False。
如果你测试a1 == a1，可以观察到最后一个测试的存在：
>>> a1 == a1
a1.__eq__(a1)
a1.__eq__(a1)
a1.__eq__(a1)
a1.__eq__(a1)
a1.__eq__(a1)
a1.__eq__(a1)
True
我不知道这种行为是否被完整记录，至少__eq__的文档中有一些提示
如果一个富比较方法没有为给定的一对参数实现操作，它可能会返回单例 NotImplemented。
和__cmp__:
如果没有定义丰富的比较（见上文），则由比较操作调用。
更多观察：
请注意，如果您定义__cmp__，它不会像__eq__ 那样尊重return NotImplemented（因为它进入了PyObject_RichCompare 中先前跳过的分支）：
class A(object):
def __init__(self, name):
self.name = name
def __str__(self):
return self.name
def __eq__(self, other):
print('{}.__eq__({})'.format(self, other))
return NotImplemented
def __cmp__(self, other):
print('{}.__cmp__({})'.format(self, other))
return NotImplemented
>>> a1, a2 = A('a1'), A('a2')
>>> a1 == a2
a1.__eq__(a2)
a2.__eq__(a1)
a1.__cmp__(a2)
a2.__cmp__(a1)
False
如果您明确地与超类和继承类进行比较，可以很容易地看到子类或相同类的行为：
>>> class A(object):
... def __init__(self, name):
... self.name = name
... def __str__(self):
... return self.name
... def __eq__(self, other):
... print('{}.__eq__({}) from A'.format(self, other))
... return NotImplemented
...
>>>
>>> class B(A):
... def __eq__(self, other):
... print('{}.__eq__({}) from B'.format(self, other))
... return NotImplemented
...
>>>
>>> a1, a2 = A('a1'), B('a2')
>>> a1 == a2
a2.__eq__(a1) from B
a1.__eq__(a2) from A
a1.__eq__(a2) from A
a2.__eq__(a1) from B
a2.__eq__(a1) from B
a1.__eq__(a2) from A
False
>>> a2 == a1
a2.__eq__(a1) from B
a1.__eq__(a2) from A
a1.__eq__(a2) from A
a2.__eq__(a1) from B
False
最后的评论：
我在gist 中添加了用于“打印”的代码，用于进行比较。如果你知道如何创建 python-c-extensions，你可以自己编译和运行代码（myrichcmp 函数需要调用两个参数来比较是否相等）。