Python 源码分析之函数机制_systemerror: bad call flags in _pycfunction_fastca

作者：我家小花儿 | 2024-03-06 13:41:43

踩

systemerror: bad call flags in _pycfunction_fastcallkeywords. meth_oldargs i

在 python 中函数也是一个对象

typedef struct {
    PyObject_HEAD
    PyObject *func_code;    /*  函数编译之后的 PyCodeObject, the __code__ attribute */
    PyObject *func_globals; /* A dictionary (other mappings won't do) */
    PyObject *func_defaults;    /* NULL or a tuple */
    PyObject *func_kwdefaults;  /* NULL or a dict */
    PyObject *func_closure; /* NULL or a tuple of cell objects */
    PyObject *func_doc;     /* The __doc__ attribute, 函数编译之后，代码段的第一个常量  */
    PyObject *func_name;    /* The __name__ attribute, a string object */
    PyObject *func_dict;    /* The __dict__ attribute, a dict or NULL */
    PyObject *func_weakreflist; /* List of weak references */
    PyObject *func_module;  /* The __module__ attribute, can be anything */
    PyObject *func_annotations; /* Annotations, a dict or NULL */
    PyObject *func_qualname;    /* The qualified name */

    /* Invariant:
     *     func_closure contains the bindings for func_code->co_freevars, so
     *     PyTuple_Size(func_closure) == PyCode_GetNumFree(func_code)
     *     (func_closure may be NULL if PyCode_GetNumFree(func_code) == 0).
     */
} PyFunctionObject;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

PyCodeObject 是一个静态代码块的描述，说静态是应该在编译的时候就可以知道该
代码块有哪些内容。比如常量表，符号表，局部变量等等，我们一般都针对的是
PyCodeObject。

而 PyFunctionObject 是动态的，这个对象是定义 def 的函数之后，每个一个函数
都会对应一个 PyFunctionObject，其中 func_code 保存的就是该函数的代码相关
部分，除此之外，还有 globals, default 等等，一般是动态决定的。还要需要
注意的是，对于一个函数 f，在运行过程中，可能在多处调用，就会创建多个
PyFunctionObject 对象，而每个对象的 func_code 都指向同一 PyCodeObject。

所以，对于一个 PyFunctionObject 它既包含静态部分，如 func_code，也包含
动态部分，比如函数参数。

#!/usr/bin/env python
# encoding: utf-8

def test():
    a = 1

test()1
2
3
4
5
6
7

编译之后

magic b'330d0d0a'
moddate b'c075345b' (Thu Jun 28 13:44:32 2018)
files sz 604
code
   argcount 0
   nlocals 0
   stacksize 2
   flags 0040
   code b'6400640184005a0065008300010064025300'
  4           0 LOAD_CONST               0 (<code object test at 0x10ca48ae0, file "/tmp/a.py", line 4>)
              2 LOAD_CONST               1 ('test')
              4 MAKE_FUNCTION            0           //创建 PyFunctionObject 并入栈
              6 STORE_NAME               0 (test)    //将 PyFunctionObject 保存到 test

  7           8 LOAD_NAME                0 (test)
             10 CALL_FUNCTION            0
             12 POP_TOP
             14 LOAD_CONST               2 (None)
             16 RETURN_VALUE
   consts
      code
         argcount 0
         nlocals 1
         stacksize 1
         flags 0043
         code b'64017d0064005300'
  5           0 LOAD_CONST               1 (1)
              2 STORE_FAST               0 (a)
              4 LOAD_CONST               0 (None)
              6 RETURN_VALUE
         consts
            None
            1
         names ()
         varnames ('a',)
         freevars ()
         cellvars ()
         filename '/tmp/a.py'
         name 'test'
         firstlineno 4
         lnotab b'0001'
      'test'
      None
   names ('test',)
   varnames ()
   freevars ()
   cellvars ()
   filename '/tmp/a.py'
   name '<module>'
   firstlineno 4
   lnotab b'0803'
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

由编译可知产生两个代码段，一个是 a.py 对应的 PyCodeObject，一个是函数 test 对应的 PyCodeObject。而 test 对应的 PyCodeObject 是一个常量。

PyObject *
PyFunction_NewWithQualName(PyObject *code, PyObject *globals, PyObject *qualname)
{
    PyFunctionObject *op;
    PyObject *doc, *consts, *module;
    static PyObject *__name__ = NULL;

    if (__name__ == NULL) {
        __name__ = PyUnicode_InternFromString("__name__");
        if (__name__ == NULL)
            return NULL;
    }

    op = PyObject_GC_New(PyFunctionObject, &PyFunction_Type);
    if (op == NULL)
        return NULL;

    op->func_weakreflist = NULL;
    Py_INCREF(code);
    op->func_code = code;
    Py_INCREF(globals);
    op->func_globals = globals;
    op->func_name = ((PyCodeObject *)code)->co_name;
    Py_INCREF(op->func_name);
    op->func_defaults = NULL; /* No default arguments */
    op->func_kwdefaults = NULL; /* No keyword only defaults */
    op->func_closure = NULL;

    consts = ((PyCodeObject *)code)->co_consts;
    if (PyTuple_Size(consts) >= 1) {
        doc = PyTuple_GetItem(consts, 0);
        if (!PyUnicode_Check(doc))
            doc = Py_None;
    }
    else
        doc = Py_None;
    Py_INCREF(doc);
    op->func_doc = doc;

    op->func_dict = NULL;
    op->func_module = NULL;
    op->func_annotations = NULL;

    /* __module__: If module name is in globals, use it.
       Otherwise, use None. */
    module = PyDict_GetItem(globals, __name__);
    if (module) {
        Py_INCREF(module);
        op->func_module = module;
    }
    if (qualname)
        op->func_qualname = qualname;
    else
        op->func_qualname = op->func_name;
    Py_INCREF(op->func_qualname);

    _PyObject_GC_TRACK(op);
    return (PyObject *)op;
}

TARGET(MAKE_FUNCTION) {
    PyObject *qualname = POP();
    PyObject *codeobj = POP();
    PyFunctionObject *func = (PyFunctionObject *)
        PyFunction_NewWithQualName(codeobj, f->f_globals, qualname);

    Py_DECREF(codeobj);
    Py_DECREF(qualname);
    if (func == NULL) {
        goto error;
    }

    if (oparg & 0x08) {
        assert(PyTuple_CheckExact(TOP()));
        func ->func_closure = POP();
    }
    if (oparg & 0x04) {
        assert(PyDict_CheckExact(TOP()));
        func->func_annotations = POP();
    }
    if (oparg & 0x02) {
        assert(PyDict_CheckExact(TOP()));
        func->func_kwdefaults = POP();
    }
    if (oparg & 0x01) {
        assert(PyTuple_CheckExact(TOP()));
        func->func_defaults = POP();
    }

    //当前函数对应的 PyFunctionObject 入栈
    PUSH((PyObject *)func);
    DISPATCH();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

创建一个 PyFunctionObject 对象，其 globals, 都来自外部的 PyFrameObject

static PyObject *
call_function(PyObject ***pp_stack, Py_ssize_t oparg, PyObject *kwnames)
{
    //执行函数，从栈指针定位到函数
    PyObject **pfunc = (*pp_stack) - oparg - 1;
    PyObject *func = *pfunc;
    PyObject *x, *w;
    Py_ssize_t nkwargs = (kwnames == NULL) ? 0 : PyTuple_GET_SIZE(kwnames);
    //nargs 参数个数
    Py_ssize_t nargs = oparg - nkwargs;
    PyObject **stack;

    /* Always dispatch PyCFunction first, because these are
       presumed to be the most frequent callable object.
    */
    //C 函数
    if (PyCFunction_Check(func)) {
        PyThreadState *tstate = PyThreadState_GET();

        PCALL(PCALL_CFUNCTION);

        stack = (*pp_stack) - nargs - nkwargs;
        C_TRACE(x, _PyCFunction_FastCallKeywords(func, stack, nargs, kwnames));
    }
    else {
        if (PyMethod_Check(func) && PyMethod_GET_SELF(func) != NULL) {
            /* optimize access to bound methods */
            PyObject *self = PyMethod_GET_SELF(func);
            PCALL(PCALL_METHOD);
            PCALL(PCALL_BOUND_METHOD);
            Py_INCREF(self);
            func = PyMethod_GET_FUNCTION(func);
            Py_INCREF(func);
            Py_SETREF(*pfunc, self);
            nargs++;
        }
        else {
            Py_INCREF(func);
        }

        stack = (*pp_stack) - nargs - nkwargs;

        if (PyFunction_Check(func)) {
            x = fast_function(func, stack, nargs, kwnames);
        }
        else {
            x = _PyObject_FastCallKeywords(func, stack, nargs, kwnames);
        }

        Py_DECREF(func);
    }

    assert((x != NULL) ^ (PyErr_Occurred() != NULL));

    /* Clear the stack of the function object.  Also removes
       the arguments in case they weren't consumed already
       (fast_function() and err_args() leave them on the stack).
     */
    while ((*pp_stack) > pfunc) {
        w = EXT_POP(*pp_stack);
        Py_DECREF(w);
        PCALL(PCALL_POP);
    }

    return x;
}
TARGET(CALL_FUNCTION) {
    PyObject **sp, *res;
    PCALL(PCALL_ALL);
    sp = stack_pointer;
    res = call_function(&sp, oparg, NULL);
    stack_pointer = sp;
    PUSH(res);
    if (res == NULL) {
        goto error;
    }
    DISPATCH();
}

//Object/methodobject.c
PyObject *
_PyCFunction_FastCallKeywords(PyObject *func, PyObject **stack,
                              Py_ssize_t nargs, PyObject *kwnames)
{
    PyObject *kwdict, *result;
    Py_ssize_t nkwargs = (kwnames == NULL) ? 0 : PyTuple_GET_SIZE(kwnames);

    assert(PyCFunction_Check(func));
    assert(nargs >= 0);
    assert(kwnames == NULL || PyTuple_CheckExact(kwnames));
    assert((nargs == 0 && nkwargs == 0) || stack != NULL);
    /* kwnames must only contains str strings, no subclass, and all keys must
       be unique */

    if (nkwargs > 0) {
        kwdict = _PyStack_AsDict(stack + nargs, kwnames);
        if (kwdict == NULL) {
            return NULL;
        }
    }
    else {
        kwdict = NULL;
    }

    result = _PyCFunction_FastCallDict(func, stack, nargs, kwdict);
    Py_XDECREF(kwdict);
    return result;
}

#define PyCFunction_GET_FUNCTION(func) \
        (((PyCFunctionObject *)func) -> m_ml -> ml_meth)

PyObject *
_PyCFunction_FastCallDict(PyObject *func_obj, PyObject **args, Py_ssize_t nargs,
                          PyObject *kwargs)
{
    PyCFunctionObject *func = (PyCFunctionObject*)func_obj;
    PyCFunction meth = PyCFunction_GET_FUNCTION(func);
    PyObject *self = PyCFunction_GET_SELF(func);
    PyObject *result;
    int flags;

    assert(PyCFunction_Check(func));
    assert(func != NULL);
    assert(nargs >= 0);
    assert(nargs == 0 || args != NULL);
    assert(kwargs == NULL || PyDict_Check(kwargs));

    /* _PyCFunction_FastCallDict() must not be called with an exception set,
       because it may clear it (directly or indirectly) and so the
       caller loses its exception */
    assert(!PyErr_Occurred());

    flags = PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);

    switch (flags)
    {
    case METH_NOARGS:
        if (kwargs != NULL && PyDict_Size(kwargs) != 0) {
            PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
                         func->m_ml->ml_name);
            return NULL;
        }

        if (nargs != 0) {
            PyErr_Format(PyExc_TypeError,
                "%.200s() takes no arguments (%zd given)",
                func->m_ml->ml_name, nargs);
            return NULL;
        }

        result = (*meth) (self, NULL);
        break;

    case METH_O:
        if (kwargs != NULL && PyDict_Size(kwargs) != 0) {
            PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
                         func->m_ml->ml_name);
            return NULL;
        }

        if (nargs != 1) {
            PyErr_Format(PyExc_TypeError,
                "%.200s() takes exactly one argument (%zd given)",
                func->m_ml->ml_name, nargs);
            return NULL;
        }

        result = (*meth) (self, args[0]);
        break;

    case METH_VARARGS:
    case METH_VARARGS | METH_KEYWORDS:
    {
        /* Slow-path: create a temporary tuple */
        PyObject *tuple;

        if (!(flags & METH_KEYWORDS) && kwargs != NULL && PyDict_Size(kwargs) != 0) {
            PyErr_Format(PyExc_TypeError,
                         "%.200s() takes no keyword arguments",
                         func->m_ml->ml_name);
            return NULL;
        }

        tuple = _PyStack_AsTuple(args, nargs);
        if (tuple == NULL) {
            return NULL;
        }

        if (flags & METH_KEYWORDS) {
            result = (*(PyCFunctionWithKeywords)meth) (self, tuple, kwargs);
        }
        else {
            result = (*meth) (self, tuple);
        }
        Py_DECREF(tuple);
        break;
    }

    case METH_FASTCALL:
    {
        PyObject **stack;
        PyObject *kwnames;
        _PyCFunctionFast fastmeth = (_PyCFunctionFast)meth;

        if (_PyStack_UnpackDict(args, nargs, kwargs, &stack, &kwnames) < 0) {
            return NULL;
        }

        result = (*fastmeth) (self, stack, nargs, kwnames);
        if (stack != args) {
            PyMem_Free(stack);
        }
        Py_XDECREF(kwnames);
        break;
    }

    default:
        PyErr_SetString(PyExc_SystemError,
                        "Bad call flags in PyCFunction_Call. "
                        "METH_OLDARGS is no longer supported!");
        return NULL;
    }

    result = _Py_CheckFunctionResult(func_obj, result, NULL);

    return result;
}

PyObject *
PyEval_EvalFrameEx(PyFrameObject *f, int throwflag)
{
    PyThreadState *tstate = PyThreadState_GET();
    return tstate->interp->eval_frame(f, throwflag);
}

static PyObject*
_PyFunction_FastCall(PyCodeObject *co, PyObject **args, Py_ssize_t nargs,
                     PyObject *globals)
{
    PyFrameObject *f;
    PyThreadState *tstate = PyThreadState_GET();
    PyObject **fastlocals;
    Py_ssize_t i;
    PyObject *result;

    PCALL(PCALL_FASTER_FUNCTION);
    assert(globals != NULL);
    /* XXX Perhaps we should create a specialized
       PyFrame_New() that doesn't take locals, but does
       take builtins without sanity checking them.
       */
    assert(tstate != NULL);
    f = PyFrame_New(tstate, co, globals, NULL);
    if (f == NULL) {
        return NULL;
    }

    fastlocals = f->f_localsplus;

    //将参数依次赋值给 f->f_localsplus
    for (i = 0; i < nargs; i++) {
        Py_INCREF(*args);
        fastlocals[i] = *args++;
    }
    result = PyEval_EvalFrameEx(f,0);

    ++tstate->recursion_depth;
    Py_DECREF(f);
    --tstate->recursion_depth;

    return result;
}

#define PyFunction_GET_GLOBALS(func) \
    (((PyFunctionObject *)func) -> func_globals)

#define PyFunction_GET_DEFAULTS(func) \
    (((PyFunctionObject *)func) -> func_defaults)

#define PyFunction_GET_KW_DEFAULTS(func) \
    (((PyFunctionObject *)func) -> func_kwdefaults)
#define PyFunction_GET_CLOSURE(func) \
    (((PyFunctionObject *)func) -> func_closure)
#define PyFunction_GET_ANNOTATIONS(func) \
    (((PyFunctionObject *)func) -> func_annotations)

static PyObject *
fast_function(PyObject *func, PyObject **stack,
              Py_ssize_t nargs, PyObject *kwnames)
{
    PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
    PyObject *globals = PyFunction_GET_GLOBALS(func);
    PyObject *argdefs = PyFunction_GET_DEFAULTS(func);
    PyObject *kwdefs, *closure, *name, *qualname;
    PyObject **d;
    //kwnames 为扩展的位置参数
    Py_ssize_t nkwargs = (kwnames == NULL) ? 0 : PyTuple_GET_SIZE(kwnames);
    Py_ssize_t nd;

    assert(PyFunction_Check(func));
    assert(nargs >= 0);
    assert(kwnames == NULL || PyTuple_CheckExact(kwnames));
    assert((nargs == 0 && nkwargs == 0) || stack != NULL);
    /* kwnames must only contains str strings, no subclass, and all keys must
       be unique */

    PCALL(PCALL_FUNCTION);
    PCALL(PCALL_FAST_FUNCTION);

    if (co->co_kwonlyargcount == 0 && nkwargs == 0 &&
        co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE))
    {   //函数不含有扩展参数的情况
        if (argdefs == NULL && co->co_argcount == nargs) {
            return _PyFunction_FastCall(co, stack, nargs, globals);
        }
        //全都是默认参数
        else if (nargs == 0 && argdefs != NULL
                 && co->co_argcount == Py_SIZE(argdefs)) {
            /* function called with no arguments, but all parameters have
               a default value: use default values as arguments .*/
            stack = &PyTuple_GET_ITEM(argdefs, 0);
            return _PyFunction_FastCall(co, stack, Py_SIZE(argdefs), globals);
        }
    }

    kwdefs = PyFunction_GET_KW_DEFAULTS(func);
    closure = PyFunction_GET_CLOSURE(func);
    name = ((PyFunctionObject *)func) -> func_name;
    qualname = ((PyFunctionObject *)func) -> func_qualname;

    if (argdefs != NULL) {
        d = &PyTuple_GET_ITEM(argdefs, 0);
        nd = Py_SIZE(argdefs);
    }
    else {
        d = NULL;
        nd = 0;
    }
    return _PyEval_EvalCodeWithName((PyObject*)co, globals, (PyObject *)NULL,
                                    stack, nargs,
                                    nkwargs ? &PyTuple_GET_ITEM(kwnames, 0) : NULL,
                                    stack + nargs,
                                    nkwargs, 1,
                                    d, (int)nd, kwdefs,
                                    closure, name, qualname);
}

#define GETLOCAL(i)     (fastlocals[i])

#define SETLOCAL(i, value)      do { PyObject *tmp = GETLOCAL(i); \
                                     GETLOCAL(i) = value; \
                                     Py_XDECREF(tmp); } while (0)

static PyObject *
_PyEval_EvalCodeWithName(PyObject *_co, PyObject *globals, PyObject *locals,
           PyObject **args, Py_ssize_t argcount,
           PyObject **kwnames, PyObject **kwargs,
           Py_ssize_t kwcount, int kwstep,
           PyObject **defs, Py_ssize_t defcount,
           PyObject *kwdefs, PyObject *closure,
           PyObject *name, PyObject *qualname)
{
    PyCodeObject* co = (PyCodeObject*)_co;
    PyFrameObject *f;
    PyObject *retval = NULL;
    PyObject **fastlocals, **freevars;
    PyThreadState *tstate;
    PyObject *x, *u;
    const Py_ssize_t total_args = co->co_argcount + co->co_kwonlyargcount;
    Py_ssize_t i, n;
    PyObject *kwdict;

    if (globals == NULL) {
        PyErr_SetString(PyExc_SystemError,
                        "PyEval_EvalCodeEx: NULL globals");
        return NULL;
    }

    /* Create the frame */
    tstate = PyThreadState_GET();
    assert(tstate != NULL);
    f = PyFrame_New(tstate, co, globals, locals);
    if (f == NULL) {
        return NULL;
    }
    fastlocals = f->f_localsplus;
    freevars = f->f_localsplus + co->co_nlocals;

    /* Create a dictionary for keyword parameters (**kwags) */
    //扩展键值对参数
    if (co->co_flags & CO_VARKEYWORDS) {
        kwdict = PyDict_New();
        if (kwdict == NULL)
            goto fail;
        i = total_args;
        if (co->co_flags & CO_VARARGS) {
            i++;
        }
        SETLOCAL(i, kwdict);
    }
    else {
        kwdict = NULL;
    }

    /* Copy positional arguments into local variables */
    //扩展位置参数
    if (argcount > co->co_argcount) {
        n = co->co_argcount;
    }
    else {
        n = argcount;
    }
    for (i = 0; i < n; i++) {
        x = args[i];
        Py_INCREF(x);
        SETLOCAL(i, x);
    }

    /* Pack other positional arguments into the *args argument */
    if (co->co_flags & CO_VARARGS) {
        u = PyTuple_New(argcount - n);
        if (u == NULL) {
            goto fail;
        }
        SETLOCAL(total_args, u);
        for (i = n; i < argcount; i++) {
            x = args[i];
            Py_INCREF(x);
            PyTuple_SET_ITEM(u, i-n, x);
        }
    }

    /* Handle keyword arguments passed as two strided arrays */
    kwcount *= kwstep;
    for (i = 0; i < kwcount; i += kwstep) {
        PyObject **co_varnames;
        PyObject *keyword = kwnames[i];
        PyObject *value = kwargs[i];
        Py_ssize_t j;

        if (keyword == NULL || !PyUnicode_Check(keyword)) {
            PyErr_Format(PyExc_TypeError,
                         "%U() keywords must be strings",
                         co->co_name);
            goto fail;
        }

        /* Speed hack: do raw pointer compares. As names are
           normally interned this should almost always hit. */
        co_varnames = ((PyTupleObject *)(co->co_varnames))->ob_item;
        for (j = 0; j < total_args; j++) {
            PyObject *name = co_varnames[j];
            if (name == keyword) {
                goto kw_found;
            }
        }

        /* Slow fallback, just in case */
        for (j = 0; j < total_args; j++) {
            PyObject *name = co_varnames[j];
            int cmp = PyObject_RichCompareBool( keyword, name, Py_EQ);
            if (cmp > 0) {
                goto kw_found;
            }
            else if (cmp < 0) {
                goto fail;
            }
        }

        if (j >= total_args && kwdict == NULL) {
            PyErr_Format(PyExc_TypeError,
                         "%U() got an unexpected keyword argument '%S'",
                         co->co_name, keyword);
            goto fail;
        }

        if (PyDict_SetItem(kwdict, keyword, value) == -1) {
            goto fail;
        }
        continue;

      kw_found:
        if (GETLOCAL(j) != NULL) {
            PyErr_Format(PyExc_TypeError,
                         "%U() got multiple values for argument '%S'",
                         co->co_name, keyword);
            goto fail;
        }
        Py_INCREF(value);
        SETLOCAL(j, value);
    }

    /* Check the number of positional arguments */
    if (argcount > co->co_argcount && !(co->co_flags & CO_VARARGS)) {
        too_many_positional(co, argcount, defcount, fastlocals);
        goto fail;
    }

    /* Add missing positional arguments (copy default values from defs) */
    if (argcount < co->co_argcount) {
        Py_ssize_t m = co->co_argcount - defcount;
        Py_ssize_t missing = 0;
        for (i = argcount; i < m; i++) {
            if (GETLOCAL(i) == NULL) {
                missing++;
            }
        }
        if (missing) {
            missing_arguments(co, missing, defcount, fastlocals);
            goto fail;
        }
        if (n > m)
            i = n - m;
        else
            i = 0;
        for (; i < defcount; i++) {
            if (GETLOCAL(m+i) == NULL) {
                PyObject *def = defs[i];
                Py_INCREF(def);
                SETLOCAL(m+i, def);
            }
        }
    }

    /* Add missing keyword arguments (copy default values from kwdefs) */
    if (co->co_kwonlyargcount > 0) {
        Py_ssize_t missing = 0;
        for (i = co->co_argcount; i < total_args; i++) {
            PyObject *name;
            if (GETLOCAL(i) != NULL)
                continue;
            name = PyTuple_GET_ITEM(co->co_varnames, i);
            if (kwdefs != NULL) {
                PyObject *def = PyDict_GetItem(kwdefs, name);
                if (def) {
                    Py_INCREF(def);
                    SETLOCAL(i, def);
                    continue;
                }
            }
            missing++;
        }
        if (missing) {
            missing_arguments(co, missing, -1, fastlocals);
            goto fail;
        }
    }

    /* Allocate and initialize storage for cell vars, and copy free
       vars into frame. */
    for (i = 0; i < PyTuple_GET_SIZE(co->co_cellvars); ++i) {
        PyObject *c;
        int arg;
        /* Possibly account for the cell variable being an argument. */
        if (co->co_cell2arg != NULL &&
            (arg = co->co_cell2arg[i]) != CO_CELL_NOT_AN_ARG) {
            c = PyCell_New(GETLOCAL(arg));
            /* Clear the local copy. */
            SETLOCAL(arg, NULL);
        }
        else {
            c = PyCell_New(NULL);
        }
        if (c == NULL)
            goto fail;
        //cellvars 在 locals 变量之后
        SETLOCAL(co->co_nlocals + i, c);
    }

    /* Copy closure variables to free variables */
    for (i = 0; i < PyTuple_GET_SIZE(co->co_freevars); ++i) {
        PyObject *o = PyTuple_GET_ITEM(closure, i);
        Py_INCREF(o);
        freevars[PyTuple_GET_SIZE(co->co_cellvars) + i] = o;
    }

    /* Handle generator/coroutine/asynchronous generator */
    if (co->co_flags & (CO_GENERATOR | CO_COROUTINE | CO_ASYNC_GENERATOR)) {
        PyObject *gen;
        PyObject *coro_wrapper = tstate->coroutine_wrapper;
        int is_coro = co->co_flags & CO_COROUTINE;

        if (is_coro && tstate->in_coroutine_wrapper) {
            assert(coro_wrapper != NULL);
            PyErr_Format(PyExc_RuntimeError,
                         "coroutine wrapper %.200R attempted "
                         "to recursively wrap %.200R",
                         coro_wrapper,
                         co);
            goto fail;
        }

        /* Don't need to keep the reference to f_back, it will be set
         * when the generator is resumed. */
        Py_CLEAR(f->f_back);

        PCALL(PCALL_GENERATOR);

        /* Create a new generator that owns the ready to run frame
         * and return that as the value. */
        if (is_coro) {
            gen = PyCoro_New(f, name, qualname);
        } else if (co->co_flags & CO_ASYNC_GENERATOR) {
            gen = PyAsyncGen_New(f, name, qualname);
        } else {
            gen = PyGen_NewWithQualName(f, name, qualname);
        }
        if (gen == NULL)
            return NULL;

        if (is_coro && coro_wrapper != NULL) {
            PyObject *wrapped;
            tstate->in_coroutine_wrapper = 1;
            wrapped = PyObject_CallFunction(coro_wrapper, "N", gen);
            tstate->in_coroutine_wrapper = 0;
            return wrapped;
        }

        return gen;
    }

    retval = PyEval_EvalFrameEx(f,0);

fail: /* Jump here from prelude on failure */

    /* decref'ing the frame can cause __del__ methods to get invoked,
       which can call back into Python.  While we're done with the
       current Python frame (f), the associated C stack is still in use,
       so recursion_depth must be boosted for the duration.
    */
    assert(tstate != NULL);
    ++tstate->recursion_depth;
    Py_DECREF(f);
    --tstate->recursion_depth;
    return retval;
}

PyFrameObject *
PyFrame_New(PyThreadState *tstate, PyCodeObject *code, PyObject *globals,
            PyObject *locals)
{
    PyFrameObject *back = tstate->frame;
    PyFrameObject *f;
    PyObject *builtins;
    Py_ssize_t i;

    if (back == NULL || back->f_globals != globals) {
        builtins = _PyDict_GetItemId(globals, &PyId___builtins__);
        if (builtins) {
            if (PyModule_Check(builtins)) {
                builtins = PyModule_GetDict(builtins);
                assert(builtins != NULL);
            }
        }
        if (builtins == NULL) {
            /* No builtins!              Make up a minimal one
               Give them 'None', at least. */
            builtins = PyDict_New();
            if (builtins == NULL ||
                PyDict_SetItemString(
                    builtins, "None", Py_None) < 0)
                return NULL;
        }
        else
            Py_INCREF(builtins);

    }
    else {
        /* If we share the globals, we share the builtins.
           Save a lookup and a call. */
        builtins = back->f_builtins;
        assert(builtins != NULL);
        Py_INCREF(builtins);
    }
    if (code->co_zombieframe != NULL) {
        f = code->co_zombieframe;
        code->co_zombieframe = NULL;
        _Py_NewReference((PyObject *)f);
        assert(f->f_code == code);
    }
    else {
        Py_ssize_t extras, ncells, nfrees;
        ncells = PyTuple_GET_SIZE(code->co_cellvars);
        nfrees = PyTuple_GET_SIZE(code->co_freevars);
        //代码段的各个变量要在新建的 PyFrameObject 中保留
        extras = code->co_stacksize + code->co_nlocals + ncells +
            nfrees;
        if (free_list == NULL) {
            f = PyObject_GC_NewVar(PyFrameObject, &PyFrame_Type,
            extras);
            if (f == NULL) {
                Py_DECREF(builtins);
                return NULL;
            }
        }
        else {
            assert(numfree > 0);
            --numfree;
            f = free_list;
            free_list = free_list->f_back;
            if (Py_SIZE(f) < extras) {
                PyFrameObject *new_f = PyObject_GC_Resize(PyFrameObject, f, extras);
                if (new_f == NULL) {
                    PyObject_GC_Del(f);
                    Py_DECREF(builtins);
                    return NULL;
                }
                f = new_f;
            }
            _Py_NewReference((PyObject *)f);
        }

        f->f_code = code;
        //将调用者的 PyCodeObject 的 co_nlocals n_cells, nfrees 赋值给 f_localsplus
        extras = code->co_nlocals + ncells + nfrees; //没有包含  code->stacksize
        f->f_valuestack = f->f_localsplus + extras;
        for (i=0; i<extras; i++)
            f->f_localsplus[i] = NULL;
        f->f_locals = NULL;
        f->f_trace = NULL;
        f->f_exc_type = f->f_exc_value = f->f_exc_traceback = NULL;
    }
    f->f_stacktop = f->f_valuestack;
    f->f_builtins = builtins;
    Py_XINCREF(back);
    f->f_back = back;
    Py_INCREF(code);
    Py_INCREF(globals);
    f->f_globals = globals;
    /* Most functions have CO_NEWLOCALS and CO_OPTIMIZED set. */
    if ((code->co_flags & (CO_NEWLOCALS | CO_OPTIMIZED)) ==
        (CO_NEWLOCALS | CO_OPTIMIZED))
        ; /* f_locals = NULL; will be set by PyFrame_FastToLocals() */
    else if (code->co_flags & CO_NEWLOCALS) {
        locals = PyDict_New();
        if (locals == NULL) {
            Py_DECREF(f);
            return NULL;
        }
        f->f_locals = locals;
    }
    else {
    //用全局变量初始化局部变量
        if (locals == NULL)
            locals = globals;
        Py_INCREF(locals);
        f->f_locals = locals;
    }

    f->f_lasti = -1;
    f->f_lineno = code->co_firstlineno;
    f->f_iblock = 0;
    f->f_executing = 0;
    f->f_gen = NULL;

    _PyObject_GC_TRACK(f);
    return f;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760

对于 C 函数，调用 (func->m_ml -> ml_meth)(args) 参数，这里参数包括没有参数，
一个参数，可变参数

对于 Python 本身的函数调用 PyEval_EvalFrameEx，对应无参数的进行了优化，有参数的
进行各种解析。

至此，我们应该对 Python 的执行机制有了更加深刻的理解。大体描述如下：
编译的时候，每个函数会编译为一个单独的 PyCodeObject;
运行的是时候首先，整个文件是一个 PyFrameObject 对象，每个 PyFrameObject 对象包含
PyCodeObject，在 PyCodeObject 执行过程中遇到函数调用，会创建一个新的 PyFunctionObject 对象，
并将编译的 PyCodeObject 赋值给该对象，根据函数类型判断是 C 函数还是 Python
本身的函数。如果是 C 函数，对调用 (func->m_ml -> ml_meth)(args)，如果是 Python
函数，会创建一个新的 PyFrameObject，并用 PyFunctionObject 初始化该 PyFrameObject
对象，最后执行 PyFunctionObject 中 PyCodeObject 中的字节码。

此外，还有一个细节需要注意的是 f_globals，虽然所有函数共享全局变量，但是，
事实上每个函数访问全局变量的时候，并不是依次向上搜索，而是在调用的是，
直接将父函数的 globals 传递给子函数。这样子函数直接搜索自身的 f_globals
就可以了。这样虽然占用了内存，但是提高了效率。

两个问题：
1. 递归是怎么实现的？
2. 前面定义的函数可以调用后面定义的函数么？为什么？

参数

python 中参数包括

位置参数，如 f(a, b)
键值对参数，如 f(a = 1, b = 2)
扩展位置参数，如 f(a, b, *argv)
扩展键值对参数，如 f(a, b, **argv)

例如：

#!/usr/bin/env python
# encoding: utf-8

def test():
    pass

def test1(a):
    pass

def test2(a, b):
    pass

def test3(a, b, *argv):
    pass

def test4(a, b, **argv):
    pass

test()
test1(1)
test2(1, 2)
test3(1, 2, 3)
test3(1, 2, 3, 4)
test4(1, 2, c = 3, d = 4)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

编译之后

magic b'330d0d0a'
moddate b'8788345b' (Thu Jun 28 15:04:39 2018)
files sz 803
code
   argcount 0
   nlocals 0
   stacksize 6
   flags 0040
   code
      b'6400640184005a006402640384005a016404640584005a02640664078400'
      b'5a036408640984005a046500830001006501640a830101006502640a640b'
      b'830201006503640a640b640c830301006503640a640b640c640d83040100'
      b'6504640a640b640c640d640e8d040100640f5300'
  4           0 LOAD_CONST               0 (<code object test at 0x103828ae0, file "/tmp/a.py", line 4>)
              2 LOAD_CONST               1 ('test')
              4 MAKE_FUNCTION            0
              6 STORE_NAME               0 (test)

  7           8 LOAD_CONST               2 (<code object test1 at 0x103839ae0, file "/tmp/a.py", line 7>)
             10 LOAD_CONST               3 ('test1')
             12 MAKE_FUNCTION            0
             14 STORE_NAME               1 (test1)

 10          16 LOAD_CONST               4 (<code object test2 at 0x103839f60, file "/tmp/a.py", line 10>)
             18 LOAD_CONST               5 ('test2')
             20 MAKE_FUNCTION            0
             22 STORE_NAME               2 (test2)

 13          24 LOAD_CONST               6 (<code object test3 at 0x103837b70, file "/tmp/a.py", line 13>)
             26 LOAD_CONST               7 ('test3')
             28 MAKE_FUNCTION            0
             30 STORE_NAME               3 (test3)

 16          32 LOAD_CONST               8 (<code object test4 at 0x1038375d0, file "/tmp/a.py", line 16>)
             34 LOAD_CONST               9 ('test4')
             36 MAKE_FUNCTION            0
             38 STORE_NAME               4 (test4)

 19          40 LOAD_NAME                0 (test)
             42 CALL_FUNCTION            0               //没参数，直接调用
             44 POP_TOP

 20          46 LOAD_NAME                1 (test1)
             48 LOAD_CONST              10 (1)
             50 CALL_FUNCTION            1               //一个参数
             52 POP_TOP

 21          54 LOAD_NAME                2 (test2)
             56 LOAD_CONST              10 (1)
             58 LOAD_CONST              11 (2)
             60 CALL_FUNCTION            2               //两个参数
             62 POP_TOP

 22          64 LOAD_NAME                3 (test3)
             66 LOAD_CONST              10 (1)
             68 LOAD_CONST              11 (2)
             70 LOAD_CONST              12 (3)
             72 CALL_FUNCTION            3               //三个参数
             74 POP_TOP

 23          76 LOAD_NAME                3 (test3)
             78 LOAD_CONST              10 (1)
             80 LOAD_CONST              11 (2)
             82 LOAD_CONST              12 (3)
             84 LOAD_CONST              13 (4)          //四个参数
             86 CALL_FUNCTION            4
             88 POP_TOP

 24          90 LOAD_NAME                4 (test4)
             92 LOAD_CONST              10 (1)
             94 LOAD_CONST              11 (2)
             96 LOAD_CONST              12 (3)
             98 LOAD_CONST              13 (4)
            100 LOAD_CONST              14 (('c', 'd')) //键值对
            102 CALL_FUNCTION_KW         4              //四个参数
            104 POP_TOP
            106 LOAD_CONST              15 (None)
            108 RETURN_VALUE
   consts
      code
         argcount 0
         nlocals 0                      //没有参数，没有局部变量
         stacksize 1
         flags 0043
         code b'64005300'
  5           0 LOAD_CONST               0 (None)
              2 RETURN_VALUE
         consts
            None
         names ()
         varnames ()
         freevars ()
         cellvars ()
         filename '/tmp/a.py'
         name 'test'
         firstlineno 4
         lnotab b'0001'
      'test'
      code
         argcount 1
         nlocals 1                      //一个参数，一个局部变量
         stacksize 1
         flags 0043
         code b'64005300'
  8           0 LOAD_CONST               0 (None)
              2 RETURN_VALUE
         consts
            None
         names ()
         varnames ('a',)
         freevars ()
         cellvars ()
         filename '/tmp/a.py'
         name 'test1'
         firstlineno 7
         lnotab b'0001'
      'test1'
      code
         argcount 2
         nlocals 2                       //两个参数，两个局部变量
         stacksize 1
         flags 0043
         code b'64005300'
 11           0 LOAD_CONST               0 (None)
              2 RETURN_VALUE
         consts
            None
         names ()
         varnames ('a', 'b')
         freevars ()
         cellvars ()
         filename '/tmp/a.py'
         name 'test2'
         firstlineno 10
         lnotab b'0001'
      'test2'
      code
         argcount 2
         nlocals 3                       //两个参数，三个局部变量，其中一个为 argv
         stacksize 1
         flags 0047
         code b'64005300'
 14           0 LOAD_CONST               0 (None)
              2 RETURN_VALUE
         consts
            None
         names ()
         varnames ('a', 'b', 'argv')
         freevars ()
         cellvars ()
         filename '/tmp/a.py'
         name 'test3'
         firstlineno 13
         lnotab b'0001'
      'test3'
      code
         argcount 2
         nlocals 3                       //两个参数，三个局部变量，其中一个为 argv
         stacksize 1
         flags 004b
         code b'64005300'
 17           0 LOAD_CONST               0 (None)
              2 RETURN_VALUE
         consts
            None
         names ()
         varnames ('a', 'b', 'argv')
         freevars ()
         cellvars ()
         filename '/tmp/a.py'
         name 'test4'
         firstlineno 16
         lnotab b'0001'
      'test4'
      1
      2
      3
      4
      ('c', 'd')
      None
   names ('test', 'test1', 'test2', 'test3', 'test4')
   varnames ()
   freevars ()
   cellvars ()
   filename '/tmp/a.py'
   name '<module>'
   firstlineno 4
   lnotab b'08030803080308030803060108010a010c010e01'
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188

当包含位置参数的时候，位置参数会保存在局部变量中，之后传递给函数。你可以试着编译如下代码来验证自己的想法。

def test5(a, b, *args, **argv):
    pass
test5(1, 2, 3, 4, c = 5, d = 6)1
2
3

函数参数从左到右依次压入栈中，才实际调用的时候，会创建
PyFrameObject，这些参数会传递给 PyFrameObject 的 f_localsplus，
当访问函数参数的时候，直接通过索引定位到 f_localsplus 中的参数，
这也是位置参数的由来。

函数分类

从 MAKE_FUNCTION 中可以看出，python 中包括 5 中函数

func->func_closure
func->func_annotations
func->func_kwdefaults
func->func_defaults
以上都为空

而且以上五中并不是互斥的，他们可任意组合。

TARGET(CALL_FUNCTION_KW) {
    PyObject **sp, *res, *names;

    names = POP();
    assert(PyTuple_CheckExact(names) && PyTuple_GET_SIZE(names) <= oparg);
    PCALL(PCALL_ALL);
    sp = stack_pointer;
    res = call_function(&sp, oparg, names);
    stack_pointer = sp;
    PUSH(res);
    Py_DECREF(names);

    if (res == NULL) {
        goto error;
    }
    DISPATCH();
}

TARGET(CALL_FUNCTION_EX) {
    PyObject *func, *callargs, *kwargs = NULL, *result;
    PCALL(PCALL_ALL);
    if (oparg & 0x01) {
        kwargs = POP();
        if (!PyDict_CheckExact(kwargs)) {
            PyObject *d = PyDict_New();
            if (d == NULL)
                goto error;
            if (PyDict_Update(d, kwargs) != 0) {
                Py_DECREF(d);
                /* PyDict_Update raises attribute
                 * error (percolated from an attempt
                 * to get 'keys' attribute) instead of
                 * a type error if its second argument
                 * is not a mapping.
                 */
                if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
                    format_kwargs_mapping_error(SECOND(), kwargs);
                }
                Py_DECREF(kwargs);
                goto error;
            }
            Py_DECREF(kwargs);
            kwargs = d;
        }
        assert(PyDict_CheckExact(kwargs));
    }
    callargs = POP();
    func = TOP();
    if (!PyTuple_CheckExact(callargs)) {
        if (check_args_iterable(func, callargs) < 0) {
            Py_DECREF(callargs);
            goto error;
        }
        Py_SETREF(callargs, PySequence_Tuple(callargs));
        if (callargs == NULL) {
            goto error;
        }
    }
    assert(PyTuple_CheckExact(callargs));

    result = do_call_core(func, callargs, kwargs);
    Py_DECREF(func);
    Py_DECREF(callargs);
    Py_XDECREF(kwargs);

    SET_TOP(result);
    if (result == NULL) {
        goto error;
    }
    DISPATCH();
}

static PyObject *
do_call_core(PyObject *func, PyObject *callargs, PyObject *kwdict)
{
    if (PyCFunction_Check(func)) {
        PyObject *result;
        PyThreadState *tstate = PyThreadState_GET();
        C_TRACE(result, PyCFunction_Call(func, callargs, kwdict));
        return result;
    }
    else {
        return PyObject_Call(func, callargs, kwdict);
    }
}

PyObject *
PyObject_Call(PyObject *func, PyObject *args, PyObject *kwargs)
{
    ternaryfunc call;
    PyObject *result;

    /* PyObject_Call() must not be called with an exception set,
       because it may clear it (directly or indirectly) and so the
       caller loses its exception */
    assert(!PyErr_Occurred());
    assert(PyTuple_Check(args));
    assert(kwargs == NULL || PyDict_Check(kwargs));

    call = func->ob_type->tp_call;
    if (call == NULL) {
        PyErr_Format(PyExc_TypeError, "'%.200s' object is not callable",
                     func->ob_type->tp_name);
        return NULL;
    }

    if (Py_EnterRecursiveCall(" while calling a Python object"))
        return NULL;

    result = (*call)(func, args, kwargs);

    Py_LeaveRecursiveCall();

    return _Py_CheckFunctionResult(func, result, NULL);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

局部变量

#!/usr/bin/env python
# encoding: utf-8

def test1(a):
    a = 1
    b = 2
    c = 3

test1(3)1
2
3
4
5
6
7
8
9

闭包与装饰器

#!/usr/bin/env python
# encoding: utf-8

def cmp_closure(base):
    v = 19
    def cmp_to(value):
        if value > 20:
            value = v
        return base < value

    return cmp_to

def cmp_noclosure(base):
    v = 19
    def cmp_to(value, base = base):
        if value > 20:
            value = v
        return base < value

    return cmp_to

cmp1 = cmp_closure(10)
print(cmp1(9))
print(cmp1(11))

cmp1 = cmp_noclosure(10)
print(cmp1(9))
print(cmp1(11))
print(cmp1(12, 13))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

magic b'330d0d0a'
moddate b'e4a6345b' (Thu Jun 28 17:14:12 2018)
files sz 1678
code
   argcount 0
   nlocals 0
   stacksize 4
   flags 0040
   code
      b'6400640184005a006402640384005a016500640483015a02650365026405'
      b'8301830101006503650264068301830101006501640483015a0265036502'
      b'640583018301010065036502640683018301010065036502640764088302'
      b'8301010064095300'
  4           0 LOAD_CONST               0 (<code object cmp_closure at 0x103072c00, file "/tmp/a.py", line 4>)
              2 LOAD_CONST               1 ('cmp_closure')
              4 MAKE_FUNCTION            0
              6 STORE_NAME               0 (cmp_closure)

 13           8 LOAD_CONST               2 (<code object cmp_noclosure at 0x103083ae0, file "/tmp/a.py", line 13>)
             10 LOAD_CONST               3 ('cmp_noclosure')
             12 MAKE_FUNCTION            0
             14 STORE_NAME               1 (cmp_noclosure)

 22          16 LOAD_NAME                0 (cmp_closure)
             18 LOAD_CONST               4 (10)
             20 CALL_FUNCTION            1
             22 STORE_NAME               2 (cmp1)

 23          24 LOAD_NAME                3 (print)
             26 LOAD_NAME                2 (cmp1)
             28 LOAD_CONST               5 (9)
             30 CALL_FUNCTION            1
             32 CALL_FUNCTION            1
             34 POP_TOP

 24          36 LOAD_NAME                3 (print)
             38 LOAD_NAME                2 (cmp1)
             40 LOAD_CONST               6 (11)
             42 CALL_FUNCTION            1
             44 CALL_FUNCTION            1
             46 POP_TOP

 26          48 LOAD_NAME                1 (cmp_noclosure)
             50 LOAD_CONST               4 (10)
             52 CALL_FUNCTION            1
             54 STORE_NAME               2 (cmp1)

 27          56 LOAD_NAME                3 (print)
             58 LOAD_NAME                2 (cmp1)
             60 LOAD_CONST               5 (9)
             62 CALL_FUNCTION            1
             64 CALL_FUNCTION            1
             66 POP_TOP

 28          68 LOAD_NAME                3 (print)
             70 LOAD_NAME                2 (cmp1)
             72 LOAD_CONST               6 (11)
             74 CALL_FUNCTION            1
             76 CALL_FUNCTION            1
             78 POP_TOP

 29          80 LOAD_NAME                3 (print)
             82 LOAD_NAME                2 (cmp1)
             84 LOAD_CONST               7 (12)
             86 LOAD_CONST               8 (13)
             88 CALL_FUNCTION            2
             90 CALL_FUNCTION            1
             92 POP_TOP
             94 LOAD_CONST               9 (None)
             96 RETURN_VALUE
   consts
      code
         argcount 1
         nlocals 2
         stacksize 3
         flags 0003
         code b'640189018700870166026402640384087d017c015300'
  5           0 LOAD_CONST               1 (19)
              2 STORE_DEREF              1 (v)

  6           4 LOAD_CLOSURE             0 (base)
              6 LOAD_CLOSURE             1 (v)
              8 BUILD_TUPLE              2
             10 LOAD_CONST               2 (<code object cmp_to at 0x103072ae0, file "/tmp/a.py", line 6>)
             12 LOAD_CONST               3 ('cmp_closure.<locals>.cmp_to')
             14 MAKE_FUNCTION            8
             16 STORE_FAST               1 (cmp_to)

 11          18 LOAD_FAST                1 (cmp_to)
             20 RETURN_VALUE
         consts
            None
            19
            code
               argcount 1
               nlocals 1
               stacksize 2
               flags 0013
               code b'7c0064016b04720c88017d0088007c006b005300'
  7           0 LOAD_FAST                0 (value)
              2 LOAD_CONST               1 (20)
              4 COMPARE_OP               4 (>)
              6 POP_JUMP_IF_FALSE       12

  8           8 LOAD_DEREF               1 (v)
             10 STORE_FAST               0 (value)

  9     >>   12 LOAD_DEREF               0 (base)
             14 LOAD_FAST                0 (value)
             16 COMPARE_OP               0 (<)
             18 RETURN_VALUE
               consts
                  None
                  20
               names ()
               varnames ('value',)
               freevars ('base', 'v')
               cellvars ()
               filename '/tmp/a.py'
               name 'cmp_to'
               firstlineno 6
               lnotab b'000108010401'
            'cmp_closure.<locals>.cmp_to'
         names ()
         varnames ('base', 'cmp_to')
         freevars ()
         cellvars ('base', 'v')
         filename '/tmp/a.py'
         name 'cmp_closure'
         firstlineno 4
         lnotab b'000104010e05'
      'cmp_closure'
      code
         argcount 1
         nlocals 2
         stacksize 4
         flags 0003
         code b'640189007c006601870066016402640384097d017c015300'
 14           0 LOAD_CONST               1 (19)
              2 STORE_DEREF              0 (v)

 15           4 LOAD_FAST                0 (base)
              6 BUILD_TUPLE              1
              8 LOAD_CLOSURE             0 (v)
             10 BUILD_TUPLE              1
             12 LOAD_CONST               2 (<code object cmp_to at 0x103083f60, file "/tmp/a.py", line 15>)
             14 LOAD_CONST               3 ('cmp_noclosure.<locals>.cmp_to')
             16 MAKE_FUNCTION            9 //这里会初始化 func_closure, func_defaults
             18 STORE_FAST               1 (cmp_to)

 20          20 LOAD_FAST                1 (cmp_to)
             22 RETURN_VALUE
         consts
            None
            19
            code
               argcount 2
               nlocals 2
               stacksize 2
               flags 0013
               code b'7c0064016b04720c88007d007c017c006b005300'
 16           0 LOAD_FAST                0 (value)
              2 LOAD_CONST               1 (20)
              4 COMPARE_OP               4 (>)
              6 POP_JUMP_IF_FALSE       12

 17           8 LOAD_DEREF               0 (v)
             10 STORE_FAST               0 (value)

 18     >>   12 LOAD_FAST                1 (base)
             14 LOAD_FAST                0 (value)
             16 COMPARE_OP               0 (<)
             18 RETURN_VALUE
               consts
                  None
                  20
               names ()
               varnames ('value', 'base')
               freevars ('v',)
               cellvars ()
               filename '/tmp/a.py'
               name 'cmp_to'
               firstlineno 15
               lnotab b'000108010401'
            'cmp_noclosure.<locals>.cmp_to'
         names ()
         varnames ('base', 'cmp_to')
         freevars ()
         cellvars ('v',)
         filename '/tmp/a.py'
         name 'cmp_noclosure'
         firstlineno 13
         lnotab b'000104011005'
      'cmp_noclosure'
      10
      9
      11
      12
      13
      None
   names ('cmp_closure', 'cmp_noclosure', 'cmp1', 'print')
   varnames ()
   freevars ()
   cellvars ()
   filename '/tmp/a.py'
   name '<module>'
   firstlineno 4
   lnotab b'0809080908010c010c0208010c010c01'
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208

字节码可以看出，
1. 调用 cmp_closure ，返回一个函数对象
2. 调用 cmp1 指向的函数

符合 Lazy 加载模式


TARGET(LOAD_DEREF) {
    PyObject *cell = freevars[oparg];
    PyObject *value = PyCell_GET(cell);
    if (value == NULL) {
        format_exc_unbound(co, oparg);
        goto error;
    }
    Py_INCREF(value);
    PUSH(value);
    DISPATCH();
}
TARGET(STORE_DEREF) {
    PyObject *v = POP();
    PyObject *cell = freevars[oparg];
    PyObject *oldobj = PyCell_GET(cell);
    PyCell_SET(cell, v);
    Py_XDECREF(oldobj);
    DISPATCH();
}

PyObject *
PyCell_New(PyObject *obj)
{
    PyCellObject *op;

    op = (PyCellObject *)PyObject_GC_New(PyCellObject, &PyCell_Type);
    if (op == NULL)
        return NULL;
    op->ob_ref = obj;
    Py_XINCREF(obj);

    _PyObject_GC_TRACK(op);
    return (PyObject *)op;
}

PyObject *
PyCell_Get(PyObject *op)
{
    if (!PyCell_Check(op)) {
        PyErr_BadInternalCall();
        return NULL;
    }
    Py_XINCREF(((PyCellObject*)op)->ob_ref);
    return PyCell_GET(op);
}

int
PyCell_Set(PyObject *op, PyObject *obj)
{
    PyObject* oldobj;
    if (!PyCell_Check(op)) {
        PyErr_BadInternalCall();
        return -1;
    }
    oldobj = PyCell_GET(op);
    Py_XINCREF(obj);
    PyCell_SET(op, obj);
    Py_XDECREF(oldobj);
    return 0;
}

TARGET(LOAD_FAST) {
    PyObject *value = GETLOCAL(oparg);
    if (value == NULL) {
        format_exc_check_arg(PyExc_UnboundLocalError,
                             UNBOUNDLOCAL_ERROR_MSG,
                             PyTuple_GetItem(co->co_varnames, oparg));
        goto error;
    }
    Py_INCREF(value);
    PUSH(value);
    FAST_DISPATCH();
}
        TARGET(BUILD_TUPLE) {
            PyObject *tup = PyTuple_New(oparg);
            if (tup == NULL)
                goto error;
            while (--oparg >= 0) {
                PyObject *item = POP();
                PyTuple_SET_ITEM(tup, oparg, item);
            }
            PUSH(tup);
            DISPATCH();
        }

        TARGET(LOAD_CLOSURE) {
            PyObject *cell = freevars[oparg];
            Py_INCREF(cell);
            PUSH(cell);
            DISPATCH();
        }

        TARGET(STORE_FAST) {
            PyObject *value = POP();
            SETLOCAL(oparg, value);
            FAST_DISPATCH();
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

生成器

TODO

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/199195