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 PRI
e1a4
NT_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的字节码。

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;                // 返回调用执行的结果

至此，执行完成结果便会返回。

本次的无参函数的调用就分析完成。