第 43 课：性能分析（cProfile, timeit）

课程定位：模块九（测试与调试）最后一课，高级难度标签：profiling, performance, optimization

1. 学习目标

学完本课，你将能够：

理解性能分析的必要性：知道在优化代码前为何以及何时需要进行性能分析。
使用 timeit 模块：精准测量小段代码或特定函数的执行时间。
使用 cProfile 模块：对整个程序或模块进行全面的性能剖析，生成清晰的分析报告。
解读分析结果：从 cProfile 输出中识别程序的性能瓶颈（如耗时最长的函数）。
应用性能分析：结合分析结果，指导你的代码优化工作。

2. 核心概念

在优化代码性能时，最大的误区是凭直觉猜测哪里慢，然后盲目修改。这就像医生不检查就开药，可能完全无效甚至有害。性能分析（Profiling） 就是代码的"体检"，它能精确告诉你程序的时间花在了哪里。

2.1 两种核心工具

Python 提供了两个主要的性能分析工具，它们适用于不同场景：

timeit 模块：像一把秒表，专注于测量一小段代码片段（如一个函数、一个循环）的执行时间。它会自动运行代码多次取平均值，以排除系统瞬时波动，得到非常精确的计时结果。适合比较两种不同实现方式的性能。
cProfile 模块：像一套全面的体检扫描仪，它会对整个程序进行一次运行分析，记录每个函数被调用的次数、总耗时、内部耗时（不包括调用其他函数的时间）等。它生成一份详细的报告，帮助你从宏观上定位性能瓶颈。这是优化大型程序的首选工具。

2.2 关键概念："瓶颈"（Bottleneck）

程序的性能通常受限于一两个关键点，就像瓶颈限制了瓶子的流量。性能分析的目标就是找出这个最影响整体速度的"瓶颈"，然后集中精力优化它。优化一个占总运行时间90%的函数，远比优化一个占0.1%的函数有意义。

3. 代码示例

3.1 使用 `timeit` 测量代码片段

import timeit

# 定义一个性能较差的函数
def poor_function():
    return [i*i for i in range(10000)]

# 定义一个性能可能更好的函数
def better_function():
    return list(map(lambda x: x*x, range(10000)))

# 使用 timeit 进行精确计时
# `setup` 参数用于导入模块等准备工作，`number` 指定执行次数
time_poor = timeit.timeit('poor_function()', setup='from __main__ import poor_function', number=1000)
time_better = timeit.timeit('better_function()', setup='from __main__ import better_function', number=1000)

print(f"列表推导式执行1000次耗时: {time_poor:.4f} 秒")
print(f"Map + Lambda执行1000次耗时: {time_better:.4f} 秒")
print(f"后者相对前者慢了: {(time_better/time_poor - 1)*100:.2f}%")

输出示例（具体数字因机器而异）：

列表推导式执行1000次耗时: 1.2345 秒
Map + Lambda执行1000次耗时: 1.5678 秒
后者相对前者慢了: 27.01%

3.2 使用 `cProfile` 分析程序

首先，创建一个稍微复杂点的程序文件 example.py：

# example.py
import time
import random

def compute_heavy(n):
    """一个模拟计算密集的函数"""
    total = 0
    for i in range(n):
        total += i * i
    return total

def read_data():
    """一个模拟I/O密集（如读取文件）的函数"""
    time.sleep(0.5)  # 模拟读取耗时
    return [random.randint(1, 100) for _ in range(1000)]

def process_data(data):
    """处理数据的函数，内部调用 compute_heavy"""
    results = []
    for item in data[:50]:  # 只处理前50个
        results.append(compute_heavy(item * 100))
    return results

def main():
    print("程序开始...")
    data = read_data()
    processed = process_data(data)
    print(f"处理完成，结果数量: {len(processed)}")

if __name__ == '__main__':
    main()

现在，在命令行中使用 cProfile 运行它：

python -m cProfile -s cumulative example.py

输出解释（节选并格式化）：

         5012 function calls (4992 primitive calls) in 0.532 seconds

   Ordered by: cumulative time

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.000    0.000    0.532    0.532 example.py:1(main)
        1    0.000    0.000    0.501    0.501 example.py:11(read_data)
        1    0.500    0.500    0.500    0.500 {built-in method time.sleep}
        1    0.001    0.001    0.030    0.030 example.py:18(process_data)
       50    0.025    0.001    0.025    0.001 example.py:6(compute_heavy)
        ...

如何阅读报告：

cumtime（累积时间）：最重要的列。它显示了一个函数以及它调用的所有子函数的总耗时。通过按 cumtime 排序（-s cumulative），你能快速找到最耗时的执行路径。
tottime（自身时间）：函数自身（不包括子函数）的运行时间总和。这能看出函数本身的计算开销。
在我们的例子中，read_data 的累积时间最长（0.501秒），其中主要是 time.sleep 在耗时，这提示我们 I/O 等待是主要瓶颈。其次，compute_heavy 被调用了50次，自身计算耗时0.025秒，如果计算量变大，这里可能成为下一个瓶颈。

3.3 使用 `cProfile` 的编程接口

你也可以在代码内部调用 cProfile，这对分析交互式程序或在生产环境中收集数据很有用。

import cProfile
import pstats

def slow_function():
    total = 0
    for i in range(1000000):
        total += i
    return total

# 使用 cProfile 进行分析
profiler = cProfile.Profile()
profiler.enable()  # 开始收集

result = slow_function()

profiler.disable()  # 停止收集

# 创建 Stats 对象来格式化输出
stats = pstats.Stats(profiler)
stats.sort_stats('cumtime')  # 按累积时间排序
stats.print_stats(10)  # 只打印前10条记录

3.4 实用技巧：自定义计时装饰器

创建一个可复用的装饰器，方便地测量任何函数的执行时间。

import time
import functools

def timer(func):
    """测量并打印函数执行时间的装饰器"""
    @functools.wraps(func)
    def wrapper_timer(*args, **kwargs):
        start_time = time.perf_counter()  # 高精度计时器
        value = func(*args, **kwargs)
        end_time = time.perf_counter()
        run_time = end_time - start_time
        print(f"函数 {func.__name__!r} 运行耗时: {run_time:.4f} 秒")
        return value
    return wrapper_timer

@timer
def waste_time(num):
    """一个耗时的函数"""
    time.sleep(num)
    return f"休眠了 {num} 秒"

# 调用
result = waste_time(1)

输出：

函数 'waste_time' 运行耗时: 1.0012 秒

4. 实践练习

练习一：基本计时对比（使用 timeit）

比较以下三种创建一个包含 0 到 999 平方数的列表的方法，并打印出每种方法的执行时间。

# 方法1：列表推导式
squares1 = [i*i for i in range(1000)]

# 方法2：map + lambda
squares2 = list(map(lambda x: x*x, range(1000)))

# 方法3：常规for循环
squares3 = []
for i in range(1000):
    squares3.append(i*i)

要求：

使用 timeit 模块进行测量。
将每个方法的执行代码字符串和必要的导入语句传入 timeit。
执行1000次（number=1000）。
按从快到慢的顺序打印出三种方法的结果。

预期输出（格式示例）：

列表推导式耗时: 0.1234 秒
常规循环耗时:    0.1567 秒
Map-Lambda耗时: 0.2345 秒

练习二：定位瓶颈（使用 cProfile）

分析下面这段代码，它模拟了一个数据处理流程。使用 cProfile 找出最耗时的函数。

import random

def generate_data():
    """生成模拟数据"""
    data = []
    for _ in range(1000):
        # 生成一个包含10个随机数的列表
        data.append([random.randint(0, 100) for _ in range(10)])
    return data

def filter_data(data):
    """过滤数据：只保留每行平均值大于50的行"""
    filtered = []
    for row in data:
        avg = sum(row) / len(row)
        if avg > 50:
            filtered.append(row)
    return filtered

def sort_data(data):
    """按每行第一个元素排序"""
    return sorted(data, key=lambda row: row[0])

def main():
    raw_data = generate_data()
    filtered = filter_data(raw_data)
    sorted_data = sort_data(filtered)
    print(f"最终数据行数: {len(sorted_data)}")

if __name__ == '__main__':
    main()

要求：

将代码保存为文件（如 data_process.py）。
使用 python -m cProfile -s cumulative data_process.py 命令进行分析。
分析报告，指出哪个函数的"累积时间（cumtime）"最长，并推测其原因。

练习三：优化与验证

针对练习二中的代码，进行以下操作：

你认为 filter_data 函数中的 avg = sum(row) / len(row) 是否有优化空间？（提示：len(row) 在循环中不变）
修改 filter_data 函数，进行你认为合理的优化。
分别对优化前后的整个程序进行 cProfile 分析（或使用练习一的计时器装饰器），对比 filter_data 函数的自身耗时（tottime），验证优化是否有效。

5. 常见错误

盲目优化：在没有任何数据支持的情况下，基于"感觉"去修改代码。永远先分析，再优化。可能你精心优化的函数只占总时间的1%。
误用 timeit 环境：在 timeit 的 setup 语句中忘记导入你函数所在的模块或变量。例如，使用 timeit.timeit('my_func()', setup='import my_module') 但实际函数在 my_module 里，需要 from my_module import my_func。
混淆 tottime 和 cumtime：tottime 高表示函数自身计算量大（如复杂算法），cumtime 高但 tottime 低则说明函数本身快，但它调用的子函数很慢（如函数A调用了慢速的函数B）。优化方向完全不同。
忽略 I/O 和网络影响：性能分析主要测的是 CPU 时间。如果程序瓶颈在于读取大文件、网络请求或数据库查询，cProfile 显示的 CPU 时间可能很短，但程序实际运行很慢。这类问题需要用计时器包裹具体的 I/O 操作，或使用专门的 I/O 分析工具。
过早优化：在程序功能还未完全确定或代码还未清晰时就进行底层优化。这会使代码变得复杂难懂，且可能后续需求变更导致优化白费。确保正确性，保证可读性，最后才是优化性能。

6. 小结

性能分析是优化的"指南针"，它能告诉你程序的时间花在了哪里，避免你做无用功。
timeit 是精密计时器，适合用于小段代码或函数的精确计时和对比。
cProfile 是全面体检工具，适合用于分析整个程序的性能剖面，快速定位耗时最长的函数调用链（查看 cumtime）。
分析报告的核心是理解 ncalls（调用次数）、tottime（自身耗时）和 cumtime（累积耗时）这三列数据的含义。
优化哲学：先正确，再清晰，最后快速。优化前必须用数据（性能分析结果）指导行动，优先优化最影响整体性能的"瓶颈"。

练习编辑器

python