性能分析

性能分析（Profiling）帮助找出程序中的瓶颈。Python 2.7 提供了 timeit 测量小段代码的执行时间，cProfile 分析函数调用频率和耗时。理解这些工具能指导优化方向，避免盲目猜测。

timeit 模块

timeit 精确测量小段代码的执行时间，自动处理计时器精度和垃圾回收：

import timeit

# 测量列表创建
t1 = timeit.timeit('list(range(1000))', number=10000)
print t1                # 总时间（秒）

# 多次运行取平均
t2 = timeit.repeat('list(range(1000))', repeat=3, number=10000)
print t2                # [0.123, 0.119, 0.121] —— 三次结果
print min(t2)           # 取最小值（最稳定）

命令行使用：

python -m timeit "list(range(1000))"
# 10000 loops, best of 3: 45.2 usec per loop

setup 参数：

import timeit

# 需要导入或定义变量
setup = """
import random
data = [random.random() for _ in range(1000)]
"""

t = timeit.timeit('sum(data)', setup=setup, number=1000)
print t

比较不同实现：

import timeit

# 字符串拼接
s1 = timeit.timeit('s = ""\nfor i in range(100):\n    s += str(i)', number=1000)

# 列表 join
s2 = timeit.timeit('s = "".join(str(i) for i in range(100))', number=1000)

print "String concat:", s1
print "List join:", s2
print "Join is %.1fx faster" % (s1 / s2)

cProfile 模块

cProfile 是 Python 标准库中的性能分析器，开销较小，适合分析完整程序：

import cProfile
import re

def test():
    for _ in range(1000):
        re.compile("[a-z]+")

cProfile.run('test()')

输出示例：

         2004 function calls in 0.015 seconds

   Ordered by: standard name

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
     1000    0.005    0.000    0.010    0.000 re.py:230(compile)
     1000    0.003    0.000    0.003    0.000 re.py:294(_compile)
        1    0.000    0.000    0.015    0.015 <string>:1(<module>)
        1    0.000    0.000    0.015    0.015 profile_test.py:4(test)
        1    0.000    0.000    0.000    0.000 {method 'disable' ...}

列说明：

列含义
ncalls调用次数
tottime函数自身执行时间（不含子调用）
percalltottime / ncalls
cumtime函数及其子调用总时间
percallcumtime / ncalls

保存分析结果：

import cProfile
import pstats

profiler = cProfile.Profile()
profiler.enable()

# 要分析的代码
for i in range(10000):
    sum(range(100))

profiler.disable()

# 保存到文件
profiler.dump_stats('profile.stats')

# 读取并排序显示
stats = pstats.Stats('profile.stats')
stats.sort_stats('cumtime')     # 按累计时间排序
stats.print_stats(20)           # 显示前 20 个

命令行使用：

python -m cProfile script.py
python -m cProfile -s cumtime script.py     # 按累计时间排序
python -m cProfile -o profile.stats script.py   # 保存到文件

内存分析

Python 2.7 标准库没有内存分析工具，需要第三方库：

pip install memory_profiler

from memory_profiler import profile

@profile
def process_large_data():
    data = []
    for i in range(100000):
        data.append("x" * 1000)
    return data

process_large_data()

运行：

python -m memory_profiler script.py

输出每行代码的内存增量。

优化策略

先分析，后优化：

import cProfile

# 1. 找到瓶颈
# 2. 只优化热点代码
# 3. 验证优化效果

常见优化方向：

问题解决方案
循环内重复计算提到循环外
字符串拼接用 join 或 StringIO
列表查找用 set 或 dict
全局变量访问提到局部变量
函数调用开销内联小函数
I/O 瓶颈批量读写、缓存

示例：优化查找：

import timeit

# 慢：列表查找 O(n)
setup_list = "items = range(1000)"
t1 = timeit.timeit('999 in items', setup=setup_list, number=10000)

# 快：集合查找 O(1)
setup_set = "items = set(range(1000))"
t2 = timeit.timeit('999 in items', setup=setup_set, number=10000)

print "List:", t1
print "Set:", t2
print "Set is %.1fx faster" % (t1 / t2)
# Set 通常快 100 倍以上

示例：优化循环：

import timeit

# 慢：每次循环访问全局
slow = """
result = []
for i in range(1000):
    result.append(math.sqrt(i))
"""

# 快：局部变量绑定
fast = """
result = []
append = result.append
sqrt = math.sqrt
for i in range(1000):
    append(sqrt(i))
"""

t1 = timeit.timeit(slow, setup='import math', number=10000)
t2 = timeit.timeit(fast, setup='import math', number=10000)

print "Slow:", t1
print "Fast:", t2

过早优化

Donald Knuth 的名言："过早优化是万恶之源"。优化前确保：

  1. 代码正确
  2. 有性能问题（通过分析确认）
  3. 优化的是热点代码（80/20 法则）

可读性通常比微优化更重要。只有在分析确认瓶颈后，才进行针对性优化。