1
# 源码
2
x = 1 + 2
3

4
# Token 流
5
NAME 'x' (1, 0)
6
EQUAL '=' (1, 2)
7
NUMBER '1' (1, 4)
8
PLUS '+' (1, 6)
9
NUMBER '2' (1, 8)
10
NEWLINE '' (1, 9)

1
// Python 词法分析器（简化）
2
static int tok_get(tok_state *tok, char **p_start, char **p_end) {
3
    char c;
4

5
    // 跳过空白和注释
6
    while (true) {
7
        c = tok_nextc(tok);
8
        if (c == ' ' || c == '\t') continue;
9
        if (c == '#') {
10
            while (c != '\n') c = tok_nextc(tok);
11
        }
12
        break;
13
    }
14

15
    // 识别标识符
16
    if (isalpha(c) || c == '_') {
17
        return NAME;
18
    }
19

20
    // 识别数字
21
    if (isdigit(c)) {
22
        return NUMBER;
23
    }
24

25
    // 识别字符串
26
    if (c == '"' || c == '\'') {
27
        return STRING;
28
    }
29

30
    // ...
31
}

1
# 源码
2
def add(a, b):
3
    return a + b
4

5
result = add(1, 2)

1
# AST（简化表示）
2
Module(body=[
3
    FunctionDef(
4
        name='add',
5
        args=arguments(args=[
6
            arg(arg='a'),
7
            arg(arg='b')
8
        ]),
9
        body=[
10
            Return(value=BinOp(
11
                left=Name(id='a'),
12
                op=Add(),
13
                right=Name(id='b')
14
            ))
15
        ]
16
    ),
17
    Assign(
18
        targets=[Name(id='result')],
19
        value=Call(
20
            func=Name(id='add'),
21
            args=[Num(n=1), Num(n=2)]
22
        )
23
    )
24
])

1
import ast
2

3
code = """
4
def add(a, b):
5
    return a + b
6
"""
7

8
tree = ast.parse(code)
9
print(ast.dump(tree, indent=2))

1
# 源码
2
def add(a, b):
3
    return a + b
4

5
# 字节码
6
import dis
7
dis.dis(add)

1
  2           0 LOAD_FAST                0 (a)
2
              2 LOAD_FAST                1 (b)
3
              4 BINARY_ADD
4
              6 RETURN_VALUE

1
// 编译 AST 到字节码（简化）
2
static int compiler_visit_expr(compiler *c, expr_ty e) {
3
    switch (e->kind) {
4
        case BinOp_kind:
5
            // 编译左操作数
6
            compiler_visit_expr(c, e->v.BinOp.left);
7
            // 编译右操作数
8
            compiler_visit_expr(c, e->v.BinOp.right);
9
            // 生成操作指令
10
            compiler_addop(c, binop_opcode(e->v.BinOp.op));
11
            break;
12
        case Name_kind:
13
            // 加载变量
14
            compiler_addop_name(c, LOAD_NAME, e->v.Name.id);
15
            break;
16
        // ...
17
    }
18
}

1
def func(x):
2
    y = x + 1
3
    return y
4

5
# 查看 Code Object
6
print(func.__code__.co_code)        # 字节码
7
print(func.__code__.co_varnames)    # 局部变量名
8
print(func.__code__.co_consts)      # 常量
9
print(func.__code__.co_names)       # 名称
10
print(func.__code__.co_filename)    # 文件名
11
print(func.__code__.co_firstlineno) # 起始行号

1
// PyFrameObject 结构（简化）
2
typedef struct _PyInterpreterFrame {
3
    PyObject *f_func;        // 函数对象
4
    PyObject *f_locals;      // 局部变量
5
    PyObject *f_globals;     // 全局变量
6
    PyObject *f_builtins;    // 内置函数
7

8
    PyCodeObject *f_code;    // 代码对象
9
    int f_lasti;             // 上条指令位置
10

11
    // 数据栈
12
    PyObject **stackpointer;
13
    PyObject **stacktop;
14

15
    // 块栈（用于异常、循环）
16
    PyTryBlock f_blockstack[CO_MAXBLOCKS];
17
} PyInterpreterFrame;

1
// Python 虚拟机主循环（简化）
2
PyObject* _PyEval_EvalFrameDefault(PyThreadState *tstate,
3
                                   PyInterpreterFrame *frame) {
4
    PyObject **stack_pointer = frame->stacktop;
5

6
    // 主执行循环
7
    for (;;) {
8
        // 获取指令
9
        _Py_CODEUNIT *next_instr = frame->instr_ptr++;
10
        unsigned char opcode = _Py_OPCODE(*next_instr);
11

12
        switch (opcode) {
13
            case LOAD_CONST: {
14
                PyObject *value = GETITEM(frame->code->co_consts, oparg);
15
                Py_INCREF(value);
16
                PUSH(value);
17
                break;
18
            }
19

20
            case LOAD_FAST: {
21
                PyObject *value = GETLOCAL(oparg);
22
                if (value == NULL) {
23
                    // 未初始化变量错误
24
                }
25
                Py_INCREF(value);
26
                PUSH(value);
27
                break;
28
            }
29

30
            case BINARY_ADD: {
31
                PyObject *right = POP();
32
                PyObject *left = TOP();
33
                PyObject *sum = PyNumber_Add(left, right);
34
                SET_TOP(sum);
35
                Py_DECREF(left);
36
                Py_DECREF(right);
37
                break;
38
            }
39

40
            case RETURN_VALUE: {
41
                PyObject *value = POP();
42
                return value;
43
            }
44

45
            // ... 更多指令处理
46
        }
47
    }
48
}

1
# 代码
2
x = 1 + 2
3

4
# 字节码执行过程
5
# 1. LOAD_CONST 1
6
#    栈: [1]
7
# 2. LOAD_CONST 2
8
#    栈: [1, 2]
9
# 3. BINARY_ADD
10
#    弹出 1, 2，计算 1+2=3，压入 3
11
#    栈: [3]
12
# 4. STORE_NAME 'x'
13
#    弹出 3，存入 x
14
#    栈: []

1
// 内存池结构
2
struct pool_header {
3
    union { block *_padding; } pad;
4
    block *freeblock;       // 空闲块链表
5
    struct pool_header *nextpool;
6
    struct pool_header *prevpool;
7
    uint arenaindex;        // Arena 索引
8
    uint szidx;             // 块大小索引
9
    uint refcount;          // 已分配块数
10
};
11

12
struct arena_object {
13
    uptr address;           // Arena 起始地址
14
    block* pool_address;    // Pool 数组
15
    uint nfreepools;        // 空闲 Pool 数
16
    uint ntotalpools;       // 总 Pool 数
17
};

1
// 引用计数
2
#define Py_INCREF(op) ((void)(++(op)->ob_refcnt))
3
#define Py_DECREF(op) \
4
    do { \
5
        if (--((op)->ob_refcnt) == 0) \
6
            _Py_Dealloc((PyObject *)(op)); \
7
    } while (0)

1
import gc
2

3
# 开启自动 GC
4
gc.enable()
5

6
# 手动触发 GC
7
gc.collect()
8

9
# 查看 GC 状态
10
gc.get_stats()

1
// PyObject 结构
2
typedef struct _object {
3
    Py_ssize_t ob_refcnt;       // 引用计数
4
    PyTypeObject *ob_type;      // 类型指针
5
} PyObject;
6

7
// 变长对象
8
typedef struct {
9
    PyObject ob_base;
10
    Py_ssize_t ob_size;         // 元素个数
11
} PyVarObject;

1
// PyTypeObject 结构（简化）
2
typedef struct _typeobject {
3
    PyObject_VAR_HEAD
4
    const char *tp_name;        // 类型名
5
    Py_ssize_t tp_basicsize;    // 基本大小
6

7
    // 方法
8
    destructor tp_dealloc;      // 析构函数
9
    printfunc tp_print;         // 打印函数
10
    getattrfunc tp_getattro;    // 属性获取
11
    setattrfunc tp_setattro;    // 属性设置
12

13
    // 数字方法
14
    binaryfunc nb_add;
15
    binaryfunc nb_subtract;
16
    binaryfunc nb_multiply;
17

18
    // 序列方法
19
    lenfunc sq_length;
20
    binaryfunc sq_concat;
21
    ssizeargfunc sq_item;
22

23
    // 映射方法
24
    lenfunc mp_length;
25
    binaryfunc mp_subscript;
26

27
    // ...
28
} PyTypeObject;

1
// 创建整数对象
2
PyObject *PyLong_FromLong(long v) {
3
    PyLongObject *result;
4

5
    // 小整数缓存
6
    if (-5 <= v && v <= 256) {
7
        return PyLong_FromSmallInt(v);
8
    }
9

10
    // 分配并初始化
11
    result = PyObject_MALLOC(sizeof(PyLongObject));
12
    if (!result) return NULL;
13

14
    result->ob_base.ob_refcnt = 1;
15
    result->ob_base.ob_type = &PyLong_Type;
16
    result->ob_digit[0] = v;
17

18
    return (PyObject *)result;
19
}

1
def add(a, b):
2
    return a + b
3

4
# 函数对象属性
5
print(add.__code__)       # 代码对象
6
print(add.__globals__)    # 全局变量
7
print(add.__defaults__)   # 默认参数
8
print(add.__closure__)    # 闭包变量

1
def outer(x):
2
    def inner(y):
3
        return x + y
4
    return inner
5

6
func = outer(10)
7
func(5)  # 返回 15

1
# 闭包字节码
2
dis.dis(func)

1
  2           0 LOAD_DEREF               0 (x)
2
              2 LOAD_FAST                0 (y)
3
              4 BINARY_ADD
4
              6 RETURN_VALUE

1
// 闭包单元
2
typedef struct {
3
    PyObject_HEAD
4
    PyObject *ob_ref;  // 捕获的变量
5
} PyCellObject;
6

7
// 函数对象
8
typedef struct {
9
    PyObject_HEAD
10
    PyCodeObject *func_code;      // 代码对象
11
    PyObject *func_globals;       // 全局变量
12
    PyObject *func_defaults;      // 默认参数
13
    PyObject *func_kwdefaults;    // 关键字默认参数
14
    PyObject *func_closure;       // 闭包单元元组
15
} PyFunctionObject;

1
# Python 会缓存编译后的字节码
2
# .py 文件 -> .pyc 文件
3

4
# 缓存位置
5
__pycache__/
6
  module.cpython-311.pyc

1
# 小整数 (-5, 256) 被缓存
2
a = 256
3
b = 256
4
print(a is b)  # True
5

6
a = 257
7
b = 257
8
print(a is b)  # False (新对象)

1
# 字符串自动驻留
2
a = "hello"
3
b = "hello"
4
print(a is b)  # True
5

6
a = "hello world"
7
b = "hello world"
8
print(a is b)  # 可能 False (包含空格)

1
import dis
2

3
# 分析函数字节码
4
def example():
5
    x = [i * 2 for i in range(10)]
6
    return x
7

8
dis.dis(example)
9

10
# 查看字节码详细信息
11
dis.Bytecode(example).info()

1
import cProfile
2

3
def slow_function():
4
    total = 0
5
    for i in range(100000):
6
        total += i
7
    return total
8

9
cProfile.run('slow_function()', sort='cumulative')

1
import sys.monitoring as monitor
2

3
# 设置监控
4
monitor.use_tool_id(monitor.PROFILER_ID, "my_profiler")
5

6
# 注册事件处理器
7
@monitor.register_callback
8
def on_call(code, offset):
9
    print(f"Called {code.co_name} at offset {offset}")

1
import sys
2

3
# 查看对象大小
4
x = [i for i in range(1000)]
5
print(sys.getsizeof(x))  # 列表容器大小
6

7
# 使用 tracemalloc 追踪内存
8
import tracemalloc
9
tracemalloc.start()
10

11
# ... 代码 ...
12

13
snapshot = tracemalloc.take_snapshot()
14
top_stats = snapshot.statistics('lineno')
15
for stat in top_stats[:10]:
16
    print(stat)