起步
python中, 任何东西都是一个对象, 函数也不例外, 函数对象结构 PyFunctionObject :
[functionobject.h]
typedef struct {
PyObject_HEAD
PyObject *func_code; // 编译后的 PyCodeObject 对象
PyObject *func_globals; // 运行时的global名字空间
PyObject *func_defaults; // 默认参数(tuple or null)
PyObject *func_kwdefaults; // 带声明的参数默认值 dict or null
PyObject *func_closure; // 闭包函数集合, null or tuple
PyObject *func_doc; // 函数的文档 PyStringObject
PyObject *func_name; // 函数名, __name__ 属性, 是PyStringObject对象
PyObject *func_dict; // 函数的 __dict__ 属性, PyDictObject 或 null
PyObject *func_weakreflist;
PyObject *func_module; // 函数的__module__ ,可以是任意对象
PyObject *func_annotations; // 注释, null or dict
PyObject *func_qualname; /* The qualified name */
} PyFunctionObject;在python中, 有两个对象都和函数有关, PyCodeObject和PyFunctionObject, 这两个对象的区别是, PyCodeObject对象是一段python代码的静态表示, 对一个code block会产生一个且只有一个PyCodeObject. 而PyFunctionObject则不同, PyFunctionObject是python代码运行时动态产生的, 它是在执行一个 def 语句时候创建的. 在PyFunctionObject中, 也会包含函数的静态信息, 这些信息保存在 func_code 中, 这个成员指向的是函数代码对应的PyCodeObject对象, 此外, PyFunctionObject还包含一些函数在执行时必要的动态信息, 即上下文, 如 func_globals, 就表明函数执行是关联了global名字空间. global 作用域中的符号和变量值必须在运行时才确定.
函数对象的创建
以无参函数调用入手, 因为不用去考虑复杂的参数传递机制的细节, 而将关注点放在函数调用的流程框架上:
def f():
print("this is a function")
f()其编译的code和字节码如下:
co_consts : (<code object f at 0x000001C5F7EFE660, file "compile.py", line 1>, 'f', None)
co_names : ('f',)
co_stacksize : 2
1 0 LOAD_CONST 0 (<code object f at 0x000001C5F7EFE660, file "compile.py", line 1>)
2 LOAD_CONST 1 ('f')
4 MAKE_FUNCTION 0
6 STORE_NAME 0 (f)
3 8 LOAD_NAME 0 (f)
10 CALL_FUNCTION 0
12 POP_TOP
14 LOAD_CONST 2 (None)
16 RETURN_VALUE这段代码的编译共产生了两个PyCodeObject对象, 一个是这个文件, 另一个是函数f():
TARGET(MAKE_FUNCTION) {
PyObject *qualname = POP(); // 函数的名字
PyObject *codeobj = POP(); // 函数对应的PyCodeObject对象
PyFunctionObject *func = (PyFunctionObject *)
PyFunction_NewWithQualName(codeobj, f->f_globals, qualname);
Py_DECREF(codeobj);
Py_DECREF(qualname);
// 处理参数
...
PUSH((PyObject *)func);
DISPATCH();
}在创建函数指令之前, 先通过LOAD_CONST将函数f对应的PyCodeObject对象压入运行时栈中. 然后以该对象和当前的PyFrameObject中的global名字空间, 通过 PyFunction_NewWithQualName 创建一个新的PyFunctionObject对象:
PyObject * PyFunction_NewWithQualName(PyObject *code, PyObject *globals, PyObject *qualname)
{
PyFunctionObject *op;
PyObject *doc, *consts, *module;
static PyObject *__name__ = PyUnicode_InternFromString("__name__");
// 创建PyFunctionObject对象
op = PyObject_GC_New(PyFunctionObject, &PyFunction_Type);
if (op == NULL)
return NULL;
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_kwdefaults = NULL; /* No keyword only defaults */
op->func_closure = NULL;
consts = ((PyCodeObject *)code)->co_consts; // 函数中的常量对象表
if (PyTuple_Size(consts) >= 1) {
doc = PyTuple_GetItem(consts, 0);
if (!PyUnicode_Check(doc))
doc = Py_None;
}
else
doc = Py_None;
Py_INCREF(doc);
op->func_doc = doc; // 函数中的文档
...
_PyObject_GC_TRACK(op);
return (PyObject *)op;
}在创建PyFunctionObject对象之后, MAKE_FUNCTION还会进行一些处理函数的参数动作, MAKE_FUNCTION指令中, 新建的function对象通过PUSH操作压入到运行时栈中.
函数调用
函数调用从 CALL_FUNCTION 指令开始, 前面在介绍了 print 信息输出时也有涉及到函数, 当时没有详细介绍函数机制, 现在重新认识一下函数调用:
TARGET(CALL_FUNCTION) {
PyObject **sp, *res;
sp = stack_pointer;
res = call_function(&sp, oparg, NULL);
stack_pointer = sp;
PUSH(res);
if (res == NULL) {
goto error;
}
DISPATCH();
}这个指令中, 获得了当前运行时栈的栈顶指针后就调用 call_function 了:
[ceval.c]
Py_LOCAL_INLINE(PyObject *) _Py_HOT_FUNCTION call_function(PyObject ***pp_stack, Py_ssize_t oparg, PyObject *kwnames)
{
PyObject **pfunc = (*pp_stack) - oparg - 1;
PyObject *func = *pfunc; // 获取PyFunctionObject 对象
PyObject *x, *w;
Py_ssize_t nkwargs = (kwnames == NULL) ? 0 : PyTuple_GET_SIZE(kwnames);
Py_ssize_t nargs = oparg - nkwargs;
PyObject **stack = (*pp_stack) - nargs - nkwargs;
/* Always dispatch PyCFunction first, because these are
presumed to be the most frequent callable object.
*/
if (PyCFunction_Check(func)) {
PyThreadState *tstate = PyThreadState_GET();
C_TRACE(x, _PyCFunction_FastCallKeywords(func, stack, nargs, kwnames));
}
else if (Py_TYPE(func) == &PyMethodDescr_Type) {
...
}
else {
...
if (PyFunction_Check(func)) {
x = _PyFunction_FastCallKeywords(func, stack, nargs, kwnames);
}
else {
x = _PyObject_FastCallKeywords(func, stack, nargs, kwnames);
}
Py_DECREF(func);
}
assert((x != NULL) ^ (PyErr_Occurred() != NULL));
/* Clear the stack of the function object. */
while ((*pp_stack) > pfunc) {
w = EXT_POP(*pp_stack);
Py_DECREF(w);
}
return x;
}其中:
#define PyCFunction_Check(op) (Py_TYPE(op) == &PyCFunction_Type)
#define PyFunction_Check(op) (Py_TYPE(op) == &PyFunction_Type)显然我们的函数创建对象时用的对象是 PyFunction_Type , 因此按照if路径走的是 x = _PyFunction_FastCallKeywords(func, stack, nargs, kwnames); . 分析调用前的变量的值都是啥, pp_stack 是在 CALL_FUNCTION 指令代码中传入的当时运行时栈的栈顶指针, oparg 是0 , 传进来的 kwnames 是NULL. 因此 pfunc = pp_stack - 1 , 所以 *pfunc 就是func, 即在MAKE_FUNCTION中创建的PyFunctionObject对象. 后面的 nkwargs 和 nargs 显然都是0.
[call.c]
PyObject * _PyFunction_FastCallKeywords(PyObject *func, PyObject **stack,
Py_ssize_t nargs, PyObject *kwnames)
{
PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); // 获得PyCodeObject对象
PyObject *globals = PyFunction_GET_GLOBALS(func); // 获得globals名字空间
PyObject *argdefs = PyFunction_GET_DEFAULTS(func); // 默认参数
PyObject *kwdefs, *closure, *name, *qualname;
PyObject **d;
Py_ssize_t nkwargs = (kwnames == NULL) ? 0 : PyTuple_GET_SIZE(kwnames);
Py_ssize_t nd;
if (co->co_kwonlyargcount == 0 && nkwargs == 0 &&
co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE))
{
if (argdefs == NULL && co->co_argcount == nargs) {
return function_code_fastcall(co, stack, nargs, globals);
}
else if (nargs == 0 && argdefs != NULL && co->co_argcount == PyTuple_GET_SIZE(argdefs)) {
return function_code_fastcall(co, stack, PyTuple_GET_SIZE(argdefs),
globals);
}
}
...
return _PyEval_EvalCodeWithName((PyObject*)co, globals, (PyObject *)NULL,
stack, nargs,
nkwargs ? &PyTuple_GET_ITEM(kwnames, 0) : NULL,
stack + nargs,
nkwargs, 1,
d, (int)nd, kwdefs,
closure, name, qualname);
}这段代码中, 包含了两条执行路径, 无参和有参的情况, f函数是无参, 显然执行了 return function_code_fastcall(co, stack, nargs, globals);.:
static PyObject* _Py_HOT_FUNCTION function_code_fastcall(PyCodeObject *co, PyObject **args, Py_ssize_t nargs,
PyObject *globals)
{
PyFrameObject *f;
PyThreadState *tstate = PyThreadState_GET();
PyObject **fastlocals;
Py_ssize_t i;
PyObject *result;
// 创建新的PyFrameObject
f = _PyFrame_New_NoTrack(tstate, co, globals, NULL);
if (f == NULL) {
return NULL;
}
fastlocals = f->f_localsplus;
// 处理参数
for (i = 0; i < nargs; i++) {
Py_INCREF(*args);
fastlocals[i] = *args++;
}
result = PyEval_EvalFrameEx(f,0);
...
return result;
}使用code对象和当前线程创建了一个新的PyFrameObject, 然后 PyEval_EvalFrameEx 执行栈帧, 也就是真正进入了所谓的函数调用状态, 在新的栈帧中执行代码,.
函数执行时的名字空间
在创建PyFunctionObject时,有一个参数globals, 这个globals最终成为函数f对象的PyFrameObject中global名字空间-- f_globals. 在那时说明 LOAD_NAME 指令时, 搜索顺序是:f_locals, f_globals, f_builtins. 这意味着, 当前的PyFrameObject对象中的与新建的PyFrameObject对象的global名字空间是同一个.
函数参数的实现
python中参数的形式很多样, 可以分为四种类型:
- 位置参数: fun(a, b), a, b是位置参数
- 键参数: fun(a, b, name='python'), 其中name就是键参数
- 扩展位置参数: fun(a, b, *lst), 其中lst是扩展位置参数
- 扩展键参数: fun(a, b, **kw), 其中kw是扩展键参数
扩展位置参数是允许在函数调用时调用参数的数量个数可变. 参数的处理过程需要回顾一下 call_function :
[ceval.c]
Py_LOCAL_INLINE(PyObject *) _Py_HOT_FUNCTION call_function(PyObject ***pp_stack, Py_ssize_t oparg, PyObject *kwnames)
{
PyObject **pfunc = (*pp_stack) - oparg - 1;
PyObject *func = *pfunc; // 获得PyFunctionObject对象
PyObject *x, *w;
Py_ssize_t nkwargs = (kwnames == NULL) ? 0 : PyTuple_GET_SIZE(kwnames);// 键参数个数
Py_ssize_t nargs = oparg - nkwargs; // 位置参数个数
PyObject **stack = (*pp_stack) - nargs - nkwargs;
...
}虚拟机执行 CALL_FUNCTION 指令时, 首先获得一个指令参数oparg, 这个参数中表示了调用函数时需要的函数参数个数信息. python存在四种参数形式, 而则oparg只是个数字, 显然不能详细表示四种参数具体信息, 实际上它表示了一共有多少个参数.
python的每个指令都是占用两个字节, 第一个字节存指令, 第二字节存放参数个数, 这意味这oparg值最多255, 也就是说python中函数参数个数最多255个.
def f(a, b):
print(a)
f(1, b=2)函数调用时用:
8 LOAD_NAME 0 (f)
10 LOAD_CONST 2 (1)
12 LOAD_CONST 3 (2)
14 LOAD_CONST 4 (('b',))
16 CALL_FUNCTION_KW 2当有键参数时, 调用了 CALL_FUNCTION_KW 这个实现和 CALL_FUNCTION 差不多:
TARGET(CALL_FUNCTION_KW) {
PyObject **sp, *res, *names;
names = POP();
assert(PyTuple_CheckExact(names) && PyTuple_GET_SIZE(names) <= oparg);
sp = stack_pointer;
res = call_function(&sp, oparg, names);
stack_pointer = sp;
PUSH(res);
...
DISPATCH();
}只是在 call_function 中多个一个 names 参数, 在CALL_FUNCTION传的是NULL. 如果我们调用是 f(1, 2) 那么 (nkwargs, nargs) 的值就是 (0, 2), 而 f(1, b=2) 则是(1, 1). 可见 nkwargs, nargs 能反应真实位置参数和键参数的个数. 键参数是个tuple类型, 因此 oparg-len(nkwargs) 就是nargs的个数了.
位置参数的传递
调用f(1, 2) 是需要将1和2分别赋值给a和b的. 先不分析键参数, 来看看f函数对应的指令:
2 0 LOAD_GLOBAL 0 (print)
2 LOAD_FAST 0 (a)
4 CALL_FUNCTION 1
6 POP_TOP
3 8 LOAD_GLOBAL 0 (print)
10 LOAD_FAST 1 (b)
12 CALL_FUNCTION 1
14 POP_TOP
16 LOAD_CONST 0 (None)
18 RETURN_VALUE参数的使用上用的是 LOAD_FAST :
TARGET(LOAD_FAST) {
PyObject *value = GETLOCAL(oparg);
Py_INCREF(value);
PUSH(value);
FAST_DISPATCH();
}这个命令显然和 LOAD_NAME 区别仅仅是, LOAD_FAST只从locals名字空间获取, 而LOAD_NAME则会根据LGB规则顺序获取. 那么这些参数是怎么进入locals名字空间的呢, 也就是说在 call_function 的时候, 参数列表应该注入到f的栈帧对象的locals中:
static PyObject* _Py_HOT_FUNCTION function_code_fastcall(PyCodeObject *co, PyObject **args, Py_ssize_t nargs,
PyObject *globals)
{
...
// 创建新的PyFrameObject
f = _PyFrame_New_NoTrack(tstate, co, globals, NULL);
fastlocals = f->f_localsplus;
// 处理参数
for (i = 0; i < nargs; i++) {
fastlocals[i] = *args++;
}
...
}显而易见了.
位置参数的默认值
如果函数有默认值, 如:
def f(a=1, b=2):
print(a)
print(b)
f()多余的指令就不贴了, 默认参数的处理在创建PyFunctionObject对象时候处理的:
0 LOAD_CONST 5 ((1, 2))
2 LOAD_CONST 2 (<code object f at 0x000001A51BCDE6F0, file "compile.py", line 1>)
4 LOAD_CONST 3 ('f')
6 MAKE_FUNCTION 1在创建函数对象时, 默认参数值以tuple形式入栈. 回头再看看 MAKE_FUNCTION 命令:
TARGET(MAKE_FUNCTION) {
PyObject *qualname = POP();
PyObject *codeobj = POP();
PyFunctionObject *func = (PyFunctionObject *) PyFunction_NewWithQualName(codeobj, f->f_globals, qualname);
// 处理参数
if (oparg & 0x08) {
assert(PyTuple_CheckExact(TOP()));
func ->func_closure = POP();
}
if (oparg & 0x04) {
assert(PyDict_CheckExact(TOP()));
func->func_annotations = POP();
}
if (oparg & 0x02) { // 键参数
assert(PyDict_CheckExact(TOP()));
func->func_kwdefaults = POP();
}
if (oparg & 0x01) { // 位置参数
assert(PyTuple_CheckExact(TOP()));
func->func_defaults = POP();
}
PUSH((PyObject *)func);
DISPATCH();
}默认参数存在了 func->func_defaults 中. 如果在CALL_FUNCTION指令中, 发现传递的位置参数个数小于fun对象中的参数, 那python需要为函数设定默认参数:
[ceval.c]
PyObject * _PyEval_EvalCodeWithName(/* 省略参数 */) {
...
// 传递的参数个数小于fun对象定义的参数个数时
if (argcount < co->co_argcount) {
Py_ssize_t m = co->co_argcount - defcount;
Py_ssize_t missing = 0;
if (n > m)
i = n - m;
else
i = 0;
for (; i < defcount; i++) {
// 赋值默认值
if (GETLOCAL(m+i) == NULL) {
PyObject *def = defs[i];
Py_INCREF(def);
SETLOCAL(m+i, def);
}
}
}
...
}这段代码的作用也就是如果函数申明是def f(a=1, b=2) 而调用时 f(3) 那么就把2赋值给locals空间的b中.
扩展位置参数和扩展键参数
前面已经有看到扩展位置参数其实是个tuple, 因此可以猜想扩展键参数其实就是个dict对象.如果我们声明一个函数如下:
def f(value, *lst, **keys):
pass
f(-1, 1, 2, 3, a=4, b=5)对应的code和指令为:
co_consts : (<code object f at 0x00000238A685E6F0, file "compile.py", line 1>, 'f', 1, 2, 3, 4, 5, ('a', 'b'), None, -1)
co_names : ('f',)
co_nlocals : 0
co_stacksize : 8
co_varnames : ()
1 0 LOAD_CONST 0 (<code object f at 0x00000238A685E6F0, file "compile.py", line 1>)
2 LOAD_CONST 1 ('f')
4 MAKE_FUNCTION 0
6 STORE_NAME 0 (f)
3 8 LOAD_NAME 0 (f)
10 LOAD_CONST 9 (-1)
12 LOAD_CONST 2 (1)
14 LOAD_CONST 3 (2)
16 LOAD_CONST 4 (3)
18 LOAD_CONST 5 (4)
20 LOAD_CONST 6 (5)
22 LOAD_CONST 7 (('a', 'b'))
24 CALL_FUNCTION_KW 6
26 POP_TOP
28 LOAD_CONST 8 (None)
30 RETURN_VALUE当含有键参数时采用了 CALL_FUNCTION_KW 指令, 前面说了, 这个指令和CALL_FUNCTION就是多了传了键参数的键组成了tuple.
PyObject * _PyEval_EvalCodeWithName(/* 省略参数 */) {
...
// 先设置键参数默认值, 这是在函数声明时用的默认值
if (co->co_kwonlyargcount > 0) {
Py_ssize_t missing = 0;
for (i = co->co_argcount; i < total_args; i++) {
PyObject *name;
if (GETLOCAL(i) != NULL)
continue;
name = PyTuple_GET_ITEM(co->co_varnames, i);
if (kwdefs != NULL) {
PyObject *def = PyDict_GetItem(kwdefs, name);
if (def) {
Py_INCREF(def);
SETLOCAL(i, def);
continue;
}
}
missing++;
}
}
// 处理扩展参数位置
kwcount *= kwstep;
for (i = 0; i < kwcount; i += kwstep) {
PyObject **co_varnames;
PyObject *keyword = kwnames[i];
PyObject *value = kwargs[i];
Py_ssize_t j;
...
if (PyDict_SetItem(kwdict, keyword, value) == -1) {
goto fail;
}
continue;
}
...
}python在编译一个函数时, 如果在其形式参数中有*lst这样的扩展位置参数形式或 **keys 时, 那么python会在编译得到的PyCodeObject对象中co_flags中添加标识.
