Question

这里有一个惊喜：

celery -A django_project worker --queue high

解析器似乎只是提到了>>> 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，那么为什么编译器在不需要时会在这里创建一个隐式闭包引用呢？

Answer 1

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

Here's where it adds the name __class__ to the symbol table if it sees 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并创建隐式单元格的compiler section：

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-the-class-object

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

薛定谔的变量：如果你正在检查它的存在，那么class单元格会神奇地出现？

2 个答案:

薛定谔的变量：如果你正在检查它的存在，那么__class__单元格会神奇地出现？

2 个答案:

薛定谔的变量：如果你正在检查它的存在，那么class单元格会神奇地出现？