《深度剖析CPython解释器》33. 为什么 obj == obj 为 False、[obj] == [obj] 为 True

2021/8/21 14:06:04

本文主要是介绍《深度剖析CPython解释器》33. 为什么 obj == obj 为 False、[obj] == [obj] 为 True,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

楔子

今天同事在用 pandas 做数据处理的时候,不小心被 nan 坑了一下,他当时被坑的原因类似下面:

import numpy as np

print(np.nan == np.nan)  # False
print([np.nan] == [np.nan])  # True

为了严谨,我们再举个栗子:

class A:

    def __eq__(self, other):
        return False


a1 = A()
a2 = A()

print(a1 == a1, a2 == a2)  # False False
print([a1, a2] == [a1, a2])  # True

为什么会出现这个结果呢?我们知道两个列表(元组也是同理)如果相等,那么首先列表里面的元素个数要相同、并且相同索引对应的元素也要相等。但问题是这里的 a1 不等于 a1、a2 也不等于 a2,那为啥 [a1, a2] 和 [a1, a2] 就相等了呢?

其实原因很好想,那就是 Python 解释器在比较两个列表中的元素的时候,会先比较它们的引用的对象的地址是否相等,也就是看它们是否引用了同一个对象,如果是同一个对象,那么直接得到 True,然后比较下一个,如果不是同一个对象,那么再比较对应的值是否相同。所以这里 a1 == a1 明明返回 False,但是放在列表中就变成了 True,原因就在于它们引用的是同一个对象。

那么下面就来从解释器源代码的角度来验证这一结论(版本为 3.9.0),其实后续涉及到的内容在之前就已经说过了,只不过因为比较简单就一笔带过了,所以这次就针对这个例子专门分析一下。

Python 的列表之间是如何比较的

要想知道底层是如何比较的,那么最好的办法就是先看一下字节码。

import dis

code = "[] == []"
dis.dis(compile(code, "<file>", "exec"))
"""
  1           0 BUILD_LIST               0
              2 BUILD_LIST               0
              4 COMPARE_OP               2 (==)
              6 POP_TOP
              8 LOAD_CONST               0 (None)
             10 RETURN_VALUE
"""

第一列:表示源代码的行号,我们这里只有一行代码。

第二列:表示指令的偏移量,每一条指令都占两个字节,第一个字节存放指令序列本身,第二个字节存放指令所需要的参数。所以指令从上到下的偏移量是 0 2 4 6 8 ......。

第三列:表示指令序列,在 C 中就是一个宏,会被替换为一个整数。Python 底层总共定义 120 多个指令序列,可以在 Include/opcode.h 头文件中查看。

第四列:表示指令参数。

所以开头的两个 BUILD_LIST 表示构建列表,后面的指令参数表示元素个数,因为是空列表,所以为 0。两个列表构建完毕显然就要进行比较了,因此指令序列是 COMPARE_OP,而后面的指令参数是 2,代表啥含义呢?

COMPARE_OP 表示比较,但是比较也分为:小于、小于等于、等于、不等于、大于、大于等于,那么到底是哪一种呢?显然要通过指零参数给出,而这里指定的是等于,所以指令参数是 2。至于指令参数后面的 (==) 则是 dis 模块帮你添加的,告诉你该指令参数的含义,方便理解。

因此我们的关注点就在 COMPARE_OP 这条指令序列对应的实现当中,而 Python 底层的指令序列对应的实现都位于 Python/ceval.c 中,在里面有一个 _PyEval_EvalFrameDefault 函数,以栈帧(PyFrameObject)为单位。该函数里面有一个无限的 for 循环,会不断地循环取出字节码中每一条指令序列和指令参数进行执行,直到将该栈帧内部的字节码全部执行完毕,然后退出循环。因此执行逻辑也是在这个 for 循环里面的,没错,for 循环里面有一个巨型的 switch,每一个指令序列都对应一个 case 语句,所以这个 switch 里面有 120 多个 case 语句,然后不同的指令序列走不同的 case,因此 _PyEval_EvalFrameDefault 这个函数非常长,总共多达 3000 行。

那么下面我们就来看看 COMPARE_OP 对应的指令实现,不过这里多提一句:不光是列表,其它对象进行比较的时候对应的指令序列也是 COMPARE_OP。

我们来分析一下:

case TARGET(COMPARE_OP): {
    // 这里的 oparg 表示的就是指令参数,显然它和指令序列(opcode)在进入 switch 语句之前就已经被获取
    // 然后这里断言 oparg 必须要小于等于 Py_GE,因为比较操作符中最大的就是 Py_GE,而我们这里是 ==,所以 oparg 的值等于 2
    assert(oparg <= Py_GE);
    // BUILD_LIST 构建的两个列表(指针)会被压入运行时栈,然后这里再将其获取
    // 当然这里只是以列表为例,但我们说进行比较的不一定是列表,可以是任意对象
    // 因此 right 就是比较操作符(我们这里是 ==)右边的变量,left 就是左边的变量
    PyObject *right = POP();  // 元素会从栈中弹出
    PyObject *left = TOP();   // 注意这里是 TOP(),不是 POP(),所以操作符左边的变量还留在栈里面
    // 调用 PyObject_RichCompare,传入 left、right、oparg 进行调用,得到返回结果 res
    // 显然具体的比较逻辑就在 PyObject_RichCompare 里面
    PyObject *res = PyObject_RichCompare(left, right, oparg);
    // 用 res 将栈顶的元素替换掉,所以操作符左边的变量不需要从栈里面弹出,直接将结果与之替换即可
    // 最后再返回
    SET_TOP(res);
    Py_DECREF(left);
    Py_DECREF(right);
    if (res == NULL)
        goto error;
    PREDICT(POP_JUMP_IF_FALSE);
    PREDICT(POP_JUMP_IF_TRUE);
    DISPATCH();
}

这里涉及到了运行时栈,具体细节就不再赘述了,总之运行时栈是必不可少的,因为 Python 的指令只能有一个指令参数,但是 PyObject_RichCompare 函数需要三个参数,因此其它的参数只能通过运行时栈给出。

我们这里只需要知道,Python 中的比较,在底层会调用 PyObject_RichCompare 函数即可:

a == b  # PyObject_RichCompare(a, b, Py_EQ)
a >= b  # PyObject_RichCompare(a, b, Py_GE)
a != b  # PyObject_RichCompare(a, b, Py_NE)
...

下面来看看 PyObject_RichCompare 里面的逻辑,该函数藏身于 Objects/object.c 中。

PyObject *
PyObject_RichCompare(PyObject *v, PyObject *w, int op)
{   // 参数 v 就是上面的 left、w 就是 right、op 就是 oparg
    
    // 获取线程状态对象,这里不需要关注
    PyThreadState *tstate = _PyThreadState_GET();
    // 0 <= op <= 5
    assert(Py_LT <= op && op <= Py_GE);
    // 如果有一方为 NULL,则调用失败
    if (v == NULL || w == NULL) {
        if (!_PyErr_Occurred(tstate)) {
            PyErr_BadInternalCall();
        }
        return NULL;
    }
    // 这里的 _Py_EnterRecursiveCall 和结尾的 _Py_LeaveRecursiveCall 会成对出现,主要是用于递归比较的,举个栗子
    /*
        a = [None]
        a.append(a)
        print(a)  # [None, [...]]
        print(a[1][1][1][1][1][1][1][1][1][1])  # [None, [...]]
        print(a[1][1][1][1][1][1][1][1][1][0])  # None
        print(a == a)  # True
    */
    // 显然 a 后面无论接多少个 [1] 都是合法的,因此就意味着要无限地比较下去,而 Python 显然不会允许这种情况发生
    // 因此这一步就是为了应对这种情况出现
    if (_Py_EnterRecursiveCall(tstate, " in comparison")) {
        return NULL;
    }
    // 调用 do_richcompare,得到返回结果
    PyObject *res = do_richcompare(tstate, v, w, op);
    _Py_LeaveRecursiveCall(tstate);
    return res;
}

可以看到 PyObject_RichCompare 里面也不是真正负责执行比较逻辑的,该函数相当于做了一些检测,而比较的结果是调用 do_richcompare 得到的,显然我们需要到这个函数中查看,该函数同样位于 Objects/object.c 中。

static PyObject *
do_richcompare(PyThreadState *tstate, PyObject *v, PyObject *w, int op)
{   
    // richcmpfunc f 相当于声明一个比较函数,因为 Python 将每个比较操作都抽象成了一个魔法方法,比如:__ge__、__eq__ 等等
    // 虽然在 Python 中不同的比较操作对应不同的魔法方法,但底层对应的都是 PyTypeObject 的 tp_richcompare 成员
    // 该成员负责所有的比较操作,至于到底是哪一种,则由参数来控制
    /* 因此我们看到具体的比较逻辑,还是定义在对应的类对象中
       比如:
           list 对象的比较逻辑定义在 PyList_Type -> tp_richcompare 中
           tuple 对象的比较逻辑定义在 PyTuple_Type -> tp_richcompare 中
           Dict 对象的比较逻辑定义在 PyDict_Type -> tp_richcompare 中
           Set 对象的比较逻辑定义在 PySet_Type -> tp_richcompare 中
    */
    richcmpfunc f;
    // 用于存储比较之后的结果
    PyObject *res;
    int checked_reverse_op = 0;
    
    /* Py_TYPE(obj) 表示获取 obj 的类型;
       Py_IS_TYPE(obj, cls) 则是判断 obj 的类型是否为 cls
       PyType_IsSubtype(cls1, cls2) 负责判断 cls1 是否是 cls2 的子类
       所以下面 if 语句的含义就是:当 v 和 w 的类型不同、并且 w 的类型是 v 的类型的子类、
       并且 w 的类型对象内部的 tp_richcompare 成员不为 NULL,然后走这个分支。
       
       直接说的话,可能不是很好解释这个 if 语句到底在做什么,我们可以用一个 Python 测试用例解释一下:
       class A:
           def __eq__(self, other):
               return "A"
       class B(A):
           def __eq__(self, other):
               return "B"
       print(A() == B())  # B
       
       我们知道默认情况下,如果操作符左边的两个对象之间没有任何关系,那么比较的时候优先会找操作符左边的对象的魔法方法
       所以如果 B 不继承 A,也就是 A 和 B 自己没有任何关系,那么按照优先级,A() == B() 就会返回字符串 "A"
       但如果操作符 "右侧的对象的类对象" 是 "左侧的对象的类对象" 的子类,那么这个规则就会被打破
       解释器就会执行操作符右侧的对象的魔法方法,所以这里 B 继承 A,A() == B() 返回了字符串 "B"
       这个 if 语句就是来干这件事的,因此这里的 f 等于 Py_TYPE(w)->tp_richcompare
       
    */
    if (!Py_IS_TYPE(v, Py_TYPE(w)) &&
        PyType_IsSubtype(Py_TYPE(w), Py_TYPE(v)) &&
        (f = Py_TYPE(w)->tp_richcompare) != NULL) {
        checked_reverse_op = 1;
        // 会取出 w 对应的 tp_richcompare,将参数传递进去,进行调用
        // 其中 _Py_SwappedOp[op] 是负责将 op 以宏的形式传递,比如 op 是 2,那么 _Py_SwappedOp[op] 就是 Py_EQ,不过结果也是 2
        // 调用之后将结果保存起来
        res = (*f)(w, v, _Py_SwappedOp[op]);
        /* 然后这里对 res 有一个判断,它是做什么的呢?
        首先我们上面说了,==、!=、>=、<=、<、> 在 Python 中对应不同的魔法方法
        但在底层解释器的角度而言,对应的都是类型对象的 tp_richcompare
        至于底层执行这个函数的时候,到底执行哪一个比较操作,则是由参数控制
        比如我们上面实现了 __eq__,意味着 tp_richcompare 不为 NULL,那么进行比较的时候毫无疑问肯定会走这个分支
        但如果我们执行的不是 A() == B(),而是 A() != B(),那么这里的 res 就返回 Py_NotImplemented
        因为 A 和 B 内部都没有定义 __ne__,因此 tp_richcompare 内部也就不包含处理比较操作为 != 时的逻辑
        所以这个分支一定会走,但返回的 res 会等于 Py_NotImplemented
        */
        if (res != Py_NotImplemented)
            // 返回了 res,并且不等于 Py_NotImplemented,才会返回
            return res;
        Py_DECREF(res);
    }
    
    // 如果不是上面那种情况,那么就看 v 是否定义了相应的魔法方法,也就是 Py_TYPE(v) 的 tp_richcompare 成员是否不为 NULL
    // 如果有的话就取出,然后传递参数进行调用,其它逻辑类似
    if ((f = Py_TYPE(v)->tp_richcompare) != NULL) {
        res = (*f)(v, w, op);
        if (res != Py_NotImplemented)
            return res;
        Py_DECREF(res);
    }
    // 如果 Py_TYPE(v) 的 tp_richcompare 成员为 NULL,或者 res 为 Py_NotImplemented
    // 就意味着在 Python 的层面,操作符左边的对象内部没有定义该操作符对应的魔法方法(可能定义了别的)
    // 那么此时会去看操作符右侧的对象内部是否有相应的魔法方法,所以这里会看 Py_TYPE(w) 的 tp_richcompare 是否不为 NULL
    if (!checked_reverse_op && (f = Py_TYPE(w)->tp_richcompare) != NULL) {
        res = (*f)(w, v, _Py_SwappedOp[op]);
        if (res != Py_NotImplemented)
            return res;
        Py_DECREF(res);
    }
    
    /* 走到这里说明,要么上面的三个 if 分支一个都没有通过,即操作两边的对象的内部都没有定义任何关于比较操作的魔法方法
    或者通过了,但返回的 res 等于 Py_NotImplemented,定义了比较操作的魔法方法,
    但是当前执行的操作符对应的魔法方法没有实现 */
    // 不过对于 Python 而言,== 和 != 是永远不会报错的,所以还要检测操作符是不是 == 或 !=
    switch (op) {
    /* 尽管指定的操作符没有实现,但如果操作符是 == 或者 !=,也就是 op 为 Py_EQ 或者 Py_NE 时
    那么就比较两个对象的内存地址,比如 class A: pass
    A 里面没有实现任何的魔法方法,但 a = A(); a == a 就是 True,因为对象的内存地址是一样的
    这里说明一下,Python 中的变量在 C 的层面就是一个泛型指针(PyObject *),它存储的不是对象(PyObject),而是对象的地址
    变量在传递的时候会传递地址,但是在操作一个变量时会自动操作变量指向的内存
    所以在判断两个变量是否指向同一个对象的时候(相当于 is),在 C 的层面只需要比较两个指针是否相等即可
    而在比较两个变量指向的对象是否相等(也就是 == ),那么会将两个变量指向的对象所维护的值取出来,调用 PyObject_RichCompare 进行比较
    */
    case Py_EQ:
        // 这里的 v 和 w 显然就相当于 Python 中的变量,就是一个指针
        // 因此判断两个变量是否指向同一个对象,直接判断这两个指针存的地址是否相等即可
        res = (v == w) ? Py_True : Py_False;
        break;
    case Py_NE:
        // 同理
        res = (v != w) ? Py_True : Py_False;
        break;
    // 如果比较操作符不是 == 或者 !=,那么就不好意思了,这两个实例之间不允许执行当前的比较操作
    default:
        _PyErr_Format(tstate, PyExc_TypeError,
                      "'%s' not supported between instances of '%.100s' and '%.100s'",
                      opstrings[op],
                      Py_TYPE(v)->tp_name,
                      Py_TYPE(w)->tp_name);
        return NULL;
    }
    // 增加引用计数,返回
    Py_INCREF(res);
    return res;
}

以上就是 do_richcompare 的逻辑,它里面干了哪些事情呢?我们说里面三个 if 语句,主要用于确定到底该执行谁的魔法方法,比如 A 和 B 的实例进行比较:

  • 1. 如果 A 和 B 是不同的类、并且 B 还是 A 的子类,那么 "A() 操作符 B()" 会优先去 B 中查找操作符对应的魔法方法
  • 2. 否则的话,会按照优先级,先找 A(操作符左边)的魔法方法
  • 3. 如果左边没有,那么就最后再找右边

如果成功执行则直接返回,否则的话再对操作符进行判定,如果是 == 或者 != ,那么就比较两个对象是否是同一个对象。

虽然花了一定的笔墨解释完了比较操作在底层的逻辑,但是我们上面的问题本质上依旧没有得到解决,我们还是不知道列表是如何比较的。因为很明显,比较的核心在于类型对象的 tp_richcompare 中,它返回的结果就是这里的 res,所以如果我们想知道列表是如何比较的,那么就去 PyList_Type 的 tp_richcompare 成员中查看即可。

而 PyList_Type 的 tp_richcompare 成员对应的是 list_richcompare 函数,我们来看一下,其藏身于 Objects/listobject.c 中。

static PyObject *
list_richcompare(PyObject *v, PyObject *w, int op)
{    
    PyListObject *vl, *wl;
    Py_ssize_t i;
    // v 和 w 一定是 PyListObject *
    if (!PyList_Check(v) || !PyList_Check(w))
        Py_RETURN_NOTIMPLEMENTED;
    // 将 PyObject * 转成 PyListObject *
    vl = (PyListObject *)v;
    wl = (PyListObject *)w;
    
    // 快分支:如果两个列表连长度都不相等,那么当比较操作符是 == 或 != 的时候可以直接出结果
    if (Py_SIZE(vl) != Py_SIZE(wl) && (op == Py_EQ || op == Py_NE)) {
        // op 是 ==,返回 False
        // op 是 !=,返回 True
        if (op == Py_EQ)
            Py_RETURN_FALSE;
        else
            Py_RETURN_TRUE;
    }

    // 当列表长度相等,或者操作不是 == 或者 !=,那么就需要将两个列表中的元素进行逐个比较了
    for (i = 0; i < Py_SIZE(vl) && i < Py_SIZE(wl); i++) {
        PyObject *vitem = vl->ob_item[i];
        PyObject *witem = wl->ob_item[i];
        /*我们说 Python 中变量本质上是一个指针,当然不光是变量,列表、元组、字典等容器里面容纳的也是指针
        如果 vitem == witem,说明这两个列表存储的是同一个对象的指针(在 Python 里面也可以说引用)
        所以直接就 continue 了,说明当前位置的两个元素是相等的
        因此我们就解释了在最开始的问题中,为什么 a1 != a1、np.nan != np.nan,但 [a1] == [a1] 和 [np.nan] == [np.nan] 却都是成立的
        再比如 None > None 会报错,但是 [None] > [None] 却不会,原因就在于 None 是单例的,地址相同
        而地址相同,那么就不比了(不管这两个对象能不能比),而是直接看下一个元素 */
        if (vitem == witem) {
            continue;
        }
        
        // 增加引用计数
        Py_INCREF(vitem);
        Py_INCREF(witem);
        /*当不是同一个对象时,那就比较对象维护的值是否相同,这里又出现了一个 PyObject_RichCompareBool
        它在底层会调用之前说的 PyObject_RichCompare,只不过在调用之前会先检测对象的地址是否相同
        如果是同一个对象,并且操作符是 ==、!=,那么会直接根据对象的地址判断
        如果不是同一个对象,或者操作符不是 == 或者 !=,再调用 PyObject_RichCompare 比较对象维护的值之间的关系,
        此外该函数返回的是整型,为真返回 1、为假返回 0,报错了返回 -1 */
        int k = PyObject_RichCompareBool(vitem, witem, Py_EQ);
        Py_DECREF(vitem);
        Py_DECREF(witem);
        if (k < 0)
            return NULL;
        // 为假直接 break,否则继续下一轮循环
        if (!k)
            break;
    }
    
    // 两个列表如果长度不相等,那么不断遍历的话,肯定有一方先结束
    // 下面逻辑就是处理长度不相等的情况,比较简单,可以自己看一下
    if (i >= Py_SIZE(vl) || i >= Py_SIZE(wl)) {
        /* No more items to compare -- compare sizes */
        Py_RETURN_RICHCOMPARE(Py_SIZE(vl), Py_SIZE(wl), op);
    }

    /* We have an item that differs -- shortcuts for EQ/NE */
    if (op == Py_EQ) {
        Py_RETURN_FALSE;
    }
    if (op == Py_NE) {
        Py_RETURN_TRUE;
    }

    /* Compare the final item again using the proper operator */
    return PyObject_RichCompare(vl->ob_item[i], wl->ob_item[i], op);
}

因此到这里我们才算真正解释了最开始的问题,在调用 PyObject_RichCompare 进行比较的时候,a1 == a1 会走内部的 __eq__,而在里面返回的 False。而 [a1] == [a1] 会走列表的 __eq__,而里面在比较元素的时候会先比较地址是否一样,如果一样直接就过了,根本不会走 type(a1) 里面的 __eq__。

Python 中的 in 也是同理,我们知道 a in b 等价于 b.__contains__(a),逻辑就是不断地对 b 进行迭代,将得到的元素依次和 a 进行比较,如果相等则直接返回 True;如果迭代结束时一直没有找到和 a 相等的元素,那么返回 False。所以逻辑很简单,但我想说的是,这里比较相等的逻辑也会先比较对象的地址是否相同,如果地址相同直接为 True,当地址不同时,才会比较值是否一致。而从底层来看的话,这里的比较会调用 PyObject_RichCompareBool,而我们知道在这个函数里面会先比较地址是否一样,地址不一样再比较维护的值是否一样(调用对应的 __eq__)。

class A:

    def __eq__(self, other):
        return False


a = A()
# 底层调用 PyObject_RichCompare,然后调用 __eq__
print(a == a)  # False
# 底层会调用 PyObject_RichCompareBool,会先判断两者是不是同一个对象
print(a in (a,))  # True
print(a in [a])  # True

以上就是由 nan 引发的一些思考,当然还是比较简单的,因为是一些之前说过的内容。



这篇关于《深度剖析CPython解释器》33. 为什么 obj == obj 为 False、[obj] == [obj] 为 True的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!


扫一扫关注最新编程教程