Python字节码与dis模块

一、Python字节码概述

Python是一门解释型语言，但其"解释"并非直接解释源代码。Python在执行时，首先将源代码编译为一种中间表示形式——字节码（Bytecode），然后由Python虚拟机（CPython的评估循环）逐条执行这些字节码指令。理解字节码是深入掌握Python内部机制的关键一步，它能帮助你理解代码的执行效率、调试疑难问题，甚至编写更高效的Python程序。

Python字节码是一种与平台无关的二进制指令集，每条指令由一个操作码（opcode）和可选的参数（arg）组成。操作码用一个字节（0-255）表示，因此称为"字节码"。CPython 3.11及之后版本引入了"自适应"字节码（adaptive bytecode）和"快速"字节码（quickened bytecode），进一步提升了执行效率。

dis 是 Python 标准库中的反汇编器（disassembler）模块，它将字节码指令转换为可读的助记符形式。通过 dis.dis() 函数，我们可以查看任何函数、类、方法或代码对象的字节码指令序列，从而理解Python在底层是如何执行代码的。

版本提示：本文基于 Python 3.12 进行讲解。Python 3.11 引入了重大字节码优化（自适应解释器），3.12 进一步改进了指令集。不同版本间的字节码可能存在差异，文中会特别说明版本相关的细节。

二、dis.dis() 反汇编函数

dis.dis() 是最核心的反汇编函数，它可以接收函数、类、方法、代码对象、字符串（源代码）等多种类型的参数，并将它们反汇编为可读字节码。

2.1 反汇编函数

将函数对象传递给 dis.dis() 是最常见的用法。它会显示该函数编译后的完整字节码指令序列。

import dis

def add(a, b):
    result = a + b
    return result

dis.dis(add)

输出结果：

2 0 RESUME 0 3 2 LOAD_FAST 0 (a) 4 LOAD_FAST 1 (b) 6 BINARY_OP 0 (+) 10 STORE_FAST 2 (result) 4 12 LOAD_FAST 2 (result) 14 RETURN_VALUE

输出格式说明：每一行从左到右依次为——行号（对应源代码行号）、指令偏移量（以字节为单位）、指令名称、参数（括号内为参数的含义）。RESUME 是 Python 3.11+ 新增的指令，用于支持调试器和协程的恢复执行。

2.2 反汇编类与方法

传递一个类给 dis.dis()，它会依次反汇编该类中定义的所有方法（包括静态方法和类方法）。

class Calculator:
    def add(self, x, y):
        return x + y

    @staticmethod
    def multiply(x, y):
        return x * y

    @classmethod
    def identity(cls, x):
        return x

dis.dis(Calculator)

2.3 反汇编代码对象

函数对象有一个 __code__ 属性，它指向函数的代码对象。我们可以直接反汇编这个代码对象，获得更细粒度的控制。

def greet(name):
    msg = f"Hello, {name}!"
    print(msg)

# 直接反汇编代码对象
code_obj = greet.__code__
dis.dis(code_obj)

print("--- 代码对象属性 ---")
print(f"参数名: {code_obj.co_varnames}")
print(f"常量: {code_obj.co_consts}")
print(f"名称: {code_obj.co_names}")
print(f"字节码长度: {len(code_obj.co_code)} 字节")

核心概念：函数与代码对象并非同一事物。每个函数对象都持有一个 __code__ 属性指向其代码对象，但多个函数可以共享同一个代码对象（例如通过 FunctionType 动态创建函数时）。代码对象才是真正包含已编译字节码的结构体。

2.4 反汇编字符串形式的源代码

dis.dis() 也可以直接接收一个字符串作为源代码进行编译并反汇编，这对快速实验非常方便。

code_str = """
for i in range(5):
    print(i ** 2)
"""
dis.dis(code_str)

三、常用字节码指令详解

字节码指令是Python虚拟机的"机器语言"。理解最常用的字节码指令是读懂反汇编输出的基础。以下是按类别划分的核心指令。

3.1 变量加载与存储指令

指令	作用	参数含义
LOAD_FAST	加载局部变量	变量在 co_varnames 中的索引
LOAD_GLOBAL	加载全局变量或内置变量	变量在 co_names 中的索引
LOAD_DEREF	加载闭包变量（自由变量）	变量在 co_freevars 中的索引
LOAD_CONST	加载常量值	常量在 co_consts 中的索引
LOAD_ATTR	加载对象属性	属性名在 co_names 中的索引
STORE_FAST	存储到局部变量	变量在 co_varnames 中的索引
STORE_GLOBAL	存储到全局变量	变量在 co_names 中的索引
STORE_ATTR	设置对象属性	属性名在 co_names 中的索引
DELETE_FAST	删除局部变量	变量在 co_varnames 中的索引

# 演示不同变量作用域的字节码差异
x = 100  # 全局变量

def scope_demo():
    a = 42           # 局部变量
    b = a + x        # x 是全局变量
    c = lambda: a    # 闭包变量 a 成为自由变量
    return c

dis.dis(scope_demo)

5 0 RESUME 0 6 2 LOAD_CONST 1 (42) 4 STORE_FAST 0 (a) 7 6 LOAD_FAST 0 (a) 8 LOAD_GLOBAL 0 (x) 10 BINARY_OP 0 (+) 14 STORE_FAST 1 (b) 8 16 LOAD_CLOSURE 0 (a) 18 BUILD_TUPLE 1 20 LOAD_CONST 2 (<code object <lambda>>) 22 MAKE_FUNCTION 8 (closure) 24 STORE_FAST 2 (c) 9 26 LOAD_FAST 2 (c) 28 RETURN_VALUE

3.2 函数调用与构建指令

指令	作用	说明
CALL_FUNCTION	调用函数（Python 3.11+ 已废弃）	参数为参数个数
CALL	通用函数调用（Python 3.12+）	携带调用标志位
MAKE_FUNCTION	创建函数对象	标志位表示有无默认值/注解/闭包等
BUILD_LIST	构建列表	参数为元素个数
BUILD_TUPLE	构建元组	参数为元素个数
BUILD_MAP	构建字典	参数为键值对个数（或预留容量）
BUILD_SET	构建集合	参数为元素个数
LIST_APPEND	列表追加（用于推导式）	代码索引与追加计数

3.3 算术与比较指令

指令	作用	说明
BINARY_OP	二元运算	参数指定运算类型（+、-、*等）
UNARY_NEGATIVE	一元负号	-x
UNARY_NOT	逻辑非	not x
COMPARE_OP	比较运算	参数指定比较类型（==、<、>=等）
CONTAINS_OP	成员测试（in/not in）	0 表示 in，1 表示 not in
IS_OP	身份测试（is/is not）	0 表示 is，1 表示 is not

def arithmetic_demo(a, b):
    return (a + b) * (a - b) / 2

dis.dis(arithmetic_demo)

2 0 RESUME 0 3 2 LOAD_FAST 0 (a) 4 LOAD_FAST 1 (b) 6 BINARY_OP 0 (+) 10 LOAD_FAST 0 (a) 12 LOAD_FAST 1 (b) 14 BINARY_OP 10 (-) 18 BINARY_OP 5 (*) 22 LOAD_CONST 1 (2) 24 BINARY_OP 11 (/) 28 RETURN_VALUE

3.4 控制流与循环指令

指令	作用	说明
JUMP_FORWARD	无条件向前跳转	跳转偏移量
JUMP_BACKWARD	无条件向后跳转	跳转偏移量（Python 3.11+ 用来实现循环）
POP_JUMP_IF_TRUE	栈顶为真时跳转	跳转目标偏移
POP_JUMP_IF_FALSE	栈顶为假时跳转	跳转目标偏移
FOR_ITER	迭代循环	循环结束时的跳转偏移
GET_ITER	获取迭代器	调用 iter()
RETURN_VALUE	返回值	退出函数
YIELD_VALUE	生成器产出值	暂停执行

def loop_demo(n):
    total = 0
    for i in range(n):
        if i % 2 == 0:
            total += i
    return total

dis.dis(loop_demo)

四、代码对象（Code Object）属性深度解析

代码对象是Python字节码的核心载体，它包含了执行一段代码所需的全部信息。理解代码对象的属性，是从"使用"字节码跨入"理解"字节码的关键一步。

4.1 代码对象的核心属性

属性	类型	说明
co_code	bytes	原始字节码指令序列，每个指令1字节opcode + 可选参数
co_consts	tuple	代码中使用的常量集合（数字、字符串、内部代码对象等）
co_names	tuple	代码中使用的全局名称（函数名、属性名等）
co_varnames	tuple	局部变量名（包括参数和内部变量）
co_freevars	tuple	自由变量名（被闭包引用的外部变量）
co_cellvars	tuple	单元格变量名（被内部嵌套函数引用的变量）
co_filename	str	源代码文件名
co_name	str	代码对象名称（通常是函数名或模块名）
co_firstlineno	int	代码在源文件中的起始行号
co_lnotab	bytes	字节码偏移到行号的映射表（Python 3.10 之前的格式）
co_linetable	bytes	字节码偏移到行号的映射表（Python 3.10+ 的改进格式）
co_stacksize	int	执行代码所需的最大栈空间
co_nlocals	int	局部变量数量
co_flags	int	位标志（是否为生成器、协程、异步等）
co_argcount	int	位置参数数量（不包括 args 和 *kwargs）
co_kwonlyargcount	int	仅限关键字参数数量

def inspect_code_object(x, y=10):
    """演示代码对象属性"""
    z = x + y
    def inner():
        return z
    return inner

code = inspect_code_object.__code__
print(f"co_name:       {code.co_name}")
print(f"co_argcount:   {code.co_argcount}")
print(f"co_nlocals:    {code.co_nlocals}")
print(f"co_varnames:   {code.co_varnames}")
print(f"co_consts:     {code.co_consts}")
print(f"co_names:      {code.co_names}")
print(f"co_cellvars:   {code.co_cellvars}")
print(f"co_freevars:   {code.co_freevars}")
print(f"co_stacksize:  {code.co_stacksize}")
print(f"co_flags:      {bin(code.co_flags)}")
print(f"co_code:       {code.co_code.hex()}")

co_name: inspect_code_object co_argcount: 2 co_nlocals: 3 co_varnames: ('x', 'y', 'z') co_consts: (None, '演示代码对象属性', <code object inner>) co_names: () co_cellvars: ('z',) co_freevars: () co_stacksize: 3 co_flags: 0b11 co_code: 8800640064006c0264005300

4.2 co_lnotab 与行号映射

字节码指令需要映射回源代码行号，这在调试、栈回溯（traceback）、性能分析中都至关重要。Python 3.10 之前使用 co_lnotab 存储映射关系，3.10+ 改用更高效的 co_linetable 格式。

# 使用 dis 模块解析行号映射
import dis

def multi_line(x):
    a = x + 1
    b = a * 2
    c = b ** 3
    return c

# 显示带有行号注解的字节码
dis.dis(multi_line, show_caches=True)

# 使用 dis.findlinestarts() 获取行号映射
linestarts = dict(dis.findlinestarts(multi_line.__code__))
print("行号映射 (字节码偏移 -> 源代码行号):")
for offset, lineno in sorted(linestarts.items()):
    print(f"  偏移 {offset:4d}  -> 第 {lineno} 行")

高级技巧：在 Python 3.12 中，字节码引入了"缓存指令"（cache entries）的概念。某些指令后面会跟随若干字节的缓存空间（以 CACHE 形式出现），用于存储内联缓存（inline cache）信息，加速属性访问、类型比较等操作。这也是 Python 3.11+ 性能大幅提升的幕后功臣之一。

五、通过字节码理解Python内部机制

字节码是理解Python"底层到底在做什么"的最佳工具。通过对比不同写法的字节码输出，我们可以直观地看到哪些写法更高效、哪些操作存在隐藏开销。

5.1 列表推导式 vs 普通 for 循环

很多人直觉认为列表推导式和 for 循环在"底层"是一样的，但字节码揭示了它们的差异。

for 循环方式

def square_loop(n):
    result = []
    for i in range(n):
        result.append(i ** 2)
    return result

列表推导式

def square_comp(n):
    return [i ** 2 for i in range(n)]

print("=== 列表推导式字节码 ===")
dis.dis(square_comp)
print()
print("=== for循环字节码 ===")
dis.dis(square_loop)

列表推导式的字节码使用专门的 LIST_APPEND 指令，直接在底层操作列表的 append 方法，避免了 LOAD_METHOD 和 CALL_METHOD 的开销。这也是为什么列表推导式通常比手动 for 循环 append 快约 10-30% 的原因。

字节码洞察：列表推导式在编译期就被优化为专门的字节码指令序列，其核心是对 LIST_APPEND 的内联使用，避免了方法查找和调用的开销。而集合推导式、字典推导式也有类似的优化（SET_ADD、MAP_ADD）。

5.2 局部变量 vs 全局变量访问速度

Python 中有一个广为人知的最佳实践：将频繁访问的全局变量（或模块级变量）赋值给局部变量以提升速度。字节码清晰地展示了原因。

import math

def global_access(n):
    """直接使用全局变量 math.sqrt"""
    result = 0
    for i in range(n):
        result += math.sqrt(i)
    return result

def local_access(n):
    """将 math.sqrt 赋给局部变量"""
    sqrt = math.sqrt
    result = 0
    for i in range(n):
        result += sqrt(i)
    return result

print("=== 全局访问字节码 ===")
dis.dis(global_access)
print("\n=== 局部访问字节码 ===")
dis.dis(local_access)

LOAD_GLOBAL 需要先在全局命名空间中查找变量，如果找不到还要在内置命名空间中查找。而 LOAD_FAST 直接通过索引在局部变量数组中快速定位。在 Python 3.12 中，LOAD_GLOBAL 已经过内联缓存优化，但相比 LOAD_FAST 仍然有固定开销。高频调用的循环中，"全局变量本地化"这一优化技巧可以带来 20-50% 的性能提升。

5.3 装饰器原理的字节码视角

装饰器的本质是"语法糖"，它等价于在函数定义之后手动调用装饰器函数。字节码展示了这一过程。

def timer(func):
    def wrapper(*args, **kwargs):
        print("计时开始...")
        return func(*args, **kwargs)
    return wrapper

@timer
def work():
    print("工作中...")
    return 42

# 等价于:
# work = timer(work)

dis.dis(work)

print("\n--- 查看"装饰背后" ---")
# work.__wrapped__ 不存在, 但我们可以看 work 的闭包
print(f"work 的闭包变量: {work.__code__.co_freevars}")
print(f"work 引用的函数对象: {work.__closure__}")

# 演示 @timer 在字节码层面的等价操作
def undecorated_work():
    print("工作中...")
    return 42

# 手动完成装饰
undecorated_work = timer(undecorated_work)

# 对比使用 @ 语法和使用手动赋值的字节码
print("=== @timer 装饰的 work ===")
dis.dis(work)

print("\n=== 手动的 undecorated_work ===")
dis.dis(undecorated_work)

重要发现：@timer 语法在编译时等同于 work = timer(work)，字节码在函数定义完成后立即调用 timer 并将返回值赋给同一个名称。因此两种写法生成的函数字节码完全一致，唯一的区别在于源代码中的出现时机和可读性。

5.4 生成器与 yield 的字节码特征

生成器函数与非生成器函数在字节码层面的根本区别在于 co_flags 标志位的不同。

def normal_func():
    return 42

def generator_func():
    yield 42
    yield 43

print("=== 普通函数标志位 ===")
print(f"co_flags: {bin(normal_func.__code__.co_flags)}")
dis.dis(normal_func)

print("\n=== 生成器函数标志位 ===")
print(f"co_flags: {bin(generator_func.__code__.co_flags)}")
dis.dis(generator_func)

生成器函数的字节码使用 YIELD_VALUE 指令暂停执行，并使用 SEND 指令（Python 3.10+）接收 send() 方法传入的值。co_flags 中的 CO_GENERATOR（0x20）位被置位，表明这是一个生成器函数——Python 虚拟机会在看到这个标志时，将函数调用的返回值包装为生成器迭代器，而非直接执行函数体。

六、字节码优化技巧与实际应用

理解字节码不仅是为了"看懂"，更是为了写出更高效的代码。以下是在字节码层面经过验证的优化技巧。

6.1 常量折叠（Constant Folding）

Python 编译器在编译期就会计算常量表达式的值，这一技术称为常量折叠。这是免费的优化，不需要我们做任何额外工作。

def const_folding():
    # 这些表达式在编译期被计算为常量
    a = 60 * 60 * 24      # 折叠为 86400
    b = "Hello, " + "World!"  # 折叠为 "Hello, World!"
    c = (1, 2, 3) * 3     # 折叠为 (1, 2, 3, 1, 2, 3, 1, 2, 3)
    d = [1, 2] + [3, 4]   # 列表加法不会折叠!
    return a, b, c, d

dis.dis(const_folding)

观察字节码就会发现，60 * 60 * 24 被直接替换为了 LOAD_CONST 86400，而不是三条乘法指令。但是列表的 + 运算不会折叠，因为列表是可变对象，每次创建新列表可能有副作用考虑。类似的，集合推导式、包含变量引用的表达式也不会折叠。

6.2 成员测试：set 优于 list

从字节码的角度看，in 操作符对 list 和 set 的检测使用的是完全相同的 CONTAINS_OP 指令。性能差异完全来自底层数据结构的 __contains__ 方法实现差异（set 的 O(1) vs list 的 O(n)），字节码层面并没有特殊优化。

def set_vs_list():
    data_list = [1, 2, 3, 4, 5]
    data_set = {1, 2, 3, 4, 5}
    # 同一个 CONTAINS_OP 指令
    a = 3 in data_list
    b = 3 in data_set
    return a, b

# 字节码本身看不出区别
# 但执行时 set.__contains__ 快得多
import timeit
print(f"list 成员测试: {timeit.timeit('3 in [1,2,3,4,5]'):.3f}s")
print(f"set 成员测试:  {timeit.timeit('3 in {1,2,3,4,5}'):.3f}s")

6.3 避免属性查找的内循环

属性访问 LOAD_ATTR 是字节码层面的一个相对"昂贵"的指令，它涉及名称查找、描述器协议（descriptor protocol）、__getattribute__ 调用等一系列复杂操作。

import math

class OptimizedDemo:
    def bad_method(self, n):
        """内循环中反复访问 math.sqrt"""
        result = 0
        for i in range(n):
            result += math.sqrt(i)
        return result

    def good_method(self, n):
        """预先本地化"""
        sqrt = math.sqrt
        result = 0
        for i in range(n):
            result += sqrt(i)
        return result

    def best_method(self, n):
        """本地化 + 理解性能"""
        sqrt = math.sqrt
        return sum(sqrt(i) for i in range(n))

print("=== bad_method ===")
dis.dis(OptimizedDemo.bad_method)

print("\n=== good_method ===")
dis.dis(OptimizedDemo.good_method)

警告：优化应建立在性能分析（profiling）的基础上。盲目优化可能会降低代码可读性而收益甚微。字节码层面的优化适用于热点代码（hot spots）——即被调用频率极高的内循环代码。永远记住："make it work, make it right, make it fast"，这三者的顺序是有道理的。

6.4 使用 dis 进行性能调试

当你想知道为什么一段代码比另一段慢时，dis 模块是第一个诊断工具。通过对比字节码，你可以快速发现以下问题：

意外使用全局变量：字节码中出现 LOAD_GLOBAL 替代了预期的 LOAD_FAST
重复属性访问：序列中出现多次 LOAD_ATTR 对同一个对象的不同属性
未优化的推导式：生成器表达式比列表推导式多了 YIELD_VALUE 的上下文切换开销
不必要的函数调用：简单运算被包装在函数中，需要 CALL_FUNCTION + RETURN_VALUE 的完整调用栈操作

实用工具：Python 3.12 的 dis 模块新增了 dis.distb() 用于反汇编栈回溯，dis.get_instructions() 可以迭代获取每条指令的详细信息，dis.show_code() 可以格式化显示代码对象的所有属性。建议在调试中将 dis.dis() 加入你的"调试工具箱"。

七、不同 Python 版本的字节码差异

Python 字节码并非一成不变。每个 Python 主版本（甚至次版本）都可能引入新的指令、废弃旧的指令或改变指令的语义。了解版本差异对于维护跨版本兼容的代码至关重要。

7.1 Python 3.10 的重要变化

引入 MATCH_KEYS、MATCH_CLASS 等指令支持 match/case 模式匹配
co_lnotab 被 co_linetable 取代，行号映射更高效
异常处理字节码优化：SETUP_FINALLY 等老旧指令被替换为更高效的 PUSH_EXC_INFO 和 POP_EXCEPT
SEND 指令被引入，用于生成器的 send() 协议优化

7.2 Python 3.11 — "自适应"字节码革命

Python 3.11 实现了 CPython 历史上最大的一次性能提升（约 25%），核心就是引入了自适应字节码解释器（Adaptive Interpreter）：

引入了 quickened 字节码，第一次执行时会将通用指令替换为特化指令（specialized instruction）。例如 LOAD_FAST 会被特化为 LOAD_FAST_CHECK 和 LOAD_FAST__LOAD_FAST
引入了 内联缓存（inline caching），常用指令后面跟随缓存槽位用于存储类型信息
新指令 RESUME 取代了旧的处理方式，支持调试器和协程
JUMP_BACKWARD 取代了 JUMP_ABSOLUTE，新指令可以携带更多循环信息
CALL_FUNCTION、CALL_METHOD 等被统一的 CALL 指令替代

7.3 Python 3.12 的改进

废弃了 CALL_FUNCTION、CALL_METHOD、LOAD_METHOD 等旧指令，全面转向 CALL、LOAD_ATTR 的统一形式
更多的内联缓存槽位，进一步提高属性访问和方法调用的性能
BINARY_OP 统一了所有的二元运算指令，BINARY_MULTIPLY、BINARY_ADD 等被整合
移除了 JUMP_IF_NOT_EXC_MATCH 等异常处理相关的旧指令

# 查看当前 Python 版本支持的所有字节码指令
import dis
import sys

print(f"Python 版本: {sys.version}")
print(f"支持的字节码指令数量: {len(dis.opmap)}")
print(f"是否支持自适应字节码: {hasattr(dis, 'COMPILER_FLAG_NAMES')}")

# 列出所有字节码指令（按编号排序）
print("\n前 20 个字节码指令：")
for i, (name, code) in enumerate(sorted(dis.opmap.items(), key=lambda x: x[1])[:20]):
    print(f"  {code:3d}: {name}")

实践建议：如果你需要编写跨 Python 版本的代码，不要在字节码层面做假设。使用 sys.version_info 进行条件判断，避免依赖特定版本的字节码行为。对于需要大量内省（introspection）的工具，考虑使用 dis 模块提供的跨版本兼容接口（如 dis.get_instructions()）而非直接解析 co_code。

八、实战：自定义字节码分析工具

将所学知识付诸实践，本节展示如何利用 dis 模块和代码对象属性，构建一个实用的字节码分析工具。

import dis
import sys

class BytecodeAnalyzer:
    """字节码分析器：统计函数中的指令使用情况"""

    def __init__(self, func):
        self.func = func
        self.code = func.__code__
        self.instructions = list(dis.get_instructions(func))
        self.stats = self._analyze()

    def _analyze(self):
        from collections import Counter
        return Counter(instr.opname for instr in self.instructions)

    def summary(self):
        print(f"函数: {self.func.__name__}")
        print(f"指令总数: {len(self.instructions)}")
        print(f"指令种类: {len(self.stats)}")
        print("\n指令频率 TOP 10:")
        for name, count in self.stats.most_common(10):
            bar = "#" * count
            print(f"  {name:25s} {count:3d}  {bar}")
        print(f"\n代码对象大小: {sys.getsizeof(self.code)} bytes")
        print(f"co_stacksize: {self.code.co_stacksize}")
        print(f"局部变量数:   {self.code.co_nlocals}")

    def find_pattern(self, opname_pattern):
        """查找特定模式的指令"""
        matches = [i for i in self.instructions if opname_pattern in i.opname]
        print(f"包含 '{opname_pattern}' 的指令 ({len(matches)} 条):")
        for instr in matches[:10]:
            offset_info = f"[偏移 {instr.offset}]"
            arg_info = f"({instr.argrepr})" if instr.argrepr else ""
            print(f"  {offset_info:12s} {instr.opname:20s} {arg_info}")

    def global_access_report(self):
        """报告全局变量访问情况"""
        globals_used = [
            instr.argrepr
            for instr in self.instructions
            if instr.opname == "LOAD_GLOBAL"
        ]
        if globals_used:
            print(f"检测到 {len(globals_used)} 次全局变量访问:")
            for g in set(globals_used):
                print(f"  - {g} (访问 {globals_used.count(g)} 次)")
        else:
            print("无全局变量访问，赞！")

    def report(self):
        self.summary()
        print("\n" + "=" * 50)
        self.global_access_report()
        print("=" * 50)
        self.find_pattern("LOAD")
        print("=" * 50)
        self.find_pattern("CALL")


# 使用示例
def demo_function(n):
    total = 0
    for i in range(n):
        total += i ** 2
    import math
    return math.sqrt(total)

analyzer = BytecodeAnalyzer(demo_function)
analyzer.report()

扩展思路：上述分析器只是冰山一角。在生产环境中，类似的字节码内省技术可以用于：框架的路由注册（Flask、Django 通过字节码分析自动发现视图函数）、测试覆盖率工具（Trace 函数结合字节码行号映射）、性能分析器（统计热点指令序列）、AOT 编译工具（解析字节码生成 C 扩展）、代码混淆工具（通过对字节码做变换来阻止逆向）。

九、核心要点总结

字节码是 Python 的中间表示：Python 源代码首先被编译为字节码（存储在 .pyc 文件中），然后由 CPython 虚拟机逐条执行。字节码是理解 Python 执行模型的最佳入口。
dis 是反汇编的标准工具：dis.dis() 可以反汇编函数、类、方法、代码对象和源代码字符串，输出包含行号、偏移量、指令名和参数的格式化信息。
核心字节码指令：LOAD_FAST（局部变量）、LOAD_GLOBAL（全局变量）、LOAD_CONST（常量）、BINARY_OP（二元运算）、CALL_FUNCTION/CALL（函数调用）、RETURN_VALUE（返回）、FOR_ITER（循环）是最常用的指令。
代码对象属性至关重要：co_code（原始字节码）、co_consts（常量表）、co_varnames（局部变量名）、co_names（全局名称）、co_lnotab/co_linetable（行号映射）是理解代码对象的核心。
字节码揭示性能真相：列表推导式比 for 循环快的原因在于使用了 LIST_APPEND 内联指令；局部变量比全局变量快的原因在于 LOAD_FAST 比 LOAD_GLOBAL 少了一次命名空间查找。
Python 3.11+ 的字节码革命：自适应解释器、内联缓存、特化指令（specialized instructions）使 CPython 性能提升约 25%。RESUME、CALL、BINARY_OP 等新指令统一并简化了旧的指令体系。
版本兼容性注意事项：字节码在不同 Python 版本间存在差异，支持模式匹配的指令（3.10+）、自适应字节码（3.11+）、统一指令格式（3.12+）等变化要求在跨版本开发中使用 dis 模块的跨版本兼容 API。
优化要基于证据：使用 dis 分析字节码，使用 timeit 和 cProfile 进行性能测量，在热点代码上应用优化，避免无根据的"优化"降低代码可读性。