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正是靠函数参数的形式决定是否可以进入快速通道的
