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

问题描述：

这里有一个惊喜：

>>> 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，那么如果不需要，为什么编译器会在这里创建一个隐式闭包引用呢？

解决方案 1：

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

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

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__意味着您获得的是类而不是封闭范围的变量值。

解决方案 2：

https://docs.python.org/3/reference/datamodel.html#creating-the-class-object

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