薛定谔变量：如果你正在检查它的存在，__class__细胞就会神奇地出现？

Question

这里有一个惊喜：

>>> class B:
...     print(locals())
...     def foo(self):
...         print(locals())
...         print(__class__ in locals().values())
...         
{'__module__': '__main__', '__qualname__': 'B'}
>>> B().foo()
{'__class__': <class '__main__.B'>, 'self': <__main__.B object at 0x7fffe916b4a8>}
True

似乎仅仅提到__class__就被解析器显式地检查了？否则我们应该得到类似的东西

NameError: name '__class__' is not defined

事实上，如果您修改为只检查密钥，即检查'__class__' in locals()，那么我们的作用域中只有self。

这个变量是如何神奇地被注入作用域的？我的猜测是这与super有关，但我没有使用super，那么如果不需要，编译器为什么要在这里创建隐式闭包引用呢？

Answer 1

在Python 3的无参数super实现中，这是一个奇怪的交互。对方法中super的访问会触发添加一个隐藏的__class__闭包变量，该变量引用定义该方法的类。解析器还通过将__class__添加到方法的符号表来对方法中名称super的加载进行特殊处理，然后相关代码的其余部分都会查找__class__而不是super。但是，如果您尝试自己访问__class__，所有查找__class__的代码都会看到它，并认为它应该执行super处理！

如果它看到super:，它会将名称__class__添加到符号表中

case Name_kind:
    if (!symtable_add_def(st, e->v.Name.id,
                          e->v.Name.ctx == Load ? USE : DEF_LOCAL))
        VISIT_QUIT(st, 0);
    /* Special-case super: it counts as a use of __class__ */
    if (e->v.Name.ctx == Load &&
        st->st_cur->ste_type == FunctionBlock &&
        !PyUnicode_CompareWithASCIIString(e->v.Name.id, "super")) {
        if (!GET_IDENTIFIER(__class__) ||
            !symtable_add_def(st, __class__, USE))
            VISIT_QUIT(st, 0);
    }
    break;

这里是drop_class_free，它设置ste_needs_class_closure:

static int
drop_class_free(PySTEntryObject *ste, PyObject *free)
{
    int res;
    if (!GET_IDENTIFIER(__class__))
        return 0;
    res = PySet_Discard(free, __class__);
    if (res < 0)
        return 0;
    if (res)
        ste->ste_needs_class_closure = 1;
    return 1;
}

检查ste_needs_class_closure并创建隐式单元格的编译器部分：

if (u->u_ste->ste_needs_class_closure) {
    /* Cook up an implicit __class__ cell. */
    _Py_IDENTIFIER(__class__);
    PyObject *tuple, *name, *zero;
    int res;
    assert(u->u_scope_type == COMPILER_SCOPE_CLASS);
    assert(PyDict_Size(u->u_cellvars) == 0);
    name = _PyUnicode_FromId(&PyId___class__);
    if (!name) {
        compiler_unit_free(u);
        return 0;
    }
    ...

还有更多相关的代码，但包含所有代码太多了。如果你想查看更多，Python/compile.c和Python/symtable.c是可以查看的地方。

如果您尝试使用名为__class__:的变量，您可能会遇到一些奇怪的错误

class Foo:
    def f(self):
        __class__ = 3
        super()
Foo().f()

输出：

Traceback (most recent call last):
  File "./prog.py", line 6, in <module>
  File "./prog.py", line 4, in f
RuntimeError: super(): __class__ cell not found

分配给__class__意味着__class__是一个局部变量，而不是闭包变量，因此不存在super()所需的闭包单元。

def f():
    __class__ = 2
    class Foo:
        def f(self):
            print(__class__)
    Foo().f()
f()

输出：

<class '__main__.f.<locals>.Foo'>

尽管封闭作用域中有一个实际的__class__变量，但__class__的特殊大小写意味着您获得的是类，而不是封闭作用域的变量值。

Answer 2

https://docs.python.org/3/reference/datamodel.html#creating-类对象

如果类主体中的任何方法引用__class__或super，则__class__是编译器创建的隐式闭包引用。这允许super()的零参数形式根据词法作用域正确识别正在定义的类，而用于进行当前调用的类或实例则根据传递给方法的第一个参数进行识别。