Python源码学习:Python函数浅析-无参函数

Python源码分析

本文环境python2.5系列
参考书籍<<Python源码剖析>>

本文会大致分析一下Python中的函数机制。在Python中，函数是一个比较重要的类型，在实现过程中主要参考了操作系统中的函数调用过程，把每个函数模拟成一段待执行的代码，在运行过程中调用，每一段执行的PyCodeObject都被包装在frame中，等待被调用执行，然后调用虚拟机调用执行，这个过程就是一个嵌套执行的过程。

分析

typedef struct {
    PyObject_HEAD
    PyObject *func_code;    /* A code object */   // PyCodeObject对象
    PyObject *func_globals; /* A dictionary (other mappings won't do) */  //对应的函数全局变量
    PyObject *func_defaults;    /* NULL or a tuple */ //函数的默认参数
    PyObject *func_closure; /* NULL or a tuple of cell objects */    // 函数闭包实现
    PyObject *func_doc;     /* The __doc__ attribute, can be anything */   // 函数文档
    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 */   

    /* 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;

由定义可知，PyFunctionObject也是一个PyObject，其中func_code是Python编译器在编译的时候就生成的对象，将Python的执行代码编译成了一个PyCodeObject对象，PyFunctionObject是Python解释器在执行字节码时，根据PyCodeObject代码生成的，并且包含函数执行时相应的全局变量。

先分析如下例子

def f():
    print("hello world")

f()

对应编译后的字节码为

  1           0 LOAD_CONST               0 (<code object f at 0x1044fd630, file "test1.py", line 1>)
              3 MAKE_FUNCTION            0
              6 STORE_NAME               0 (f)

  4           9 LOAD_NAME                0 (f)
             12 CALL_FUNCTION            0
             15 POP_TOP             
             16 LOAD_CONST               1 (None)
             19 RETURN_VALUE  

并且可以查看一下，code object f的结果为

  2           0 LOAD_CONST               1 ('hello world')
              3 PRINT_ITEM          
              4 PRINT_NEWLINE       
              5 LOAD_CONST               0 (None)
              8 RETURN_VALUE

通过两段字节码的分析可知，该代码里面包含了两个PyCodeObject一个是运行的本身，另一个测试f对应的PyCodeObject。先分析本身的字节码执行，在LOAD_CONST对应的f的PyCodeObject后，直接调用了MAKE_FUNCTION，我们查看一些具体的执行流程。

            v = POP(); /* code object */   //获取code
            x = PyFunction_New(v, f->f_globals);  //调用新建函数方法，并将当前执行的全局变量传入
            Py_DECREF(v);
            /* XXX Maybe this should be a separate opcode? */
            if (x != NULL && oparg > 0) {
                v = PyTuple_New(oparg);
                if (v == NULL) {
                    Py_DECREF(x);
                    x = NULL;
                    break;
                }
                while (--oparg >= 0) {
                    w = POP();
                    PyTuple_SET_ITEM(v, oparg, w);    // 根据传入参数的个数，将传入参数设置到tuple中
                }
                err = PyFunction_SetDefaults(x, v);  // 处理函数的默认参数
                Py_DECREF(v);
            }
            PUSH(x);
            break;

由此我们进一步分析PyFunction_New代码

PyObject *
PyFunction_New(PyObject *code, PyObject *globals)
{
    PyFunctionObject *op = PyObject_GC_New(PyFunctionObject,
                        &PyFunction_Type);              // 申请函数对象的空间
    static PyObject *__name__ = 0;
    if (op != NULL) {         
        PyObject *doc;
        PyObject *consts;
        PyObject *module;
        op->func_weakreflist = NULL;
        Py_INCREF(code);
        op->func_code = code;                           // 设置函数对应的PyCodeObject
        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_closure = NULL;                   
        consts = ((PyCodeObject *)code)->co_consts;               // code中的常量
        if (PyTuple_Size(consts) >= 1) {                          // 获取函数的doc
            doc = PyTuple_GetItem(consts, 0);
            if (!PyString_Check(doc) && !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;       

        /* __module__: If module name is in globals, use it.
           Otherwise, use None.
        */
        if (!__name__) {
            __name__ = PyString_InternFromString("__name__");
            if (!__name__) {
                Py_DECREF(op);
                return NULL;
            }
        }
        module = PyDict_GetItem(globals, __name__);
        if (module) {
            Py_INCREF(module);
            op->func_module = module;
        }
    }
    else
        return NULL;
    _PyObject_GC_TRACK(op);
    return (PyObject *)op;
}

主要工作就是完成申请PyFunctionObject的空间大小，设置各个参数值。
至此，一个PyFunctionObject就完成创建。
接着就是LOAD_NAME f,此时就加载刚刚创建好的函数对象，然后调用CALL_FUNCTION，我们继续查看；

        case CALL_FUNCTION:
        {
            PyObject **sp;
            PCALL(PCALL_ALL);
            sp = stack_pointer;
#ifdef WITH_TSC
            x = call_function(&sp, oparg, &intr0, &intr1);
#else
            x = call_function(&sp, oparg);
#endif
            stack_pointer = sp;
            PUSH(x);
            if (x != NULL)
                continue;
            break;
        }

此时，将函数传入call_function中，

static PyObject *
call_function(PyObject ***pp_stack, int oparg
#ifdef WITH_TSC
        , uint64* pintr0, uint64* pintr1
#endif
        )
{
    int na = oparg & 0xff;         // 获取输入参数的个数
    int nk = (oparg>>8) & 0xff;    // 获取位置参数的个数
    int n = na + 2 * nk;           //  总大小，由于一个位置参数由key和value组成，所有乘2
    PyObject **pfunc = (*pp_stack) - n - 1;      // 获取函数对象
    PyObject *func = *pfunc;
    PyObject *x, *w;

    /* Always dispatch PyCFunction first, because these are
       presumed to be the most frequent callable object.
    */
    if (PyCFunction_Check(func) && nk == 0) {           // 检查func的类型，是否为cfunc
        ...
    } else {
        if (PyMethod_Check(func) && PyMethod_GET_SELF(func) != NULL) {  // 检查func是否是类访问的方法
            /* 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_DECREF(*pfunc);
            *pfunc = self;
            na++;
            n++;
        } else
            Py_INCREF(func);
        READ_TIMESTAMP(*pintr0);
        if (PyFunction_Check(func))                                     // 检查是否是函数类型
            x = fast_function(func, pp_stack, n, na, nk);               // 处理快速方法
        else
            x = do_call(func, pp_stack, na, nk);
        READ_TIMESTAMP(*pintr1);
        Py_DECREF(func);
    }

    /* 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;
}

主要是先判断函数的类型，然后在根据函数的类型进行调用，在本例中，会调用fast_function;

static PyObject *
fast_function(PyObject *func, PyObject ***pp_stack, int n, int na, int nk)
{
    PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);    // 获取函数的对应的字节码
    PyObject *globals = PyFunction_GET_GLOBALS(func);                // 获取函数的执行时的全局变量
    PyObject *argdefs = PyFunction_GET_DEFAULTS(func);               // 获取函数的默认参数
    PyObject **d = NULL;
    int nd = 0;

    PCALL(PCALL_FUNCTION);
    PCALL(PCALL_FAST_FUNCTION);  
    if (argdefs == NULL && co->co_argcount == n && nk==0 &&
        co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) {   // 一般函数的执行过程
        PyFrameObject *f;                                              // 调用函数对应的帧
        PyObject *retval = NULL;                                       // 参数执行完成后的返回结果
        PyThreadState *tstate = PyThreadState_GET();                   // 获取当前线程的状态
        PyObject **fastlocals, **stack; 
        int i;

        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;                                  // 本地变量
        stack = (*pp_stack) - n;

        for (i = 0; i < n; i++) {
            Py_INCREF(*stack);
            fastlocals[i] = *stack++;
        }
        retval = PyEval_EvalFrameEx(f,0);                              // 调用解释器继续执行函数对应的字节码
        ++tstate->recursion_depth;
        Py_DECREF(f);
        --tstate->recursion_depth;
        return retval;
    }
    if (argdefs != NULL) {
        d = &PyTuple_GET_ITEM(argdefs, 0);
        nd = ((PyTupleObject *)argdefs)->ob_size;
    }
    return PyEval_EvalCodeEx(co, globals,
                 (PyObject *)NULL, (*pp_stack)-n, na,
                 (*pp_stack)-2*nk, nk, d, nd,
                 PyFunction_GET_CLOSURE(func));
}

此时，调用fast_function就又调用解释器函数执行字节码，然后执行完成将结果返回，此时解释器执行的字节码为code f的字节码。

扫描二维码关注公众号，回复： 1572622 查看本文章

  2           0 LOAD_CONST               1 ('hello world')
              3 PRINT_ITEM          
              4 PRINT_NEWLINE       
              5 LOAD_CONST               0 (None)
              8 RETURN_VALUE

该段字节码执行的源码分析，有兴趣可自行查看，执行完成后就是打印hello world，然后返回None值，然后通过RETURN_VALUE；

        case RETURN_VALUE:
            retval = POP();     // 弹出返回结果
            why = WHY_RETURN;
            goto fast_block_end;   // 跳转到fast_block_end

fast_block_end，该处代码就是判断当前执行流程中，是否有错误或者执行完成已经有返回结果了就中断循环，然后就执行到

    /* pop frame */
    exit_eval_frame:
    Py_LeaveRecursiveCall();
    tstate->frame = f->f_back;     // 将当前执行的帧设置为调用的帧

    return retval;                // 返回调用执行的结果

至此，执行完成结果便会返回。
本次的无参函数的调用就分析完成。