起步
异常机制经常涉及到 try except finally , 其实, 即使没有这几个异常的语法, python执行过程中抛出的异常还是会被虚拟机扑捉到:
>>> 1/0
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero除数0异常
1 / 0 对应的指令:
0 LOAD_CONST 0 (1)
2 LOAD_CONST 1 (0)
4 BINARY_TRUE_DIVIDE除法操作为:
TARGET(BINARY_TRUE_DIVIDE) {
PyObject *divisor = POP(); // 1
PyObject *dividend = TOP(); // 0
PyObject *quotient = PyNumber_TrueDivide(dividend, divisor);
Py_DECREF(dividend);
Py_DECREF(divisor);
SET_TOP(quotient);
if (quotient == NULL)
goto error;
DISPATCH();
}PyNumber_TrueDivide 在这个函数里面会对对象类型判断最终走上不同的路径, 其最终执行的是:
static PyObject * long_true_divide(PyObject *v, PyObject *w)
{
PyLongObject *a, *b, *x;
Py_ssize_t a_size, b_size, shift, extra_bits, diff, x_size, x_bits;
digit mask, low;
int inexact, negate, a_is_small, b_is_small;
double dx, result;
CHECK_BINOP(v, w);
a = (PyLongObject *)v;
b = (PyLongObject *)w;
a_size = Py_ABS(Py_SIZE(a));
b_size = Py_ABS(Py_SIZE(b));
negate = (Py_SIZE(a) < 0) ^ (Py_SIZE(b) < 0);
if (b_size == 0) {
PyErr_SetString(PyExc_ZeroDivisionError,
"division by zero");
goto error;
}
...
}当发现除数是0时, 调用 PyErr_SetString 抛出异常, 在python对象体系中, 异常本身也是对象, 在 pyerrors.h中就定义了很多异常:
[pyerrors.h]
...
PyAPI_DATA(PyObject *) PyExc_SystemExit;
PyAPI_DATA(PyObject *) PyExc_TypeError;
PyAPI_DATA(PyObject *) PyExc_UnboundLocalError;
PyAPI_DATA(PyObject *) PyExc_UnicodeError;
PyAPI_DATA(PyObject *) PyExc_UnicodeEncodeError;
PyAPI_DATA(PyObject *) PyExc_UnicodeDecodeError;
PyAPI_DATA(PyObject *) PyExc_UnicodeTranslateError;
PyAPI_DATA(PyObject *) PyExc_ValueError;
PyAPI_DATA(PyObject *) PyExc_ZeroDivisionError;记录异常信息
在 PyErr_SetString 后, 会沿着 PyErr_SetString -> PyErr_SetObject -> PyErr_Restore , 在 PyErr_Restore 中, python将存放这个异常:
void PyErr_Restore(PyObject *type, PyObject *value, PyObject *traceback)
{
PyThreadState *tstate = PyThreadState_GET();
PyObject *oldtype, *oldvalue, *oldtraceback;
if (traceback != NULL && !PyTraceBack_Check(traceback)) {
/* XXX Should never happen -- fatal error instead? */
/* Well, it could be None. */
Py_DECREF(traceback);
traceback = NULL;
}
// 保存以前的异常信息
oldtype = tstate->curexc_type;
oldvalue = tstate->curexc_value;
oldtraceback = tstate->curexc_traceback;
// 设置当前的异常信息
tstate->curexc_type = type;
tstate->curexc_value = value;
tstate->curexc_traceback = traceback;
// 抛弃以前的异常信息
Py_XDECREF(oldtype);
Py_XDECREF(oldvalue);
Py_XDECREF(oldtraceback);
}最终 curexc_type 存放下了 PyExc_ZeroDivisionError , 而 curexc_value 存放了字符串 "division by zero" . 当前的活动线程用 PyThreadState_GET 获得, 将异常信息存放到线程状态对象中.
在python的sys模块中, 提供了一个接口, 我们可以访问python虚拟机存在线程状态中的异常信息:
import sys
try:
1/0
except Exception:
print(sys.exc_info()[0]) # 获得tstate->curexc_type
print(sys.exc_info()[1]) # 获得tstate->curexc_value字节码中的异常获取
在除法的实现函数中, 我们看到异常信息记录到了线程状态. 而指令运行完后, 在那个巨大的switch块中该如何处理:
PyObject* _Py_HOT_FUNCTION _PyEval_EvalFrameDefault(PyFrameObject *f, int throwflag)
{
for (;;) {
switch (opcode) {
// 巨大的switch结构
}
assert(why == WHY_NOT);
why = WHY_EXCEPTION; // 通知虚拟机, 异常发生了
// 尝试捕捉异常
if (why != WHY_NOT)
break;
// 创建traceback对象
PyTraceBack_Here(f);
if (tstate->c_tracefunc != NULL)
call_exc_trace(tstate->c_tracefunc, tstate->c_traceobj,
tstate, f);
...
}
}在跳出switch之后, WHY_NOT 状态表示虚拟机状态一切正常, 没有发生错误; 设置为 WHY_EXCEPTION 后, 表示在执行字节码的过程中有异常抛出了. 虚拟机意识到有异常发生后, 它就要开始进入异常处理的流程, 这个流程涉及到PyFrameObject对象链表, 这个链表会是输出的异常信息呈链状结构, 设涉及到一个 traceback 对象, 在这个对象中记录栈帧链表信息, python虚拟机利用这个对象将栈帧表中每一个栈帧当前状态可视化.
[traceback.c]
int PyTraceBack_Here(PyFrameObject *frame)
{
PyObject *exc, *val, *tb, *newtb;
// 获得线程中保存线程状态的 traceback 对象
PyErr_Fetch(&exc, &val, &tb);
// 创建新的traceback对象
newtb = (PyObject *)newtracebackobject((PyTracebackObject *)tb, frame);
if (newtb == NULL) {
_PyErr_ChainExceptions(exc, val, tb);
return -1;
}
PyErr_Restore(exc, val, newtb);
Py_XDECREF(tb);
return 0;
}
void PyErr_Fetch(PyObject **p_type, PyObject **p_value, PyObject **p_traceback)
{
PyThreadState *tstate = PyThreadState_GET();
*p_type = tstate->curexc_type;
*p_value = tstate->curexc_value;
*p_traceback = tstate->curexc_traceback;
tstate->curexc_type = NULL;
tstate->curexc_value = NULL;
tstate->curexc_traceback = NULL;
}PyTracebackObject 是保存在线程状态对象中的, 此结构的定义如下:
[traceback.h]
typedef struct _traceback {
PyObject_HEAD
struct _traceback *tb_next;
struct _frame *tb_frame;
int tb_lasti;
int tb_lineno;
} PyTracebackObject;里面成员 tb_next , 可以看出该对象也和PyFrameObject一样, 是一个链表结构, 这个可以从创建traceback对象得到:
[traceback.c]
static PyTracebackObject * newtracebackobject(PyTracebackObject *next, PyFrameObject *frame)
{
PyTracebackObject *tb;
if ((next != NULL && !PyTraceBack_Check(next)) ||
frame == NULL || !PyFrame_Check(frame)) {
PyErr_BadInternalCall();
return NULL;
}
// 申请对象
tb = PyObject_GC_New(PyTracebackObject, &PyTraceBack_Type);
if (tb != NULL) {
Py_XINCREF(next);
tb->tb_next = next; // 建立链表结构
Py_XINCREF(frame);
tb->tb_frame = frame;
tb->tb_lasti = frame->f_lasti;
tb->tb_lineno = PyFrame_GetLineNumber(frame);
PyObject_GC_Track(tb);
}
return tb;
}next正是前面从线程状态中得到的traceback对象.tb->tb_lineno 是异常处在源代码中对应的行号.
Python虚拟机意识到有异常抛出, 创建了traceback对象后, 就需要开始寻找是否有 except 语句能处理. 如果没有找到, 虚拟机将退出当前活动栈帧, 并沿着栈帧链表回退到上一个栈帧.
PyObject* _Py_HOT_FUNCTION _PyEval_EvalFrameDefault(PyFrameObject *f, int throwflag)
{
for (;;) {
switch (opcode) {
// 巨大的switch结构
}
assert(why == WHY_NOT);
why = WHY_EXCEPTION; // 通知虚拟机, 异常发生了
// 尝试捕捉异常
if (why != WHY_NOT)
break;
// 创建traceback对象
PyTraceBack_Here(f);
if (tstate->c_tracefunc != NULL)
call_exc_trace(tstate->c_tracefunc, tstate->c_traceobj,
tstate, f);
...
}
if (why != WHY_RETURN)
retval = NULL; // 利用retval通知前一个栈帧有异常出现
exit_eval_frame:
if (PyDTrace_FUNCTION_RETURN_ENABLED())
dtrace_function_return(f);
Py_LeaveRecursiveCall();
f->f_executing = 0;
// 将线程状态对象中的活动栈帧设置为上一个栈帧, 完成栈帧回退的动作
tstate->frame = f->f_back;
return _Py_CheckFunctionResult(NULL, retval, "PyEval_EvalFrameEx");
}可以看到, 如果开发人员没有提供任何捕捉异常的动作, 那么程序将帧的返回值设为 retval = NULL; , 通过重新设置当前线程状态对象中的活动栈帧, 完成栈帧回退的动作.
异常控制语义结构
当我们在python代码中提供了异常的捕捉动作又会是什么样的呢:
try:
raise Exception("this is an exception")
except Exception as e:
print(e)
finally:
print("finally code")它的code和字节码:
co_consts : ('this is an exception', None, 'finally code')
co_names : ('Exception', 'e', 'print')
co_stacksize : 23
1 0 SETUP_FINALLY 60 (to 62)
2 SETUP_EXCEPT 12 (to 16)
2 4 LOAD_NAME 0 (Exception)
6 LOAD_CONST 0 ('this is an exception')
8 CALL_FUNCTION 1
10 RAISE_VARARGS 1
12 POP_BLOCK
14 JUMP_FORWARD 42 (to 58)
3 >> 16 DUP_TOP
18 LOAD_NAME 0 (Exception)
20 COMPARE_OP 10 (exception match)
22 POP_JUMP_IF_FALSE 56
24 POP_TOP
26 STORE_NAME 1 (e)
28 POP_TOP
30 SETUP_FINALLY 14 (to 46)
4 32 LOAD_NAME 2 (print)
34 LOAD_NAME 1 (e)
36 CALL_FUNCTION 1
38 POP_TOP
40 POP_BLOCK
42 POP_EXCEPT
44 LOAD_CONST 1 (None)
>> 46 LOAD_CONST 1 (None)
48 STORE_NAME 1 (e)
50 DELETE_NAME 1 (e)
52 END_FINALLY
54 JUMP_FORWARD 2 (to 58)
>> 56 END_FINALLY
>> 58 POP_BLOCK
60 LOAD_CONST 1 (None)
6 >> 62 LOAD_NAME 2 (print)
64 LOAD_CONST 2 ('finally code')
66 CALL_FUNCTION 1
68 POP_TOP
70 END_FINALLY
72 LOAD_CONST 1 (None)
74 RETURN_VALUE前两条 SETUP_FINALLY 和 SETUP_EXCEPT 指令就是申请一块 PyTryBlock , 并设置跳转时的目的地址handler. Exception("this is an exception") 中是通过 CALL_FUNCTION 指令, 该内建函数中会构造出一个异常对象. 创建过程在此不提. 创建后的对象会被压入运行时栈当中. RAISE_VARARGS 指令就是把这个异常对象从运行时栈中取出:
TARGET(RAISE_VARARGS) {
PyObject *cause = NULL, *exc = NULL;
switch (oparg) {
case 2:
cause = POP(); /* cause */
case 1:
exc = POP(); /* exc */
case 0: /* Fallthrough */
if (do_raise(exc, cause)) {
why = WHY_EXCEPTION;
goto fast_block_end;
}
break;
default:
PyErr_SetString(PyExc_SystemError,
"bad RAISE_VARARGS oparg");
break;
}
goto error;
}参数oparg是1, 显然异常对象取出后赋值给了 exc . 然后调用 do_raise 函数. 然后设置 why = WHY_EXCEPTION; 后跳转到 fast_block_end 标记中:
fast_block_end:
/* Unwind stacks if a (pseudo) exception occurred */
while (why != WHY_NOT && f->f_iblock > 0) {
/* Peek at the current block. */
f->f_iblock--;
UNWIND_BLOCK(b);
if (why == WHY_EXCEPTION && (b->b_type == SETUP_EXCEPT
|| b->b_type == SETUP_FINALLY)) {
PyObject *exc, *val, *tb;
...
PyErr_Fetch(&exc, &val, &tb);
...
Py_INCREF(tb);
PUSH(tb);
PUSH(val);
PUSH(exc);
why = WHY_NOT;
JUMPTO(handler);
break;
}在该表机理, 首先从当前PyFrameObject对象中获得 PyTryBlock , 虚拟机通过 PyErr_Fetch 得到了当前现在状态对象中存储的最新的异常对象和traceback对象, 随后将 tb, val,exc分别压入运行时栈中, 并将why设为WHY_NOT, 因为需要处理都设置完毕, 让虚拟机执行路径继续前进. 而接下来处理异常的工作就交给程序员指定的代码来解决, 这个通过 JUMP_FORWARD 实现:
TARGET(JUMP_FORWARD) {
JUMPBY(oparg);
FAST_DISPATCH();
}参数是42, 也就是跳转到48处指令. 在48处指令下文中 POP_JUMP_IF_FALSE ,也就是当没有异常时候, 则再次跳转至56处即finally语句, 如果异常不匹配, 异常信息要重新放回线程状态中, 然后重新设置why的状态, 让python重新进入异常发生状态, 重返异常状态的功能由 END_FINALLY 来完成.
PREDICTED(END_FINALLY);
TARGET(END_FINALLY) {
PyObject *status = POP();
if (PyLong_Check(status)) {
...
}
else if (PyExceptionClass_Check(status)) {
PyObject *exc = POP();
PyObject *tb = POP();
PyErr_Restore(status, exc, tb);
why = WHY_EXCEPTION;
goto fast_block_end;
}
else if (status != Py_None) {
...
}
Py_DECREF(status);
DISPATCH();
}通过 PyErr_Restore 函数将异常信息重新写回线程状态中.
不管异常是否匹配, 最终都要调用 58 POP_BLOCK:
PREDICTED(POP_BLOCK);
TARGET(POP_BLOCK) {
PyTryBlock *b = PyFrame_BlockPop(f);
UNWIND_BLOCK(b);
DISPATCH();
}总结
总结一下, python的异常机制处理中, 最重要的是why所表示的虚拟机状态及PyFrameObject对象中f_blockstack里存放的PyTryBlock对象. 变量why将指明python虚拟机当前是否发生了异常, 而PyTryBlock对象则指示程序员是否为异常设置了 except 代码块和 finally 代码块. python虚拟机处理异常的过程就是 why 和 PyTryBlock 的共同作用下完成的.
