Python虚拟机函数机制之无参调用（一）

PyFunctionObject对象

在Python中，任何一个东西都是对象，函数也不例外。函数这种抽象机制，是通过一个Python对象——PyFunctionObject来实现的

typedef struct {
    PyObject_HEAD
    PyObject *func_code;	//编译后的PyCodeObject对象
    PyObject *func_globals;	//函数运行时的global名字空间
    PyObject *func_defaults;	//默认参数（tupple或NULL）
    PyObject *func_closure;	//NULL or a tuple of cell objects，用于实现closure(闭包)
    PyObject *func_doc;		//函数的文档（PyStringObject）
    PyObject *func_name;	//函数名称，函数的__name__属性，（PyStringObject）
    PyObject *func_dict;	//函数的__dict__属性（PyDictObject或NULL）
    PyObject *func_weakreflist;
    PyObject *func_module;	//函数的__module__，可以是任何对象
} PyFunctionObject;

　　

在Python中，有两个对象和函数有关，PyCodeObject和PyFunctionObject。PyCodeObject对象是对一段Python源代码的静态表示，Python源代码经过编译后，对一个Code Block会产生一个且只有一个PyCodeObject对象，这个PyCodeObject对象包含了在这个Code Block的一些静态信息，所谓静态信息即可以在源代码中看到的信息，如Code Block有a = 1这样的表达式，那么符号a和值1，以及它们之间的联系就是一种静态信息，这些信息会分别存储在PyCodeObject的常量表co_consts、符号表co_names以及字节码co_code中，这些信息是编译时就可以得到，因为PyCodeObject是编译时的结果

而PyFunctionObject则不同，PyFunctionObject对象是Python代码在运行时动态产生的，更准确的说，是在执行一个def语句时创建的。在PyFunctionObject中，也会包含这个函数的静态信息，这些信息存储在func_code中。实际上，func_code一定会指向函数代码所对应的PyCodeObject对象。除此之外，PyFunctionObject对象还包含一些函数在执行时必须的动态信息，即上下文信息，比如func_globals，就是函数在执行时关联的global作用域。global作用于的符号和值对应的关系必须在运行时才能确定，所以这部分必须在运行时动态创建，无法存储在PyCodeObject中

对于一段Python代码，其对应的PyCodeObject对象只有一个，而代码所对应的PyFunctionObject对象却可能有多个，比如一个函数多次调用，Python会在运行时创建多个PyFunctionObject对象，每一个PyFunctionObject对象的func_code域都会关联到这个PyCodeObject对象，如图1-1展示了PyFunctionObject与PyCodeObject对象之间的关系：

图1-1

无参数调用

我们对Python函数的剖析从无参数的调用开始，因为无参数调用是最简单的形式

# cat demo.py
def f():
    print("Function")

f()

# python2.5
……
>>> source = open("demo.py").read()
>>> co = compile(source, "demo.py", "exec")
>>> import dis
>>> dis.dis(co)
  1           0 LOAD_CONST               0 (<code object f at 0x7fd9831c3648, file "demo.py", line 1>)
              3 MAKE_FUNCTION            0
              6 STORE_NAME               0 (f)

  5           9 LOAD_NAME                0 (f)
             12 CALL_FUNCTION            0
             15 POP_TOP
             16 LOAD_CONST               1 (None)
             19 RETURN_VALUE
>>> from demo import f
Function
>>> dis.dis(f)
  2           0 LOAD_CONST               1 ('Function')
              3 PRINT_ITEM
              4 PRINT_NEWLINE
              5 LOAD_CONST               0 (None)
              8 RETURN_VALUE

　　

demo.py会产生两个PyCodeObject对象，一个是源文件编译后所生成的PyCodeObject对象，还有一个是函数f编译后所生成的PyCodeObject对象，包含在源文件对应的PyCodeObject对象中。

从上面的例子可以看到，在dis编译demo.py时，并没有将f函数的字节码编译出来，而当我们把函数f传给dis模块时，我们才得到函数f对应的字节码。这表明，函数f的字节码根本不在demo.py所对应的PyCodeObject对象的co_code域中，而是在函数f所对应的PyCodeObject对象中，函数f所对应的PyCodeObject对象，包含在demo.py所对应的PyCodeObject对象中，这是我们必须注意的字节码指令的层次结构。因此，函数的声明与函数的实现实际上是分离的，它们分离在不同的PyCodeObject对象中。尽管从源代码上来看，我们的第一直觉认为声明和实现应该是在一起的，但实际上不是。

Python虚拟机在执行def语句时，会动态创建一个函数，即PyFunctionObject，在这个过程中，MAKE_FUNCTION指令时一个关键：

ceval.c

case MAKE_FUNCTION:
	v = POP(); //获得与函数f对应的PyCodeObject
	x = PyFunction_New(v, f->f_globals);
	Py_DECREF(v);
	//处理函数参数的默认值
	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);
		}
		err = PyFunction_SetDefaults(x, v);
		Py_DECREF(v);
	}
	PUSH(x);
	break;

　　

在MAKE_FUNCTION之前，Python虚拟机会执行"0   LOAD_CONST   0"，将与函数f对应的PyCodeObject对象压入到运行时栈。在执行MAKE_FUNCTION时，再将其取出，然后以该对象和当前PyFrameObject对象中维护的global名字空间f_globals对象为参数，通过PyFunction_New创建一个新的PyFunctionObject对象，而这个f_globals，将成为函数f运行时栈时的global名字空间

funcobject.c

PyObject * PyFunction_New(PyObject *code, PyObject *globals)
{
	//[1]：申请PyFunctionObject对象所需的内存空间
	PyFunctionObject *op = PyObject_GC_New(PyFunctionObject, &PyFunction_Type);
	static PyObject *__name__ = 0;
	if (op != NULL) {
		……
		//设置PyCodeObject对象
		op->func_code = code;
		//设置global名字空间
		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;
		//函数文档
		if (PyTuple_Size(consts) >= 1) {
			doc = PyTuple_GetItem(consts, 0);
			if (!PyString_Check(doc) && !PyUnicode_Check(doc))
				doc = Py_None;
		}
		else
			doc = Py_None;
		……
	}
	else
		return NULL;
	_PyObject_GC_TRACK(op);
	return (PyObject *)op;
}

　　

创建PyFunctionObject对象之后，MAKE_FUNCTION还会进行一些处理函数参数的动作，由于我们的f是最简单的无参函数，没有任何参数，所以参数的传递机制会在后面的章节剖析

在MAKE_FUNCTION结束之后，新建的PyFunctionObject对象通过PUSH操作压入运行时栈中，随后的"6   STORE_NAME   0"和"9   LOAD_NAME   0"不再详述。下面，图1-1展示了def f()语句执行完成后，运行时栈和local名字空间的情况：

图1-1创建PyFunctionObject对象后的虚拟机状态

函数调用

从"12   CALL_FUNCTION   0"开始，Python虚拟机就开始进行调用函数的动作了

ceval.c

case CALL_FUNCTION:
	{
		PyObject **sp;
		PCALL(PCALL_ALL);
		sp = stack_pointer;
		x = call_function(&sp, oparg);
		stack_pointer = sp;
		PUSH(x);
		if (x != NULL)
			continue;
		break;
	}

　　

CALL_FUNCTION的实现非常简单，仅仅是取得栈顶指针，然后就调用call_function函数了。那么我们就跟随着Python虚拟机的步伐，进入call_function函数一探究竟

ceval.c

static PyObject * call_function(PyObject ***pp_stack, int oparg)
{
	//[1]：处理函数参数信息
	int na = oparg & 0xff;
	int nk = (oparg >> 8) & 0xff;
	int n = na + 2 * nk;
	//[2]：获得PyFunctionObject对象
	PyObject **pfunc = (*pp_stack) - n - 1;
	PyObject *func = *pfunc;
	PyObject *x, *w;

	if (PyCFunction_Check(func) && nk == 0)
	{
		……
	}
	else
	{
		if (PyMethod_Check(func) && PyMethod_GET_SELF(func) != NULL)
		{
			……
		}
		else
			Py_INCREF(func);
		READ_TIMESTAMP(*pintr0);
		//[3]：对PyFunctionObject对象进行调用
		if (PyFunction_Check(func))
			x = fast_function(func, pp_stack, n, na, nk);
		else
			x = do_call(func, pp_stack, na, nk);
		……
	}

	……
	return x;
}

　　

可以看到，不光是Function，还有CFunction和Method也会进入call_function，这里的CFunction为内建函数，Method为实例方法或类方法。在这里，我们的重心还是在Function上，先不管CFunction和Method

在call_function的[1]处，有一些处理函数参数信息的动作，n指明了在运行时栈中，栈顶有多少个元素是与参数相关的。当然，对于我们的f，这里的na、nk和n都是0，所以[2]处的pfunc为(*pp_stack) - 1，因为pp_stack就是我们在CALL_FUNCTION的指令代码中传入的当前运行时栈的栈顶指针

很显然，*pFunc，也就是func，指向了Python虚拟机在CALL_FUNCTION之前通过"9   LOAD_NAME   0"指令压入到运行时栈中的那个在MAKE_FUNCTION中创建的PyFunctionObject对象

Python虚拟机代码在通过[3]处的检查，就会进入fast_function。这里，我们也进入fast_function函数

ceval.c

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;

	……
	//[1]：一般函数的快速通道
	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;
		……
		f = PyFrame_New(tstate, co, globals, NULL);
		……
		//再次进入Python虚拟机
		retval = PyEval_EvalFrameEx(f, 0);
		……
		return retval;
	}
	if (argdefs != NULL)
	{
		d = &PyTuple_GET_ITEM(argdefs, 0);
		nd = ((PyTupleObject *)argdefs)->ob_size;
	}
	//PyEval_EvalCodeEx的实现中，依然会调用PyEval_EvalFrameEx
	return PyEval_EvalCodeEx(co, globals,
							 (PyObject *)NULL, (*pp_stack) - n, na,
							 (*pp_stack) - 2 * nk, nk, d, nd,
							 PyFunction_GET_CLOSURE(func));
}

　　

进入fast_function之后，首先会从PyFunctionObject对象中抽取出之前保存的PyCodeObject对象及函数运行时的global名字空间等信息。然后我们可以看到fast_function的执行分两条路径，无参函数会在fast_function的[1]处作出判断，进入函数的快速通道，Python虚拟机会为其创建一个新的PyFrameObject对象，进而调用PyEval_EvalFrameEx

而在另一条路上，则是PyEval_EvalCodeEx，函数PyEval_EvalCodeEx包含一系列复杂的动作，但如果追踪下去，它最后依旧要调用PyEval_EvalFrameEx函数完成字节码指令的执行。从PyEval_EvalFrameEx开始，Python虚拟机才真正开始进入函数调用的状态。这个过程实际上就是对x86平台上函数调用的模拟，在调用函数时创建新的栈帧，在新栈帧中执行函数代码。

有一点需要注意，在最终通过PyEval_EvalFrameEx时，PyFunctionObject对象的影响已经消失了，真正对栈帧产生影响的是PyFunctionObject中存储的PyCodeObject对象和global名字空间。说白了，PyFunctionObject只是为调用PyEval_EvalFrameEx时运输PyCodeObject对象和global名字空间

之前我们有提到函数的快速通道，那什么样的函数才可以进入快速通道呢？像C、C++和Java这样的函数就可以，也就是形如：func(x, y)这样的函数，如果像Python独有的函数func(a, *args, **kwargs)这样的函数则不行，Python正是靠函数参数的形式决定是否可以进入快速通道的