Python 源码编译过程

Python 源码到机器码的过程，以 CPython 为例，编译过程如下：

将源代码解析为解析树（Parser Tree）
将解析树转换为抽象语法树（Abstract Syntax Tree）
将抽象语法树转换到控制流图（Control Flow Graph）
根据流图将字节码（bytecode）发送给虚拟机（ceval）

可以使用以下模块进行操作：

ast 模块可以控制抽象语法树的生成和编译
py-compile 模块能够将源码换成字节码（编译），保存在 __pycache__ 文件夹，以 .pyc 结尾（不可读）
dis 模块通过反汇编支持对字节码的分析（可读）

ast 模块使用

ast 模块可以用于生成和编译 Python 代码的抽象语法树，许多静态分析工具都使用该模块生成抽象语法树。

ast.parse() 函数可以用来生成抽象语法树，ast.compile() 可以将抽象语法树编译为代码。

用下列代码作为测试样例：

def nums():
    for i in range(2):
        if i % 2 == 0:
            print("even: ", i)
        else:
            print(" odd: ", i)

nums()

编译执行

代码对象是 CPython 实现的低级细节，涉及 code 模块，该模块是解释器基类，可用于自定义 Python 解释器。

# 读取源文件
with open("demo.py") as f:
    data = f.read()

# 生成可以被 exec() 或 eval() 执行的代码对象
cm = compile(data, '<string>', 'exec')
exec(cm)

生成 AST

直接从源码生成，Python 3.9 支持 indent 参数，打印输出更为友好。

1 2	f_ast = ast.parse(data) print(ast.dump(f_ast, indent=4))

得到如下结果：

Module( # 第一级，模块
    body=[
        FunctionDef( # 第二级，函数定义
            name='nums', # 函数名称
            args=arguments( # 参数
                posonlyargs=[],
                args=[],
                kwonlyargs=[],
                kw_defaults=[],
                defaults=[]),
            body=[ # 函数体
                For( # 循环
                    target=Name(id='i', ctx=Store()),
                    iter=Call( # 递归函数调用
                        func=Name(id='range', ctx=Load()),
                        args=[
                            Constant(value=2)], # 参数
                        keywords=[]),
                    body=[ # 循环体
                        If( # 条件判断
                            test=Compare(# 比较
                                left=BinOp( # 左操作数
                                    left=Name(id='i', ctx=Load()), # 左操作数
                                    op=Mod(), # 操作符
                                    right=Constant(value=2)), # 右操作数
                                ops=[
                                    Eq()],
                                comparators=[ # 右操作数
                                    Constant(value=0)]),
                            body=[ # 为真
                                Expr(
                                    value=Call( # 调用函数
                                        func=Name(id='print', ctx=Load()),
                                        args=[
                                            Constant(value='even: '),
                                            Name(id='i', ctx=Load())],
                                        keywords=[]))],
                            orelse=[ # 为假
                                Expr(
                                    value=Call( # 调用函数
                                        func=Name(id='print', ctx=Load()),
                                        args=[
                                            Constant(value=' odd: '),
                                            Name(id='i', ctx=Load())],
                                        keywords=[]))])],
                    orelse=[])],
            decorator_list=[]),
        Expr( # 第二级，表达式语句
            value=Call( # 调用函数
                func=Name(id='nums', ctx=Load()),
                args=[],
                keywords=[]))],
    type_ignores=[])

遍历 AST

修改 AST

有两种方式：①修改 AST 节点；②替换 AST 节点。ast 模块提供了 NodeVisitor 和 NodeTransformer 实现这两种功能。

将 i%2 == 0修改为 i+2==0

ast.NodeVisitor.visit 如果没有实现对象的 visit_classname 方法，则调用 generic_visit 方法
ast.NodeVisitor.generic_visit 在子节点上调用 visit 方法

class NodeVisitor(ast.NodeVisitor):
    def visit_BinOp(self, node): # 修改操作符
        if isinstance(node.op, ast.Mod):
            node.op = ast.Add()
        self.generic_visit(node) # 遍历子节点

visitor = NodeVisitor()
visitor.visit(f_ast) # 遍历

输出如下：

1 2	odd: 0 odd: 1

删除 else 节点

调用 compile() 函数时缺失 lineno 和 col_offset 属性，使用 ast.fix_missing_locations 函数添加

class NodeTransformer(ast.NodeTransformer):
    def visit_If(self, node):
        return ast.If(
            test=node.test,
            body=node.body,
            orelse=[]
        )

transformer = NodeTransformer()
f_ast = transformer.visit(f_ast) # 返回新的 AST
ast.fix_missing_locations(f_ast)

输出如下：

even:  0

可视化 AST

使用 graphviz 绘制，遍历 AST 节点，将每个节点对象的类型名称作为点，父节点和每个子节点都连一条边。

安装 graphviz 二进制程序 👉 https://graphviz.org/download/
pip 安装包
1
pip install graphviz

def visit(node, nodes, pindex, g):
    name = str(type(node).__name__)
    index = len(nodes)
    nodes.append(index)
    g.node(str(index), name)
    if index != pindex:
        g.edge(str(index), str(pindex))
    for n in ast.iter_child_nodes(node):
        visit(n, nodes, index, g)
    
graph = Digraph(format="png")
tree = ast.parse(data)
visit(tree, [], 0, graph)
graph.render("test")