一文带你深度解密Python的字节码

typedef struct {
    //头部信息，我们看到真的一切皆对象，字节码也是个对象
    PyObject_HEAD    
    //可以通过位置参数传递的参数个数
    int co_argcount;            
    //只能通过位置参数传递的参数个数，Python3.8新增
    int co_posonlyargcount;     
    //只能通过关键字参数传递的参数个数
    int co_kwonlyargcount;     
    //代码块中局部变量的个数，也包括参数
    int co_nlocals;             
    //执行该段代码块需要的栈空间
    int co_stacksize;      
    //参数类型标识    
    int co_flags;           
    //代码块在文件中的行号  
    int co_firstlineno;         
    //指令集，也就是字节码，它是一个bytes对象 
    PyObject *co_code;         
    //常量池，一个元组，保存代码块中的所有常量 
    PyObject *co_consts;       
    //一个元组，保存代码块中引用的其它作用域的变量
    PyObject *co_names;      
    //一个元组，保存当前作用域中的变量   
    PyObject *co_varnames;    
    //内层函数引用的外层函数的作用域中的变量
    PyObject *co_freevars;      
    //外层函数的作用域中被内层函数引用的变量
    //本质上和co_freevars是一样的
    PyObject *co_cellvars;      
    //无需关注
    Py_ssize_t *co_cell2arg;    
    //代码块所在的文件名
    PyObject *co_filename;    
    //代码块的名字，通常是函数名、类名，或者文件名
    PyObject *co_name;         
    //字节码指令与python源代码的行号之间的对应关系
    //以PyByteObject的形式存在 
    PyObject *co_lnotab;        
} PyCodeObject;

class A:
    a = 123

def foo():
    a = []

def func():
    pass

print(func.__code__)  # <code object ......
print(type(func.__code__))  # <class 'code'>

def foo(a, b, c=3):
    pass
print(foo.__code__.co_argcount)  # 3

def bar(a, b, *args):
    pass
print(bar.__code__.co_argcount)  # 2

def func(a, b, *args, c):
    pass
print(func.__code__.co_argcount)  # 2

def foo(a, b, c):
    pass

print(foo.__code__.co_posonlyargcount)  # 0

def bar(a, b, /, c):
    pass

print(bar.__code__.co_posonlyargcount)  # 2

def foo(a, b=1, c=2, *, d, e):
    pass
print(foo.__code__.co_kwonlyargcount)  # 2

def foo(a, b, *, c):
    name = "xxx"
    age = 16
    gender = "f"
    c = 33

print(foo.__code__.co_nlocals)  # 6

def foo(a, b, *, c):
    name = "xxx"
    age = 16
    gender = "f"
    c = 33

print(foo.__code__.co_stacksize)  # 1

def foo1():
    pass
# 结果全部为假
print(foo1.__code__.co_flags & 0x04)  # 0
print(foo1.__code__.co_flags & 0x08)  # 0

def foo2(*args):
    pass
# co_flags & 0x04 为真，因为出现了 *args
print(foo2.__code__.co_flags & 0x04)  # 4
print(foo2.__code__.co_flags & 0x08)  # 0

def foo3(*args, **kwargs):
    pass
# 显然 co_flags & 0x04 和 co_flags & 0x08 均为真
print(foo3.__code__.co_flags & 0x04)  # 4
print(foo3.__code__.co_flags & 0x08)  # 8

# 如果是生成器函数
# 那么 co_flags & 0x20 为真
def foo1():
    yield
print(foo1.__code__.co_flags & 0x20)  # 32

# 如果是协程函数
# 那么 co_flags & 0x80 为真
async def foo2():
    pass
print(foo2.__code__.co_flags & 0x80)  # 128
# 显然 foo2 不是生成器函数
# 所以 co_flags & 0x20 为假
print(foo2.__code__.co_flags & 0x20)  # 0

# 如果是异步生成器函数
# 那么 co_flags & 0x200 为真
async def foo3():
    yield
print(foo3.__code__.co_flags & 0x200)  # 512
# 显然它不是生成器函数、也不是协程函数
# 因此和 0x20、0x80 按位与之后，结果都为假
print(foo3.__code__.co_flags & 0x20)  # 0
print(foo3.__code__.co_flags & 0x80)  # 0

def foo(a, b, *, c):
    pass

# 显然是文件的第一行
# 或者理解为 def 所在的行
print(foo.__code__.co_firstlineno)  # 1

def foo():
    return bar

def bar():
    pass

print(foo().__code__.co_firstlineno)  # 4

c = 1

def foo(a, b):
    print(a, b, c)
    d = (list, int, str)

print(
    foo.__code__.co_names
)  # ('print', 'c', 'list', 'int', 'str')

c = 1

def foo(a, b):
    print(a, b, c)
    d = (list, int, str)
print(foo.__code__.co_varnames)  # ('a', 'b', 'd')

x = 123

def foo(a, b):
    c = "abc"
    print(x)
    print(True, False, list, [1, 2, 3], {"a": 1})
    return ">>>"

print(
    foo.__code__.co_consts
)  # (None, 'abc', True, False, 1, 2, 3, 'a', '>>>')

def foo():
    pass
# 这里就是函数名
print(foo.__code__.co_name)  # foo

def foo(a, b, /, c, *, d, e):
    f = 123
    g = list()
    g.extend([tuple, getattr, print])

print(foo.__code__.co_code)
#b'd\x01}\x05t\x00\x83\x00}\x06|\x06......'

#define POP_TOP                   1
#define ROT_TWO                   2
#define ROT_THREE                 3
#define DUP_TOP                   4
#define DUP_TOP_TWO               5
#define NOP                       9
#define UNARY_POSITIVE           10
#define UNARY_NEGATIVE           11
#define UNARY_NOT                12
#define UNARY_INVERT             15
#define BINARY_MATRIX_MULTIPLY   16
#define INPLACE_MATRIX_MULTIPLY  17
#define BINARY_POWER             19
#define BINARY_MULTIPLY          20
#define BINARY_MODULO            22
#define BINARY_ADD               23
#define BINARY_SUBTRACT          24
#define BINARY_SUBSCR            25
#define BINARY_FLOOR_DIVIDE      26
#define BINARY_TRUE_DIVIDE       27
#define INPLACE_FLOOR_DIVIDE     28
// ...
// ...

# Python中的dis模块专门负责干这件事情
import dis

def foo(a, b):
    c = a + b
    return c

# 里面接收一个字节码
# 当然函数也是可以的，会自动获取co_code
dis.dis(foo)
"""
  5           0 LOAD_FAST                0 (a)
              2 LOAD_FAST                1 (b)
              4 BINARY_ADD
              6 STORE_FAST               2 (c)

  6           8 LOAD_FAST                2 (c)
             10 RETURN_VALUE
"""

from opcode import opmap

opmap = {v: k for k, v in opmap.items()}

def foo(a, b):
    c = a + b
    return c

code = foo.__code__.co_code
for i in range(0, len(code), 2):
    print("操作码: {:<12} 操作数: {}".format(
        opmap[code[i]], code[i+1]
    ))
"""
操作码: LOAD_FAST    操作数: 0
操作码: LOAD_FAST    操作数: 1
操作码: BINARY_ADD   操作数: 0
操作码: STORE_FAST   操作数: 2
操作码: LOAD_FAST    操作数: 2
操作码: RETURN_VALUE 操作数: 0
"""