起步
在所有编程语言中, 除了顺序执行外, 控制跳转都是基本的功能, 这节将看看python提供的流程控制, 包括异常机制.
if 控制流
如以下的源码:
a = 1
if a > 10:
print("a > 10")
elif a < -2:
print("a < -2")
elif a == 1:
print("a == 1")
else:
print("unkonwn")对应的code与字节码指令:
co_consts : (1, 10, 'a > 10', 2, 'a < -2', 'a == 1', 'unkonwn', None, -2)
co_names : ('a', 'print')
co_stacksize : 2
1 0 LOAD_CONST 0 (1)
2 STORE_NAME 0 (a)
2 4 LOAD_NAME 0 (a)
6 LOAD_CONST 1 (10)
8 COMPARE_OP 4 (>)
10 POP_JUMP_IF_FALSE 22
3 12 LOAD_NAME 1 (print)
14 LOAD_CONST 2 ('a > 10')
16 CALL_FUNCTION 1
18 POP_TOP
20 JUMP_FORWARD 44 (to 66)
4 >> 22 LOAD_NAME 0 (a)
24 LOAD_CONST 8 (-2)
26 COMPARE_OP 0 (<)
28 POP_JUMP_IF_FALSE 40
5 30 LOAD_NAME 1 (print)
32 LOAD_CONST 4 ('a < -2')
34 CALL_FUNCTION 1
36 POP_TOP
38 JUMP_FORWARD 26 (to 66)
6 >> 40 LOAD_NAME 0 (a)
42 LOAD_CONST 0 (1)
44 COMPARE_OP 2 (==)
46 POP_JUMP_IF_FALSE 58
7 48 LOAD_NAME 1 (print)
50 LOAD_CONST 5 ('a == 1')
52 CALL_FUNCTION 1
54 POP_TOP
56 JUMP_FORWARD 8 (to 66)
9 >> 58 LOAD_NAME 1 (print)
60 LOAD_CONST 6 ('unkonwn')
62 CALL_FUNCTION 1
64 POP_TOP
>> 66 LOAD_CONST 7 (None)
68 RETURN_VALUE比较操作
与其他编程语言语言, 在if语句中, 根据条件的不同, 会选择向左走还是向右走. 从上面第二行源码对应的字节码可知, COMPARE_OP指令进行比较, 在执行一条JUMP指令进行跳转, 比较指令的定义:
[object.h]
#define Py_LT 0
#define Py_LE 1
#define Py_EQ 2
#define Py_NE 3
#define Py_GT 4
#define Py_GE 5
[opcode.h]
enum cmp_op {PyCmp_LT=Py_LT, PyCmp_LE=Py_LE, PyCmp_EQ=Py_EQ, PyCmp_NE=Py_NE,
PyCmp_GT=Py_GT, PyCmp_GE=Py_GE, PyCmp_IN, PyCmp_NOT_IN,
PyCmp_IS, PyCmp_IS_NOT, PyCmp_EXC_MATCH, PyCmp_BAD};大于 PyCmp_GT 操作对应了4, 因此 COMPARE_OP 指令的参数为PyCmp_GT:
TARGET(COMPARE_OP) {
PyObject *right = POP();
PyObject *left = TOP();
PyObject *res = cmp_outcome(oparg, left, right);
Py_DECREF(left);
Py_DECREF(right);
SET_TOP(res);
if (res == NULL)
goto error;
PREDICT(POP_JUMP_IF_FALSE);
PREDICT(POP_JUMP_IF_TRUE);
DISPATCH();
}比较操作都需要两个参数, 因此从栈中弹出两个元素, 调用 cmp_outcome 进行判断, 里面就是一个switch的判断了:
static PyObject * cmp_outcome(int op, PyObject *v, PyObject *w)
{
int res = 0;
switch (op) {
case PyCmp_IS:
res = (v == w);
break;
case PyCmp_IS_NOT:
res = (v != w);
break;
case PyCmp_IN:
...
break;
case PyCmp_NOT_IN:
...
break;
case PyCmp_EXC_MATCH:
...
break;
default:
return PyObject_RichCompare(v, w, op);
}
v = res ? Py_True : Py_False;
Py_INCREF(v);
return v;
}这段代码中还能看到对in和not in的集合的判断操作 PyCmp_IN, PyCmp_NOT_IN , 这就对应了python代码上的if 1 in lst: . 这段打码也看到有进行is操作. 而显然, 例子中的大于操作走的是 PyObject_RichCompare , 在 PyObject_RichCompare 中, 首先会确保比较操作在 Py_LT 和 Py_GE 之间: assert(Py_LT <= op && op <= Py_GE); ; 如果进行比较的两个对象类型相同, 且这两个对象不是用户自定义的类实例, 那么会选择对象对应PyTypeObject定义的 tp_richcompare 操作; 如果类型对象没有定义这个动作, 就选择类型对象中定义的 tp_compare 操作. 在Python中, 无论是内建对象, 还是用户自定义的类实例对象, 其比较操作都是在各自对应的类型对象的 tp_richcompare 或 tp_compare 中. 如果两个都没有, 就报出两个对象不支持比较操作的错误信息了.
bool 对象
比较操作的结果是一个bool值, bool值只有两个,真和假. python中用 Py_True Py_False 表示:
[boolobject.h]
/* Don't use these directly */
PyAPI_DATA(struct _longobject) _Py_FalseStruct, _Py_TrueStruct;
/* Use these macros */
#define Py_False ((PyObject *) &_Py_FalseStruct)
#define Py_True ((PyObject *) &_Py_TrueStruct)c语言中没有bool类型, 采用的是1和0. python一样用int类型充当布尔型:
[boolobject.c]
struct _longobject _Py_FalseStruct = {
PyVarObject_HEAD_INIT(&PyBool_Type, 0)
{ 0 }
};
struct _longobject _Py_TrueStruct = {
PyVarObject_HEAD_INIT(&PyBool_Type, 1)
{ 1 }
};从而可以得知, true和false两个python布尔值是常驻内存的.
指针跳跃
判断语句 if a > 10: 因为a赋值为1, 显然这里判断返回是false, 则需要进行跳转, 跳转指令使用了 PREDICT(POP_JUMP_IF_FALSE) 宏:
#define PREDICT(op) \
do{ \
_Py_CODEUNIT word = *next_instr; \
opcode = _Py_OPCODE(word); \
if (opcode == op){ \
oparg = _Py_OPARG(word); \
next_instr++; \
goto PRED_##op; \
} \
} while(0)
#define PREDICTED(op) PRED_##op:这两个宏意味着, 如果有个地方使用了宏 PREDICTED(POP_JUMP_IF_FALSE); 那这个地方会替换为 PRED_POP_JUMP_IF_FALSE: , 用来作为 goto 的跳转点, 因此判断的结果就可以为:
...
if (*next_instr == POP_JUMP_IF_FALSE)
goto PRED_POP_JUMP_IF_FALSE;
if (*next_instr == POP_JUMP_IF_TRUE)
goto PRED_POP_JUMP_IF_TRUEgoto指令目录是为了绕过一些无谓的操作:
PREDICTED(POP_JUMP_IF_FALSE);
TARGET(POP_JUMP_IF_FALSE) {
PyObject *cond = POP(); // 获取条件判断的结果
int err;
if (cond == Py_True) { // true 顺序执行
Py_DECREF(cond);
FAST_DISPATCH();
}
if (cond == Py_False) { // false 进行跳转
Py_DECREF(cond);
JUMPTO(oparg);
FAST_DISPATCH();
}
err = PyObject_IsTrue(cond); // 通用判断
Py_DECREF(cond);
if (err > 0)
;
else if (err == 0)
JUMPTO(oparg);
else
goto error;
DISPATCH();
}优先会判断bool类型的, 通用因为要兼容如if s: 或 if xx_obj: 这种没有比较操作的布尔判断. 而最终进行跳转是宏 JUMPTO(oparg) 其中, 根据上下文可知参数 oparg = 22:
#define JUMPTO(x) (next_instr = first_instr + (x) / sizeof(_Py_CODEUNIT))_Py_CODEUNIT 是 uint16_t 的别名 typedef uint16_t _Py_CODEUNIT; 因此它的sizeof是2. 这边就是将指令跳到第11条指令了.
for 循环控制
在if控制中, 只存在两个分支结构, 也就是字节码指令仍然是向前跳跃的. 相对的, for循环则可以让指令回退. 例如如下的代码:
lst = [1, 2]
for i in lst:
print(i)对应的code和字节码指令:
co_consts : (1, 2, None)
co_names : ('lst', 'i', 'print')
co_stacksize : 3
1 0 LOAD_CONST 0 (1)
2 LOAD_CONST 1 (2)
4 BUILD_LIST 2
6 STORE_NAME 0 (lst)
2 8 SETUP_LOOP 20 (to 30)
10 LOAD_NAME 0 (lst)
12 GET_ITER
>> 14 FOR_ITER 12 (to 28)
16 STORE_NAME 1 (i)
3 18 LOAD_NAME 2 (print)
20 LOAD_NAME 1 (i)
22 CALL_FUNCTION 1
24 POP_TOP
26 JUMP_ABSOLUTE 14
>> 28 POP_BLOCK
>> 30 LOAD_CONST 2 (None)
32 RETURN_VALUE循环结构初始化
for循环控制从 SETUP_LOOP 指令开始的:
TARGET(SETUP_LOOP)
TARGET(SETUP_EXCEPT)
TARGET(SETUP_FINALLY) {
PyFrame_BlockSetup(f, opcode, INSTR_OFFSET() + oparg,
STACK_LEVEL());
DISPATCH();
}SETUP_LOOP 的实现中仅仅是简单调用一下 PyFrame_BlockSetup 函数:
[frameobject.c]
void PyFrame_BlockSetup(PyFrameObject *f, int type, int handler, int level)
{
PyTryBlock *b;
if (f->f_iblock >= CO_MAXBLOCKS) // #define CO_MAXBLOCKS 20
Py_FatalError("XXX block stack overflow");
b = &f->f_blockstack[f->f_iblock++];
b->b_type = type;
b->b_level = level;
b->b_handler = handler;
}CO_MAXBLOCKS 被定义为20, 暂时不清楚这意味着什么, f->f_iblock 在 PyFrame_New 中初始化为0;关于 PyTryBlock 的定义如下:
[frameobject.h]
typedef struct {
int b_type; /* what kind of block this is */
int b_handler; /* where to jump to find handler */
int b_level; /* value stack level to pop to */
} PyTryBlock;PyTryBlock 除了循环控制, 在异常机制中也有用到.
list 迭代器
SETUP_LOOP 指令是从PyFrameObject的f_blockstack中申请一块PyTryBlock, 再通过 GET_ITER 获取list对象的迭代器:
TARGET(GET_ITER) {
/* before: [obj]; after [getiter(obj)] */
PyObject *iterable = TOP();
PyObject *iter = PyObject_GetIter(iterable);
Py_DECREF(iterable);
SET_TOP(iter);
if (iter == NULL)
goto error;
PREDICT(FOR_ITER);
PREDICT(CALL_FUNCTION);
DISPATCH();
}其中 #define TOP() (stack_pointer[-1]) ,居然有个负数索引? 我们知道, 对于一个数组array, array[i] 相当于 (array + i) . 那array[-1] 也就相当于 (array - 1) , 这样做虽然不安全却完全合法. 而SET_TOP就是 #define SET_TOP(v) (stack_pointer[-1] = (v)) , 这段替换成POP和PUSH也完全没问题. 总之, GET_ITER 指令是先从运行时栈中获取栈顶上的PyListObject对象, 然后通过 PyObject_GetIter 获取迭代器:
[abstract.c]
PyObject * PyObject_GetIter(PyObject *o)
{
PyTypeObject *t = o->ob_type;
getiterfunc f;
f = t->tp_iter; // 获得类型对象的tp_iter操作
if (f == NULL) {
if (PySequence_Check(o))
return PySeqIter_New(o);
// 不支持迭代操作
return type_error("'%.200s' object is not iterable", o);
}
else {
// 通过tp_iter操作获得iterator
PyObject *res = (*f)(o);
return res;
}
}显然 PyObject_GetIter 是通过类型对象的 tp_iter 操作获得与对象关联的迭代器, 迭代器的概念类似于STL, 都是为容器元素遍历提供一层接口, 实现遍历操作与容器的具体分离. 而迭代器也是一个python对象:
[listobject.c]
typedef struct {
PyObject_HEAD
Py_ssize_t it_index;
PyListObject *it_seq; /* Set to NULL when iterator is exhausted */
} listiterobject;既然迭代器是PyObject对象, 那它肯定也有对应的类型对象:
PyTypeObject PyListIter_Type = {
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"list_iterator", /* tp_name */
sizeof(listiterobject), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
(destructor)listiter_dealloc,
...
PyObject_SelfIter, /* tp_iter */
(iternextfunc)listiter_next, /* tp_iternext */
listiter_methods, /* tp_methods */
0, /* tp_members */
};在 PyList_Type 中成员 tp_iter 赋值为 list_iter , 这就是前面的f, 也正是创建迭代器对象的实现所在:
[listobject.c]
static PyObject * list_iter(PyObject *seq)
{
listiterobject *it;
if (!PyList_Check(seq)) {
PyErr_BadInternalCall();
return NULL;
}
it = PyObject_GC_New(listiterobject, &PyListIter_Type);
if (it == NULL)
return NULL;
it->it_index = 0;
Py_INCREF(seq);
it->it_seq = (PyListObject *)seq; // 这个seq是之前创建的PyListObject对象
_PyObject_GC_TRACK(it);
return (PyObject *)it;
}从这可以看出, 迭代器是list上的一层封装, list对象只是迭代器中成员 it_seq . 迭代器维护了当前访问的元素在list对象中的序号即 it_index , 实现了对list的遍历.
GET_ITER指令之后就是FOR_ITER了.
迭代控制
获得数组迭代器后, 就应该进入一个循环结构了:
PREDICTED(FOR_ITER);
TARGET(FOR_ITER) {
/* before: [iter]; after: [iter, iter()] *or* [] */
PyObject *iter = TOP(); // 取得迭代器对象
// 通过迭代器对象获取集合中下一个元素对象
PyObject *next = (*iter->ob_type->tp_iternext)(iter);
if (next != NULL) {
// 入栈
PUSH(next);
PREDICT(STORE_FAST);
PREDICT(UNPACK_SEQUENCE);
DISPATCH();
}
/* iterator ended normally */
// next = NULL 迭代正常结束
STACKADJ(-1);
Py_DECREF(iter);
JUMPBY(oparg);
PREDICT(POP_BLOCK);
DISPATCH();
}FOR_ITER指令首先从运行时栈中获得迭代器对象, 然后调用 tp_iternext 进行迭代. 该函数总是返回与迭代器关联的容器的下一个元素, 如果已经遍历完毕则返回NULL.
获得一个有效元素后, 将这个元素入栈, PREDICT(STORE_FAST); PREDICT(UNPACK_SEQUENCE); 会做一些字节码预测, 这边就假设这两句不存在吧.
[listobject.c]
static PyObject * listiter_next(listiterobject *it)
{
PyListObject *seq;
PyObject *item;
assert(it != NULL);
seq = it->it_seq;
if (seq == NULL)
return NULL;
assert(PyList_Check(seq));
if (it->it_index < PyList_GET_SIZE(seq)) {
item = PyList_GET_ITEM(seq, it->it_index);
++it->it_index;
Py_INCREF(item);
return item;
}
it->it_seq = NULL;
Py_DECREF(seq);
return NULL;
}大概意思就是 return it->it_seq->ob_item[ it->it_index++ ]; , 这之后python虚拟机沿着字节码顺序一条一条执行下去. 完成输出后有个 JUMP_ABSOLUTE 参数是14:
TARGET(JUMP_ABSOLUTE) {
JUMPTO(oparg);
DISPATCH();
}跳转到 14 FOR_ITER 12 (to 28) 指令, 也就是进行下一次循环,
终止迭代
当 FOR_ITER 指令中迭代器遍历完成, 返回NULL值后, 执行 JUMPBY(oparg); 显然这里参数为12:
#define JUMPBY(x) (next_instr += (x) / sizeof(_Py_CODEUNIT))也就是将栈指针向前偏移6个指令, 也就是到 >> 28 POP_BLOCK :
PREDICTED(POP_BLOCK);
TARGET(POP_BLOCK) {
PyTryBlock *b = PyFrame_BlockPop(f);
UNWIND_BLOCK(b);
DISPATCH();
}其中宏 UNWIND_BLOCK 定义为:
#define UNWIND_BLOCK(b) \
while (STACK_LEVEL() > (b)->b_level) { \
PyObject *v = POP(); \
Py_XDECREF(v); \
}
#define STACK_LEVEL() ((int)(stack_pointer - f->f_valuestack))在执行 POP_BLOCK 的指令时, 会获取在 SETUP_LOOP 处申请的 PyTryBlock 结构, 实际上是将这个PyTryBlock结构归还给f->f_blockstack, 同时, 虚拟机会将运行时栈的深度信息恢复到SETUP_LOOP之前的状态, 从而完成整个for循环结构.
while 循环结构
对于代码:
a = 0
while a < 10:
a += 1
if a == 5:
continue
if a == 7:
break
print(a)对应的code和字节码:
co_consts : (0, 10, 1, 5, 7, None)
co_names : ('a', 'print')
co_stacksize : 2
1 0 LOAD_CONST 0 (0)
2 STORE_NAME 0 (a)
2 4 SETUP_LOOP 48 (to 54)
>> 6 LOAD_NAME 0 (a)
8 LOAD_CONST 1 (10)
10 COMPARE_OP 0 (<)
12 POP_JUMP_IF_FALSE 52
3 14 LOAD_NAME 0 (a)
16 LOAD_CONST 2 (1)
18 INPLACE_ADD
20 STORE_NAME 0 (a)
4 22 LOAD_NAME 0 (a)
24 LOAD_CONST 3 (5)
26 COMPARE_OP 2 (==)
28 POP_JUMP_IF_FALSE 32
5 30 JUMP_ABSOLUTE 6
6 >> 32 LOAD_NAME 0 (a)
34 LOAD_CONST 4 (7)
36 COMPARE_OP 2 (==)
38 POP_JUMP_IF_FALSE 42
7 40 BREAK_LOOP
8 >> 42 LOAD_NAME 1 (print)
44 LOAD_NAME 0 (a)
46 CALL_FUNCTION 1
48 POP_TOP
50 JUMP_ABSOLUTE 6
>> 52 POP_BLOCK
>> 54 LOAD_CONST 5 (None)
56 RETURN_VALUEwhile循环一样通过 SETUP_LOOP 申请一块PyTryBlock空间. 这节主要探究 continue 和 break.
continue 指令
当 a == 5 判断为true时, 执行了 continue 也就是对应指令中的 30 JUMP_ABSOLUTE 6:
PREDICTED(JUMP_ABSOLUTE);
TARGET(JUMP_ABSOLUTE) {
JUMPTO(oparg);
DISPATCH();
}
oparg的值是6, 这里就讲流程跳转到 6 LOAD_NAME 0 (a) 处了, 继续进行下一次的while判断.
break 指令
当 a == 5 判断为true时, 执行了 break 语句:
TARGET(BREAK_LOOP) {
why = WHY_BREAK;
goto fast_block_end;
}将python虚拟机状态设置为 WHY_BREAK , 然后进入 fast_block_end 代码处. 该处也包含了异常处理机制的处理, 这里只显示和break相关:
fast_block_end:
/* Unwind stacks if a (pseudo) exception occurred */
while (why != WHY_NOT && f->f_iblock > 0) {
/* Peek at the current block. */
PyTryBlock *b = &f->f_blockstack[f->f_iblock - 1];
...
f->f_iblock--;
UNWIND_BLOCK(b);
if (b->b_type == SETUP_LOOP && why == WHY_BREAK) {
why = WHY_NOT;
JUMPTO(b->b_handler);
break;
}
...
}首先得到在 SETUP_LOOP 指令申请的PyTryBlock, 将why值设为WHY_NOT, 表明退出状态没有任何错误, 再通过宏 JUMPTO 将虚拟机中下一条指令的指示器 next_instr 设置为距离code开始位置 b->b_handler 处的位置.
在执行 SETUP_LOOP 时, b->b_handler 是被设置为 INSTR_OFFSET() + oparg 的, 其中宏:
#define INSTR_OFFSET() (sizeof(_Py_CODEUNIT) * (int)(next_instr - first_instr))因此在指令 4 SETUP_LOOP 48 (to 54) 中, 此时, oparg = 48, (sizeof(_Py_CODEUNIT) * (int)(next_instr - first_instr)) 中, 下一条指令next_instr - first_instr是下一条在第一条的偏移量, 每条指令占两个字节, next_instr是第4条指令,所以next_instr - first_instr=_Py_CODEUNIT[3]-_Py_CODEUNIT[0] = 3.
所以 b->b_handler = INSTR_OFFSET() + oparg = (2 * (3 - 0) + 48 = 54
因为#define JUMPTO(x) (next_instr = first_instr + (x) / sizeof(_Py_CODEUNIT))
因此 JUMPTO(b->b_handler) 的动作就是, next_instr = 0 + 54 / 2 = 27. 也就是第27条指令:54 LOAD_CONST 5 (None) , 它已经跳出while循环了.
