函数是任何一个语言的核心构成要素。首先，我想对于绝大部分的程序员，函数是我们在学习编程过程中，接触到的第一个逻辑解耦工具。在我们学习C语言编程的头一两次课里，我们就开始学会使用函数封装逻辑，然后在别处调用。另一方面，函数的调用，是程序运行的根本驱动力。对于大部分编程语言而言，其应用程序的启动，都是从执行入口函数开始的。因此，在我们尝试了解一个语言的底层构造机制时，函数是一个重要的话题。
本文分四个部分梳理python 函数的底层机制。首先是介绍与python函数有关的对象（python 处处皆对象），第二部分和第三部分分别讨论函数的创建与运行。
而最后一部分讨论的是函数中可能用到的各种类型的变量。
与函数有关的python对象
python 处处皆对象，任何一个python的组成元素，其在本质上，都是以一个对象表现的。对于python的函数系统，有三类对象与之有密切的关系，分别是
PyCodeObject,PyFunctionObject,PyFrameObject。
PyCodeObject
在固有印象里，python是一个脚本语言，然而python也是需要编译的。python每次在执行一个脚本的时候，其前端编译器都需要对脚本代码进行编译，这个编译的过程和java等语言的编译过程是相似的，都会生成平台无关的中间代码以及一些其他的静态信息。而这个信息就被保存在PyCodeObject对象里。
python在编译过程中，生成PyCodeObject 的原则是，针对于每一个作用域，生成一个PyCodeObject。由于作用域的嵌套性，PyCodeObject之间也存在嵌套关系。举例来说
针对于写在 test.py 文件中的如下代码：
class Test：
def f():
pass
其在编译时就会产生三个PyCodeObject，针对于整个文件的PyCodeObject,针对于类Test的PyCodeObject和针对于函数f的PyCodeObject。三个PyCodeObject 之间互相嵌套，嵌套的关系与它们之间的作用域关系一致。
PycodeObject 对象是可以离线存储的，我们经常见到的.pyc 文件就是用来存储一个模块所对应的PycodeObject的。
PyCodeObject 的数据结构如下：
/* Bytecode object */
typedef struct {
PyObject_HEAD
int co_argcount; /* #arguments, except *args */
int co_nlocals; /* #local variables */
int co_stacksize; /* #entries needed for evaluation stack */
int co_flags; /* CO_..., see below */
PyObject *co_code; /* instruction opcodes */
PyObject *co_consts; /* list (constants used) */
PyObject *co_names; /* list of strings (names used) */
PyObject *co_varnames; /* tuple of strings (local variable names) */
PyObject *co_freevars; /* tuple of strings (free variable names) */
PyObject *co_cellvars; /* tuple of strings (cell variable names) */
/* The rest doesn't count for hash/cmp */
PyObject *co_filename; /* string (where it was loaded from) */
PyObject *co_name; /* string (name, for reference) */
int co_firstlineno; /* first source line number */
PyObject *co_lnotab;
void *co_zombieframe; /* for optimization only (see frameobject.c) */
PyObject *co_weakreflist; /* to support weakrefs to code objects */
} PyCodeObject;
如前所述，PyCodeObject主要存储的是编译器解析出的代码静态信息。如果当前的PyCodeObject 对应于一个函数，那么PyCodeObject中将记录这个函数的参数个数（co_argcount），局部变量个数（co_nlocals）等信息。函数本身编译产生的指令代码序列以字符串的形式被存储在co_code中。
说了这么多，这里可以得到一个结论，对于函数来说，PyCodeObject存储的是，python函数在编译以后，执行以前的静态信息。
PyFunctionObject
python 是一种动态语言。一些在传统语言当中编译期发生的事情，在python里却是在运行时发生的。比如 函数的定义。python中函数的定义，发生在虚拟机执行def 语句对应的指令序列时。而函数定义语句的产物就是本小节的主角，PyFunctionObject。
PyFunctionObject的数据结构如下：
typedef struct {
PyObject_HEAD
PyObject *func_code; /* A code object */
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 */
} PyFunctionObject;
PyFunctionObject 作为函数的定义载体，理所当然的要载有函数体内的指令代码序列等静态信息。PyFunctionObject 中的func_code就是用于引用函数对应的PycodeObject的指针。
除了pyCodeObject，PyFunctionObject还保存了函数外的全局名字空间(func_globals)，函数的默认参数列表(func_defaults)，以及函数的闭包变量引用（func_closures）。这些信息，我个人把它们看做是一个函数运行时的上下文环境，显然这些信息对于函数的运行至关重要。
那么这里，我们可以得到一个结论，PyFuctionObject 是函数指令序列与函数执行环境的载体。
PyFrameObject
在很多编程语言中，都有函数栈帧这一概念。我想对于绝大部分程序员，这都是一个非常熟悉的概念了。而python函数运行时的栈就是用PyFrameObject对象表示的。
typedef struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table (PyDictObject) */
PyObject *f_globals; /* global symbol table (PyDictObject) */
PyObject *f_locals; /* local symbol table (any mapping) */
PyObject **f_valuestack; /* points after the last local */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
PyObject *f_exc_type, *f_exc_value, *f_exc_traceback;
PyThreadState *f_tstate;
int f_lasti; /* Last instruction if called */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
} PyFrameObject;
我们清楚的在这个结构中看见了 f_valuestack和f_stacktop ，显然这组指针用于指向一个函数栈帧空间的栈底和栈顶。
除了保存函数栈帧空间的位置以外，PyFrameObject对象还保存了一个函数执行时的全局名字空间（f_globals），这个名字空间就是PyfunctionObject携带的func_globals,函数的运行时全局名字空间会在函数开始运行前的初始化阶段，由PyFunctionObject对象传递到PyFrameObject对象。
此外，成员 f_localsplus用于存储函数实参等作用范围在函数体内的变量。
那么这里可以看到，作为函数栈帧对象PyFrameObject 用来保存函数运行时的动态信息。其生命周期从函数开始运行到函数运行结束。
小结
这里对三种函数相关的对象做一个总结。
PyCodeObject存储的是函数的代码，声明等静态信息。
PyFrameObject存储的是函数栈帧等函数运行时的动态信息。
而PyFunctionObject，是函数在定义后运行前的一个暂存对象。
保存有函数的静态信息和运行时上下文环境。
某种程度上，PyFuctionObject，是连接PyCodeObject 与 PyFrameObject的桥梁。
函数创建
就像我们所共知的，python 是一门脚本语言，其语言运行的基本机制是虚拟机逐句执行python语句，说的更准确一点， python虚拟机逐句执行预先编译产生的PyCodeObject 中的python中间代码指令序列。
不同于传统的静态语言，python中函数的定义行为，也是在运行时，由虚拟机执行相应的指令序列完成的。
这里我们通过一个例子，来演示函数的定义过程。首先我们建立一个名字为test.py的python文件，其内容如下：
def f():
print "hello world"
紧接着，我们通过python内置的compile函数，可以得到test.py编译产生的PyCodeObject 对象，利用dis模块，我们可以提取得到test.py这个模块所对应的指令码序列：
0 LOAD_CONST 0 (<code object f at 0x1055df430, file "test.py", line 1>)
3 MAKE_FUNCTION 0
6 STORE_NAME 0 (f)
9 LOAD_CONST 1 (None)
12 RETURN_VALUE
到这里，我们看见了python 中间代码指令序列的“庐山真面目”。
dis函数的输出分为三列，第一列是指令相对于代码段起始位置的偏移，第二列是指令码，第三列为指令参数。关于指令码的意义，官网上有一个较为权威的介绍。
观察 test.py 所对应的指令序列：
LOAD_CONST 0 (<code object f at 0x1055df430, file "test.py", line 1>)
# 从test.py对应的PyCodeObject对象的co_const成员中，读取函数f对应的PyCodeObject
MAKE_FUNCTION 0
# 利用f的PyCodeObject创建函数对象 PyFunctionObject
STORE_NAME 0 (f)
# 存储函数对象到当前名字空间
可以看到，上述三条指令，完成了python语句层面的def操作。
其中的一个核心指令是 MAKE_FUNCTION.
python虚拟机在执行MAKE_FUNTION命令时，首先创建一个PyFunctionObject对象，之后会将函数对应的PyCodeObject 以及一个当前的全局名字空间（CurrentFrame.f_globals）绑定到PyFunctionObject对象上。
PyFunctionObject.func_code=PyCodeObejct
PyFunctionObject.func_globals= CurrentFrame.f_globals
此外，如果函数有默认参数的话，也在这个过程中将默认参数值传递给PyFunctiobObject保存
PyFunctionObejct.func_defaults=tuple(默认参数1，默认参数2...)
至此，我们可以看出python函数的定义语句，完成的核心功能就是生成并初始化一个PyFunctionObject对象。其目的在于完成对于函数静态信息与执行上下文环境的封装，为函数的调用做好准备。
函数运行
现在，我们已经知道，函数在python中，是以PyFunctionObject 对象的形式，存储在当前名字空间中的。那么接下来要介绍的事情就是函数的调用。
函数调用对应的python中间代码指令是 CALL_FUNCTION。概括的讲，函数的调用分为两个部分：创建PyFrameObject对象与执行PyEval_EvalFrameEx函数。
创建PyFrameObject
如同其他语言一样，python语言中也存在函数栈帧的概念，其作用也与其他语言中的函数栈帧相似-- 作为函数运行与调用的活动记录，保存局部动态数据。
追踪python的底层源码，我们可以定位到pyFrameObject 对象的创建代码：
f=Frame_New(tstate,co,globals,NUll);
其中，co 是一个PyCodeObject 对象，globals，则是一个全局名字空间，
如前所述，这里的PyCodeObject，和globals 名字空间，是从PyFrameObject对象里获得的！！
到这里，我们可以看清楚函数从创建到调用过程中，底层相关对象的转换过程：
编译期：生成PycodeObject。保存静态信息
运行期（1）：执行def语句。创建PyFunctionObject对象封装PyCodeObject和全局名字空间。
运行期 （2）：执行函数调用，利用PyFunctionObject对象创建并初始化PyFrameObject对象。
PyFrameObject中有一个很重要的成员：f_back;可以看到，这是一个指向另一个PyFrameObject 的指针，这暗示着我们，PyFrameObject对象在python运行时环境中是以链表形式组织的。
实际上，调用函数的栈帧与被调用函数的栈帧对象之间正式通过这个指针联系的。
def caller():
calle()
生成PyFrameObject后，还需要将函数调用的实参从当前的函数调用栈复制到PyFrameObject 的f_locals
plus区，从而完成函数的参数传递工作。
执行PyEval_EvalFrameEx函数
结束了PyFrameObject 对象的创建与初始化之后，python虚拟机开始执行PyEval_EvalFrameEx 函数。
可以这么讲，PyEval_EvalFrameEx函数是整个python虚拟机驱动的关键。
其代码的骨干结构如下：
PyEval_EvalFrameEx()
{
while（1）
{
switch（opcode）
{
case “LOAD_CONST”:
...
case "MAKE_FUNCTION":
...
...
...
case "CALL_FUNCTION":
...
PyEval_EvalFrameEx();
...
}
}
}
通过执行这个函数，python虚拟机可以执行当前python函数对应的PyFrameObject 对象中f_code成员内保存的python中间代码指令序列。
从而可以完成对于函数逻辑的执行。
这里我们注意到，PyEval_EvalFrameEx 函数中，包含着对于CALL_FUNCTION 指令的处理,而CALL_FUNCTION 指令本身的处理流程，又包含了一个对于PyEval_EvalFrameEx函数的调用。
所以，本质上，python通过这种对于PyEval_EvalFrameEx的递归调用，实现了对于函数之间调用的处理。
上述PyEval_EvalFrameEx 内的这种中间代码处理逻辑，个人认为是一种比较经典的虚拟机主干逻辑设计。在我学习过的llvm项目中，其后端解释器的构造也是相似的。
在这里可以看到的是，虚拟机是通过PyEval_EvalFrameEx内的主干逻辑来执行中间代码序列的。而函数间的调用，是在PyEval_EvalFrameEx代码内，MAKE_FUNCTION 指令处理分支上，递归调用PyEval_EvalFrameEx完成的。
如果追溯整个python虚拟机运行过程中，PyEval_EvalFrameEx
的调用轨迹，我们大概可以得到如下一幅图：
比较特殊的一点是，最外层的PyEval_EvalFrameEx所执行的中间代码，并不是属于某个函数对应的PyCodeObject的。而是属于一个名字叫做“__ main __”的模块所对应的PyCodeObject的
__name__ == '__main__'
python 虚拟机在一开始，取寻找这个名字叫做“__ main __”的模块，提取他的PyCodeObject，调用PyEval_EvalFrameEx 去执行 从而触发了整个虚拟机的运转。
某种程度上，这个特殊的“main” 模块，就是python语言应用程序的“入口函数”。
函数中的变量
函数运行过程中访问的变量概括的讲，可以分为三类：全局变量，局部变量，参数变量。这其中，局部变量和参数变量的作用域范围和存储形式是很相近的。其存储的位置都在PyFrameObject的f_localsplus数组中。而全局变量则是存储在PyFrameObject的f_globals 所引用的名字空间中。
在python的中间代码指令中，对于全局名字空间的访问命令是：
LOAD_GLOBAL/STORE_GLOBAL。其语义分别是:从全局名字空间中取出某个全局对象压栈,将函数栈中的某个对象写入全局名字空间。
相似的，对于局部变量和参数变量的读写命令分别是：
LOAD_FAST/ STORE_FAST.
函数运行过程中，变量的访问广泛的存在于以下两个抽象过程中：
读取数据作为命令参数：
python虚拟机从当前栈帧的局部空间（f_localsplus）或者全局空间（f_globals）中读取数据并压栈，作为接下来中间代码指令的执行参数。
读取数据作为返回值：
python虚拟机执行命令的返回结果会存储在当前的函数栈中，通过弹栈操作，将命令执行的结果写入到全局或者局部空间中。
