在学习和使用python的过程中，难免碰到一些不理解的地方，有时候还会因此踩到坑里许久爬不出来。这种情况下，一种解决问题的手段是，查看python 代码“编译”后的中间代码序列。同许多虚拟机托管型语言一样，python 的前端编译器将python代码转译为自己定义的中间代码，中间代码会被虚拟机解释执行（如python等脚本型语言），或者经过二次（部分）编译为native代码运行（如java，c#）。中间代码通常都有两种等价的表现形式，一种是方便机器执行的bytecode 形式，另一种则是方便程序员阅读的指令序列形式。通过python的dis模块，我们可以轻松得到一个python函数对应的指令序列。

dis模块

dis 模块是python 的所谓反汇编模块，功能是将字节码转为可阅读的指令码。

dis中的重要api：

• dis.dis

解析一个bytesource object，所谓bytesourse object 指的是含有code object 的对象
（module，class，method，function...etc）

针对于不同的对象类型，dis的效果不同:

• dis.distb

解析当前出现异常的函数的指令序列，用于调试。

例子：

try:
    result = 1/0
except:
    import dis
    import sys
    exc_type, exc_value, exc_tb = sys.exc_info()
    dis.distb(exc_tb)

指令码（opcode）列表

注意：下文中的tos 代表栈顶元素，tos1 代表次栈顶元素，依次类推。。。

栈中元素移动操作

NOP

不做动作，占位指令，用于优化

POP_TOP

函数栈顶元素出栈

ROT_TWO

栈顶的头两个元素交换位置

ROT_THREE

栈顶的头三个元素做如下循环位移变换：
3->2, 2->1, 1->3

ROT_FOUR

栈顶的头四个元素做循环位移变换

DUP_TOP

把栈顶元素复制一份压回栈中

DUP_TOPX(count)

把栈顶的count 个元素复制一份，保持原有顺序压回栈中，其中1<=count<=5

一元运算

将栈顶元素取出，进行操作，再push回栈中。

UNARY_NEGATIVE()

取负：TOS = -TOS.

UNARY_NOT()

一元取反： TOS = not TOS.

UNARY_INVERT()

一元按位取反：TOS = ~TOS.

GET_ITER()

取迭代器： TOS = iter(TOS)
在for 语句中用到，执行type(TOS).tp_iter 创建迭代器

二元运算

将栈顶的前两个元素取出进行计算，结果压回栈中

BINARY_POWER()

幂运算： TOS = TOS1 ** TOS.

BINARY_MULTIPLY()

乘法运算：TOS = TOS1 * TOS.

BINARY_DIVIDE()

除法 TOS = TOS1 / TOS

3/2=1

BINARY_TRUE_DIVIDE()

保存浮点精度的除法 TOS = TOS1 / TOS
引入 future.division 后，除号对应的指令替换为binary_true_divide

from __future__ import division 
3/2=1.5

BINARY_FLOOR_DIVIDE()

保存浮点精度的除法： TOS = TOS1 // TOS.
3//2=1.5

BINARY_MODULO()

取模运算 TOS = TOS1 % TOS.

BINARY_ADD()

加法： TOS = TOS1 + TOS.

BINARY_SUBTRACT()

减法： TOS = TOS1 - TOS.

BINARY_LSHIFT()

左移：TOS = TOS1 << TOS.

BINARY_RSHIFT()

右移： TOS = TOS1 >> TOS.

BINARY_AND()

与运算 ：TOS = TOS1 & TOS.

BINARY_XOR()

异或运算 ：TOS = TOS1 ^ TOS.

BINARY_OR()

或运算：TOS = TOS1 | TOS.

in place 运算

计算结果可以被操作数引用的到
看起来，就是不耗费额外的空间存储结果
每一个 二元运算，都对应一个inplace 运算

INPLACE_POWER()

INPLACE_MULTIPLY()

INPLACE_DIVIDE()

INPLACE_FLOOR_DIVIDE()

INPLACE_TRUE_DIVIDE()

INPLACE_MODULO()

INPLACE_ADD()

INPLACE_SUBTRACT()

INPLACE_LSHIFT()

INPLACE_RSHIFT()

INPLACE_AND()

INPLACE_XOR()

INPLACE_OR()

切片操作

访问

SLICE

Implements TOS = TOS[:].

SLICE_1

Implements TOS = TOS1[TOS:].

SLICE_2

Implements TOS = TOS1[:TOS].

SLICE_3

Implements TOS = TOS2[TOS1:TOS].

赋值

不会对栈空间本身压入任何东西

STORE_SLICE+0()

TOS[:] = TOS1.影响的是 栈上存储的操作数 TOS(实际上是PyList_Object)对象所引用的list

STORE_SLICE+1()

TOS1[TOS:] = TOS2.

STORE_SLICE+2()

TOS1[:TOS] = TOS2.

STORE_SLICE+3()

TOS2[TOS1:TOS] = TOS3.

删除

DELETE_SLICE+0()

del TOS[:].

DELETE_SLICE+1()

del TOS1[TOS:].

DELETE_SLICE+2()

del TOS1[:TOS].

DELETE_SLICE+3()

del TOS2[TOS1:TOS].

下标访问操作

BINARY_SUBSCR()

索引运算： TOS = TOS1[TOS].

STORE_SUBSCR()

TOS1[TOS] = TOS2.

DELETE_SUBSCR()

del TOS1[TOS].

打印操作

PRINT_ITEM()

打印栈顶元素到标准输出

PRINT_NEWLINE()

打印回车

break && continue

BREAK_LOOP()

break语句
原理：取pytry_block 中的handler 获取循环结束后的下一条指令地址，从而完成跳出循环操作

CONTINUE_LOOP(target)

continue 语句
实际的代码中，没有见到使用，用的是jump 指令

返回值系列

RETURN_VALUE

将栈顶元素tos返回给函数调用者

YIELD_VALUE

将栈顶元素tos 作为生成器返回值返回。

import 系列

IMPORT_STAR

将栈顶module 对象中全部的名字（非_ 开头）引入到当前local名字空间中，栈顶module 弹栈.
用于实现
from module import *

IMPORT_NAME(name)

实现import xxx，引发整个import 逻辑，最后只返回一个根module，给名字空间引用
最后将一个module object 压栈，接着跟一个store

IMPORT_FROM(name)

实现 from xxx import xxx，引发整个import 逻辑，最后返回相应的module 给名字空间引用
最后将一个module object 压栈，接着跟一个store

block 与异常

POP_BLOCK()

将当前py_tryblock 从栈f_blockstack弹出，py_tryblock 是用于记录 循环，异常跳转地址等信息的数据结构.

pyTryBlock 结构的定义:

typedef struct{
    int b_type;  //SETUP_LOOP/SETUP_EXCEPTION给出跳出正常指令流的原因
    int b_handler;  //给出下一条指令的地址。
};

pyTryBlock 定义在 pyFrameObject 中

PyFrameObject{
    pyTryBlockstack  f_blockstack[20]   // 最大为20  意味着不能有嵌套20层以上的循环或者异常
    int f_iblock 
}

END_FINALLY

当异常不匹配时，重新保存异常信息，设置异常发生状态标识，开始栈展开动作

RAISE_VARARGS(argc)

对应于raise 语句，argc 指定了raise语句后面跟的参数个数，参数个数范围为0-3

SETUP_LOOP(delta)

占用一个py_tryblock，类型设置为loop

SETUP_EXCEPT(delta)

占用一个py_tryblock，类型设置为except

SETUP_FINALLY(delta)

占用一个py_tryblock，类型设置为finally

build 系列

BUILD_CLASS

利用当前栈上信息创建类
执行build class 之前栈上准备好的信息有：
method_dic 基类名 元组类名

BUILD_TUPLE(count)

创建元祖 从栈顶取count 个元素，创建一个元素对象再压入栈中

BUILD_LIST(count)

创建列表，原理同tuple

BUILD_SET(count)

创建集合，原理同tuple

BUILD_MAP(count)

创建map，原理同tuple，单个元素为（PyDictEntry）

typedef struct{
hash
key
value
}PydictEntry；

BUILD_SLICE(argc)

创建一个slice 对象，slice对象 就是用来保存切片操作的三个参数（start，stop，step）的，
用于切片操作里的参数传递。

myslice = slice(0，5，1) # 生成一个切片对象   
l = list(range(10))  #创建一个list
print l[myslice]  #将切片对象应用于切片操作

make，创建函数（闭包）pyfunctionobject对象

MAKE_FUNCTION(argc)

创建一个pyfunctionobject，并将其压栈

栈上参数准备：code obj，默认参数1，默认参数2...

pyfunctionobject.func_code=code obj
pyfunctionobjec.func_defaults=tuple(默认参数1，默认参数2...)

MAKE_CLOSURE(argc)

创建一个pyfunctionobject，并将其压栈

栈上参数准备：code obj，cell_tuple，默认参数1，默认参数2
pyfunctionobject.func_code=code obj
pyfucntionobject.func_closure=cell_tuple
pyfunctionobjec.func_defaults=tuple(默认参数1，默认参数2...)

with 语句

SETUP_WITH

调用对象的enter

WITH_CLEANUP

调用对象的exit

赋值，访问名字

1.访问name：

以lgb 规则访问名字空间

（frame->f_locals,frame->f_globals,frame->f_builtins）

STORE_NAME

为名字赋一个引用对象，对象由栈顶弹栈得到

DELETE_NAME

del name

LOAD_NAME

将名字引用的对象压栈

2.访问全局变量

STORE_GLOBAL

LOAD_GLOBAL

DEL_GLOBAL

3.访问对象中的属性

STORE_ATTR

LOAD_ATTR

DELETE_ATTR

4.访问函数内部的局部变量，参数等

STORE_FAST

LOAD_FAST

DELETE_FAST

5.访问函数闭包的pycellobject

位于pyframeobject.f_localsplus 的freevars部分（里面保存cell，free对象）

STORE_DEREF

LOAD_DEREF （用于闭包函数对象调用）

LOAD_CLOSURE （用于闭包函数对象创建）

DELETE_DEREF

6.访问常量

LOAD_CONST

跳转系列

COMPARE_OP(opname)

对栈顶的两个元素做opname 指定的比较操作，运算结果压栈

JUMP_FORWARD(delta)

相对跳转，向前跳delta 字节

POP_JUMP_IF_TRUE(target)

如果当前栈顶结果为true，那么向前跳转至target，同时tos 弹栈

POP_JUMP_IF_FALSE(target)

如果当前栈顶结果为false，那么向前跳转至target，同时tos 弹栈

JUMP_IF_TRUE_OR_POP(target)

如果当前栈顶结果为true，那么向前跳转至target，同时保留tos，否则tos 弹栈

JUMP_IF_FALSE_OR_POP(target)

如果当前栈顶结果为false，那么向前跳转至target，同时保留tos，否则tos 弹栈

call 系列

CALL_FUNCTION(argc)

调用一个函数
调用该指令前，需要将pyfuntionobject，和实参（位置参数，键参数）压栈
在创建类时，也有调用（联想闭包的创建，凡是嵌套的def 定义，都是要在执行时创建，所以需要call 来执行）