Python 代码是什么？—— 从字节到执行的完整解析

def greet(name):
    return f"Hello, {name}!"print(greet("Python"))

┌─────────────┐     ┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│   源代码     │ ──▶ │   词法分析   │ ──▶ │   语法分析   │ ──▶ │   编译器     │
│   .py 文件   │     │  (Tokenizer) │     │   (Parser)   │     │  (Compiler)  │
└─────────────┘     └─────────────┘     └─────────────┘     └──────┬──────┘
                                                                    │
                                                                    ▼
┌─────────────┐     ┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│   机器码     │ ◀── │    CPU      │ ◀── │   解释器     │ ◀── │   字节码     │
│  (二进制)    │     │  (执行)     │     │  (PVM/VM)   │     │  .pyc 文件   │
└─────────────┘     └─────────────┘     └─────────────┘     └─────────────┘

# 源代码x = 1 + 2# 词法分析结果（Token 序列）[
    Token(NAME, 'x'),
    Token(OP, '='),
    Token(NUMBER, '1'),
    Token(OP, '+'),
    Token(NUMBER, '2'),
    Token(NEWLINE, '\n'),
    Token(ENDMARKER, '')]

import tokenizeimport io

code = 'x = 1 + 2'# 将字符串转换为文件对象reader = io.BytesIO(code.encode('utf-8'))# 词法分析for token in tokenize.tokenize(reader.readline):
    print(f"{token.type:12} {token.string!r:10} 行{token.start[0]} 列{token.start[1]}")

ENCODING     'utf-8'    行0 列0
NAME         'x'        行1 列0
OP           '='        行1 列2
NUMBER       '1'        行1 列4
OP           '+'        行1 列6
NUMBER       '2'        行1 列8
NEWLINE      '\n'       行1 列9
ENDMARKER    ''         行2 列0

# 源代码if x > 0:
    print("positive")# 对应的 AST（简化表示）Module(
    body=[
        If(
            test=Compare(
                left=Name(id='x', ctx=Load()),
                ops=[Gt()],
                comparators=[Constant(value=0)]
            ),
            body=[
                Expr(
                    value=Call(
                        func=Name(id='print', ctx=Load()),
                        args=[Constant(value='positive')],
                        keywords=[]
                    )
                )
            ],
            orelse=[]
        )
    ])

import ast

code = '''
def factorial(n):
    if n <= 1:
        return 1
    return n * factorial(n - 1)
'''tree = ast.parse(code)print(ast.dump(tree, indent=2))

import disdef greet(name):
    return f"Hello, {name}!"# 查看函数的字节码dis.dis(greet)

  2           0 LOAD_CONST               1 ('Hello, ')
              2 LOAD_FAST                0 (name)
              4 FORMAT_VALUE             0
              6 BUILD_STRING             2
              8 RETURN_VALUE

// CPython 核心执行循环（简化版）// Python/ceval.cfor (;;) {
    opcode = NEXTOP();
    switch (opcode) {
        case TARGET(LOAD_CONST): {
            PyObject *value = GETITEM(consts, oparg);
            Py_INCREF(value);
            PUSH(value);
            DISPATCH();
        }
        
        case TARGET(BINARY_ADD): {
            PyObject *right = POP();
            PyObject *left = TOP();
            PyObject *sum = PyNumber_Add(left, right);
            Py_DECREF(left);
            Py_DECREF(right);
            SET_TOP(sum);
            DISPATCH();
        }
        
        case TARGET(RETURN_VALUE): {
            retval = POP();
            goto exiting;
        }
        // ... 数百个 case
    }}

首次导入模块 hello.py
        │
        ▼
┌─────────────────┐
│ 1. 检查 hello.pyc  │
│    是否存在且未过期？ │
└────────┬────────┘
         │
    ┌────┴────┐
    ▼         ▼
  不存在    存在且新鲜
  或已过期   (mtime 匹配)
    │         │
    ▼         ▼
  重新编译   直接加载
  生成 .pyc  字节码
    │
    ▼
┌─────────────────┐
│ 2. 写入 __pycache__/ │
│    hello.cpython-311.pyc │
└─────────────────┘

import py_compileimport marshalimport structimport time# 手动编译生成 .pycpy_compile.compile('hello.py', doraise=True)# 读取 .pyc 文件结构with open('__pycache__/hello.cpython-311.pyc', 'rb') as f:
    # 魔数（标识 Python 版本）
    magic = f.read(4)
    # 时间戳/哈希
    timestamp = struct.unpack('<I', f.read(4))[0]
    print(f"魔数: {magic.hex()}")
    print(f"编译时间: {time.ctime(timestamp)}")
    
    # 跳过其他头部信息（PEP 552）
    # 加载字节码对象
    f.seek(16)  # Python 3.7+ 头部为 16 字节
    code_object = marshal.load(f)
    
    print(f"\n代码对象类型: {type(code_object)}")
    print(f"常量表: {code_object.co_consts}")
    print(f"变量名: {code_object.co_varnames}")
    print(f"文件名: {code_object.co_filename}")

def example(a, b):
    c = a + b    return c * 2code = example.__code__print(f"co_name: {code.co_name}")           # 函数名: exampleprint(f"co_argcount: {code.co_argcount}")   # 参数个数: 2print(f"co_nlocals: {code.co_nlocals}")     # 局部变量数: 3 (a, b, c)print(f"co_varnames: {code.co_varnames}")   # 变量名: ('a', 'b', 'c')print(f"co_consts: {code.co_consts}")       # 常量: (None, 2)print(f"co_code: {code.co_code}")           # 原始字节码: b'|\x00|\x01\x17\x00}\x02|\x02d\x01\x14\x00S\x00'print(f"co_code hex: {code.co_code.hex()}") # 十六进制表示

import sysdef trace_calls(frame, event, arg):
    """追踪函数调用"""
    if event == 'call':
        code = frame.f_code        print(f"[CALL] {code.co_name} at {code.co_filename}:{frame.f_lineno}")
        print(f"       locals: {list(frame.f_locals.keys())}")
    elif event == 'return':
        print(f"[RETURN] value={arg}")
    return trace_callsdef factorial(n):
    if n <= 1:
        return 1
    return n * factorial(n - 1)# 设置追踪函数sys.settrace(trace_calls)factorial(3)sys.settrace(None)

[CALL] factorial at <stdin>:14
       locals: ['n']
[CALL] factorial at <stdin>:14
       locals: ['n']
[CALL] factorial at <stdin>:14
       locals: ['n']
[RETURN] value=1
[RETURN] value=2
[RETURN] value=6

import threadingimport timedef cpu_bound_task():
    """纯 CPU 计算任务"""
    count = 0
    for i in range(50_000_000):
        count += i    return count# 单线程执行start = time.time()cpu_bound_task()cpu_bound_task()print(f"单线程耗时: {time.time() - start:.2f}s")# 多线程执行（受 GIL 限制，不会更快！）start = time.time()t1 = threading.Thread(target=cpu_bound_task)t2 = threading.Thread(target=cpu_bound_task)t1.start(); t2.start()t1.join(); t2.join()print(f"多线程耗时: {time.time() - start:.2f}s")

单线程耗时: 3.50s
多线程耗时: 3.80s  ← 更慢！因为线程切换有开销

# 多进程绕过 GILfrom multiprocessing import Poolimport timedef cpu_bound(n):
    return sum(range(n))if __name__ == '__main__':
    start = time.time()
    with Pool(4) as p:
        p.map(cpu_bound, [50_000_000] * 4)
    print(f"多进程耗时: {time.time() - start:.2f}s")

// Include/object.htypedef struct _object {
    _PyObject_HEAD_EXTRA  // 双向链表指针（用于垃圾回收）
    Py_ssize_t ob_refcnt; // 引用计数
    PyTypeObject *ob_type; // 类型指针} PyObject;

s = "hello"# 以下三种写法在底层等价：len(s)              # 直接调用内置函数s.__len__()         # 调用对象的特殊方法type(s).__len__(s)  # 通过类型对象调用# 验证print(len(s))           # 5print(s.__len__())      # 5print(str.__len__(s))   # 5

import sys

a = [1, 2, 3]print(sys.getrefcount(a))  # 2（a 引用 + getrefcount 参数引用）b = aprint(sys.getrefcount(a))  # 3del bprint(sys.getrefcount(a))  # 2# 循环引用问题a = []b = []a.append(b)  # b 的引用计数 +1b.append(a)  # a 的引用计数 +1del adel b# 此时 a 和 b 的引用计数各为 1，但已无法访问 → 内存泄漏！# Python 使用分代垃圾回收（GC）解决循环引用import gc
gc.collect()  # 强制触发垃圾回收

import tracemalloc

tracemalloc.start()# 分配大量小对象data = [i for i in range(100000)]snapshot = tracemalloc.take_snapshot()top_stats = snapshot.statistics('lineno')print("[内存分配 Top 5]")for stat in top_stats[:5]:
    print(f"{stat.size / 1024:.1f} KiB: {stat.traceback.format()[-1]}")