Python Files 博客发布了几篇主题为「Hunting Performance in Python Code」的系列文章，对提升 Python 代码的性能的方法进行了介绍。在其中的每一篇文章中，作者都会介绍几种可用于 Python 代码的工具和分析器，以及它们可以如何帮助你更好地在前端（Python 脚本）和/或后端（Python 解释器）中找到瓶颈。
代码地址：
目录
一、环境设置
二、内存分析
三、CPU 分析——Python 脚本
四、CPU 分析——Python 解释器（略）
一、环境设置
设置
在深入到基准测试和性能分析之前，首先我们需要一个合适的环境。这意味着我们需要为这项任务配置我们的机器和操作系统。
我的机器的规格如下：
处理器：Intel(R) Xeon(R) CPU E5-2699 v3 @ 2.30GHz
内存：32GB
操作系统：Ubuntu 16.04 LTS
Kernel：4.4.0-75-generic
我们的目标是得到可复现的结果，因此要确保我们的数据不会受到其它后台进程、操作系统配置或任何其它硬件性能提升技术的影响。
让我们首先从配置用于性能分析的机器开始。
硬件功能
首先，禁用所有硬件性能功能，也就是说要禁用 Intel Turbo Boost 和 Hyper Threading from BIOS/UEFI。
正如其官方网页上说的那样，Turbo Boost 是「一种在处理器内核运行，并可以在低于功耗、电流和温度规格限制的情况下允许它们以高于额定频率的速度运行的技术。」此外，Hyper Threading 是「一种可以更高效地利用处理器资源的技术，能使每个内核都能多线程运行。」
这都是值得我们花钱购买的好东西。那为什么要在性能分析/基准测试中禁用它们呢？因为使用这些技术会让我们无法得到可靠的和可复现的结果。这会让运行过程发生变化。让我们看个小例子 primes.py，代码故意写得很糟糕。
import time
import statistics
def primes(n):
if n==2:
return [2]
elif n<2:
return []
s=range(3,n+1,2)
mroot = n ** 0.5
half=(n+1)/2-1
i=0
m=3
while m <= mroot:
if s[i]:
j=(m*m-3)/2
s[j]=0
while j<half:
s[j]=0
j+=m
i=i+1
m=2*i+3
return [2]+[x for x in s if x]
def benchmark():
results = []
gstart = time.time()
for _ in xrange(5):
start = time.time()
count = len(primes(1000000))
end = time.time()
results.append(end-start)
gend = time.time()
mean = statistics.mean(results)
stdev = statistics.stdev(results)
perc = (stdev * 100)/ mean
print "Benchmark duration: %r seconds" % (gend-gstart)
print "Mean duration: %r seconds" % mean
print "Standard deviation: %r (%r %%)" % (stdev, perc)
benchmark()
这段代码可在 GitHub 上查看：。你需要运行以下命令安装一个依赖包：
pip install statistics
让我们在一个启用了 Turbo Boost 和 Hyper Threading 的系统中运行它：
python primes.py
Benchmark duration: 1.0644240379333496 seconds
Mean duration: 0.2128755569458008 seconds
Standard deviation: 0.032928838418120374 (15.468585914964498 %)
现在禁用该系统的睿频加速（Turbo Boost）和超线程（Hyper Threading），然后再次运行这段代码：
python primes.py
Benchmark duration: 1.2374498844146729 seconds
Mean duration: 0.12374367713928222 seconds
Standard deviation: 0.000684464852339824 (0.553131172568 %)
看看第一个案例的标准差为 15%。这是一个很大的值！假设我们的优化只能带来 6% 的加速，那我们怎么能将运行过程中的变化（run to run variation）和你的实现的差异区分开？
相对而言，在第二个例子中，标准差减少到了大约 0.6%，我们的新优化方案效果清晰可见。
CPU 节能
禁用所有的 CPU 节能设置，并使用固定的 CPU 频率。这可以通过在 Linux 功率调节器（power governor）中将 intel_pstate 改成 acpi_cpufreq 而实现。
intel_pstate 驱动使用英特尔内核（Sandy Bridge 或更新）处理器的内部调节器实现了一个缩放驱动。acpi_cpufreq 使用了 ACPI Processor Performance States。
下面让我们先来检查一下：
$ cpupower frequency-info
analyzing CPU 0:
driver: intel_pstate
CPUs which run at the same hardware frequency: 0
CPUs which need to have their frequency coordinated by software: 0
maximum transition latency: 0.97 ms.
hardware limits: 1.20 GHz - 3.60 GHz
available cpufreq governors: performance, powersave
current policy: frequency should be within 1.20 GHz and 3.60 GHz.
The governor "powersave" may decide which speed to use
within this range.
current CPU frequency is 1.20 GHz.
boost state support:
Supported: yes
Active: yes
可以看到这里所使用的调节器被设置成了节能模式，而 CPU 的频率范围在 1.20 GHz 到 3.60 GHz 之间。这个设置对日常应用来说是很不错的，但却会影响到基准测试的结果。
那么应该给调节器设置什么值呢？如果我们浏览一下文档，我们可以看到我们可以使用以下设置：
高性能（performance）：以最大频率运行 CPU
节能（powersave）：以最小频率运行 CPU
自定义（userspace）：按用户指定的频率运行 CPU
按需（ondemand）：根据当前负载动态调节频率。可能跳至最高频率，空闲时又会降低
保守（conservative）：根据当前负载动态调节频率。相比于按需模式，其频率调节更加渐进
我们要使用性能调节器（performance governor），并将频率设置成 CPU 支持的最大频率。如下所示：
$ cpupower frequency-info
analyzing CPU 0:
driver: acpi-cpufreq
CPUs which run at the same hardware frequency: 0
CPUs which need to have their frequency coordinated by software: 0
maximum transition latency: 10.0 us.
hardware limits: 1.20 GHz - 2.30 GHz
available frequency steps: 2.30 GHz, 2.20 GHz, 2.10 GHz, 2.00 GHz, 1.90 GHz, 1.80 GHz, 1.70 GHz, 1.60 GHz, 1.50 GHz, 1.40 GHz, 1.30 GHz, 1.20 GHz
available cpufreq governors: conservative, ondemand, userspace, powersave, performance
current policy: frequency should be within 2.30 GHz and 2.30 GHz.
The governor "performance" may decide which speed to use
within this range.
current CPU frequency is 2.30 GHz.
cpufreq stats: 2.30 GHz:100.00%, 2.20 GHz:0.00%, 2.10 GHz:0.00%, 2.00 GHz:0.00%, 1.90 GHz:0.00%, 1.80 GHz:0.00%, 1.70 GHz:0.00%, 1.60 GHz:0.00%, 1.50 GHz:0.00%, 1.40 GHz:0.00%, 1.30 GHz:0.00%, 1.20 GHz:0.00% (174)
boost state support:
Supported: no
Active: no
现在你已经使用性能调节器将频率设置成了固定的 2.3 GHz。这是最大的可设置的值，没有睿频加速（Turbo Boost），它可以被用在 Xeon E5-2699 v3 上。
要完成设置，请使用管理员权限运行以下命令：
cpupower frequency-set -g performance
cpupower frequency-set --min 2300000 --max 2300000
如果你没有 cpupower，可使用以下命令安装：
sudo apt-get install linux-tools-common linux-header-`uname -r` -y
功率调节器对 CPU 的工作方式有很大的影响。该调节器的默认设置是自动调节频率以减少功耗。我们不想要这样的设置，所以从 GRUB 中禁用它。只需要编辑 /boot/grub/grub.cfg（但是如果你在 kernel 升级上很小心，那么这将会消失）或在 /etc/grub.d/40_custom 中创建一个新的 kernel 入口。我们的 boot 行中必须包含这个 flag： intel_pstate=disable，如下所示：
linux /boot/vmlinuz-4.4.0-78-generic.efi.signed root=UUID=86097ec1-3fa4-4d00-97c7-3bf91787be83 ro intel_pstate=disable quiet splash $vt_handoff
ASLR（地址空间配置随机发生器）
这个设置是有争议的，参见 Victor Stinner 的博客： 的支持。
我为什么要说这个呢？因为在上面给出的特定硬件上，禁用 ASLR 可以将运行之间的标准差降低至 0.4%。
另一方面，根据在我的个人计算机（Intel Core i7 4710MQ）上的测试，禁用 ASLR 会导致 Victor 所提到的同样的问题。在更小的 CPU（比如 Intel Atom）上的测试会带来甚至更大的运行间标准差。
因为这似乎并不是普遍适用的真理，而且很大程度上依赖于硬件/软件配置，所以对于这个设置，我在启用后测量一次，再禁用后测量一次，之后再进行比较。
在我的机器上，我通过在 /etc/sysctl.conf. 中加入以下命令禁用了 ASLR。使用 sudo sysctl -p 进行应用。
kernel.randomize_va_space = 0
如果你想在运行时禁用它：
sudo bash -c 'echo 0 >| /proc/sys/kernel/randomize_va_space'
如果你想重新启用：
sudo bash -c 'echo 2 >| /proc/sys/kernel/randomize_va_space'
二、内存分析
在这一节，我将介绍一些有助于我们解决 Python 中（尤其是使用 PyPy 时）的内存消耗难题的工具。
我们为什么要关心这个问题？为什么我们不仅仅就关心性能？这些问题的答案相当复杂，但我会总结出来。
PyPy 是一个可选的 Python 解释器，其相对于 CPython 有一些巨大的优势：速度（通过其 Just in Time 编译器）、兼容性（几乎可以替代 CPython）和并发性（使用 stackless 和 greenlets）。
PyPy 的一个缺点是因为其 JIT 和垃圾一样的回收站实现，它通常会使用比 CPython 更多的内存。但是在某些案例中，其的内存消耗会比 CPython 少。
下面我们来看看你可以如何测量你的应用使用了多少内存。
诊断内存使用
memory_profiler
memory_profiler 是一个可用来测量解释器运行一个负载时的内存用量的库。你可以通过 pip 安装它：
pip install memory_profiler
另外还要安装 psutil 依赖包：
pip install psutil
这个工具的优点是它会在一个 Python 脚本中一行行地显示内存消耗。这可以让我们找到脚本中可以被我们重写的位置。但这种分析有一个缺点。你的代码的运行速度比一般脚本慢 10 到 20 倍。
怎么使用它？你只需要在你需要测量的函数上直接加上 @profile() 即可。
让我们看看实际怎么操作！我们将使用之前用过的素材脚本作为模型，但做了一点修改，移除了统计部分。代码也可在 GitHub 查看：
from memory_profiler import profile
@profile(precision=6)
def primes(n):
if n == 2:
return [2]
elif n < 2:
return []
s = range(3, n + 1, 2)
mroot = n ** 0.5
half = (n + 1) / 2 - 1
i = 0
m = 3
while m <= mroot:
if s[i]:
j = (m * m - 3) / 2
s[j] = 0
while j < half:
s[j] = 0
j += m
i = i + 1
m = 2 * i + 3
return [2] + [x for x in s if x]
len(primes(100000))
开始测量时，使用以下 PyPy 命令：
pypy -m memory_profiler 02.primes-v3.py
或者直接在脚本中导入 memory_profiler：
pypy -m memory_profiler 02.primes-v3.py
在执行完这行代码之后，我们可以看到 PyPy 得到这样的结果：
Line # Mem usage Increment Line Contents
54 35.312500 MiB 0.000000 MiB @profile(precision=6)
55 def primes(n):
56 35.351562 MiB 0.039062 MiB if n == 2:
57 return [2]
58 35.355469 MiB 0.003906 MiB elif n < 2:
59 return []
60 35.355469 MiB 0.000000 MiB s = []
61 59.515625 MiB 24.160156 MiB for i in range(3, n+1):
62 59.515625 MiB 0.000000 MiB if i % 2 != 0:
63 59.515625 MiB 0.000000 MiB s.append(i)
64 59.546875 MiB 0.031250 MiB mroot = n ** 0.5
65 59.550781 MiB 0.003906 MiB half = (n + 1) / 2 - 1
66 59.550781 MiB 0.000000 MiB i = 0
67 59.550781 MiB 0.000000 MiB m = 3
68 59.554688 MiB 0.003906 MiB while m <= mroot:
69 59.554688 MiB 0.000000 MiB if s[i]:
70 59.554688 MiB 0.000000 MiB j = (m * m - 3) / 2
71 59.554688 MiB 0.000000 MiB s[j] = 0
72 59.554688 MiB 0.000000 MiB while j < half:
73 59.554688 MiB 0.000000 MiB s[j] = 0
74 59.554688 MiB 0.000000 MiB j += m
75 59.554688 MiB 0.000000 MiB i = i + 1
76 59.554688 MiB 0.000000 MiB m = 2 * i + 3
77 59.554688 MiB 0.000000 MiB l = [2]
78 59.679688 MiB 0.125000 MiB for x in s:
79 59.679688 MiB 0.000000 MiB if x:
80 59.679688 MiB 0.000000 MiB l.append(x)
81 59.683594 MiB 0.003906 MiB return l
我们可以看到这个脚本使用了 24.371094 MiB 的 RAM。让我们简单分析一下。我们看到其中大多数都用在了数值数组的构建中。它排除了偶数数值，保留了所有其它数值。
我们可以通过调用 range 函数而对其进行一点改进，其使用一个增量参数。在这个案例中，该脚本看起来像是这样：
from memory_profiler import profile
@profile(precision=6)
def primes(n):
if n == 2:
return [2]
elif n < 2:
return []
s = range(3, n + 1, 2)
mroot = n ** 0.5
half = (n + 1) / 2 - 1
i = 0
m = 3
while m <= mroot:
if s[i]:
j = (m * m - 3) / 2
s[j] = 0
while j < half:
s[j] = 0
j += m
i = i + 1
m = 2 * i + 3
l = [2]
for x in s:
if x:
l.append(x)
return l
len(primes(100000))
如果我们再次测量，我们可以得到以下结果：
Line # Mem usage Increment Line Contents
27 35.343750 MiB 0.000000 MiB @profile(precision=6)
28 def primes(n):
29 35.382812 MiB 0.039062 MiB if n == 2:
30 return [2]
31 35.382812 MiB 0.000000 MiB elif n < 2:
32 return []
33 35.386719 MiB 0.003906 MiB s = range(3, n + 1, 2)
34 35.417969 MiB 0.031250 MiB mroot = n ** 0.5
35 35.417969 MiB 0.000000 MiB half = (n + 1) / 2 - 1
36 35.417969 MiB 0.000000 MiB i = 0
37 35.421875 MiB 0.003906 MiB m = 3
38 58.019531 MiB 22.597656 MiB while m <= mroot:
39 58.019531 MiB 0.000000 MiB if s[i]:
40 58.019531 MiB 0.000000 MiB j = (m * m - 3) / 2
41 58.019531 MiB 0.000000 MiB s[j] = 0
42 58.019531 MiB 0.000000 MiB while j < half:
43 58.019531 MiB 0.000000 MiB s[j] = 0
44 58.019531 MiB 0.000000 MiB j += m
45 58.019531 MiB 0.000000 MiB i = i + 1
46 58.019531 MiB 0.000000 MiB m = 2 * i + 3
47 58.019531 MiB 0.000000 MiB l = [2]
48 58.089844 MiB 0.070312 MiB for x in s:
49 58.089844 MiB 0.000000 MiB if x:
50 58.089844 MiB 0.000000 MiB l.append(x)
51 58.093750 MiB 0.003906 MiB return l
很好，现在我们的内存消耗下降到了 22.75 MiB。使用列表解析（list comprehension），我们还可以将消耗再降低一点。
from memory_profiler import profile
@profile(precision=6)
def primes(n):
if n == 2:
return [2]
elif n < 2:
return []
s = range(3, n + 1, 2)
mroot = n ** 0.5
half = (n + 1) / 2 - 1
i = 0
m = 3
while m <= mroot:
if s[i]:
j = (m * m - 3) / 2
s[j] = 0
while j < half:
s[j] = 0
j += m
i = i + 1
m = 2 * i + 3
return [2] + [x for x in s if x]
len(primes(100000))
再次测量：
Line # Mem usage Increment Line Contents
4 35.425781 MiB 0.000000 MiB @profile(precision=6)
5 def primes(n):
6 35.464844 MiB 0.039062 MiB if n == 2:
7 return [2]
8 35.464844 MiB 0.000000 MiB elif n < 2:
9 return []
10 35.464844 MiB 0.000000 MiB s = range(3, n + 1, 2)
11 35.500000 MiB 0.035156 MiB mroot = n ** 0.5
12 35.500000 MiB 0.000000 MiB half = (n + 1) / 2 - 1
13 35.500000 MiB 0.000000 MiB i = 0
14 35.500000 MiB 0.000000 MiB m = 3
15 57.683594 MiB 22.183594 MiB while m <= mroot:
16 57.683594 MiB 0.000000 MiB if s[i]:
17 57.683594 MiB 0.000000 MiB j = (m * m - 3) / 2
18 57.683594 MiB 0.000000 MiB s[j] = 0
19 57.683594 MiB 0.000000 MiB while j < half:
20 57.683594 MiB 0.000000 MiB s[j] = 0
21 57.683594 MiB 0.000000 MiB j += m
22 57.683594 MiB 0.000000 MiB i = i + 1
23 57.683594 MiB 0.000000 MiB m = 2 * i + 3
24 57.847656 MiB 0.164062 MiB return [2] + [x for x in s if x]
我们最后的脚本仅消耗 22.421875 MiB。相比于第一个版本，差不多下降了 10%。
三、CPU 分析——Python 脚本
在这一节，我将介绍一些有助于我们解决 Python 中的分析 CPU 使用的难题的工具。
CPU 性能分析（profiling）的意思是通过分析 CPU 执行代码的方式来分析这些代码的性能。也就是说要找到我们代码中的热点（hot spot），然后看我们可以怎么处理它们。
接下来我们会看看你可以如何追踪你的 Python 脚本的 CPU 使用。我们将关注以下分析器（profiler）：
* cProfile
* line_profiler
* pprofile
* vprof
测量 CPU 使用
import time
def primes(n):
if n == 2:
return [2]
elif n < 2:
return []
s = []
for i in range(3, n+1):
if i % 2 != 0:
s.append(i)
mroot = n ** 0.5
half = (n + 1) / 2 - 1
i = 0
m = 3
while m <= mroot:
if s[i]:
j = (m * m - 3) / 2
s[j] = 0
while j < half:
s[j] = 0
j += m
i = i + 1
m = 2 * i + 3
l = [2]
for x in s:
if x:
l.append(x)
return l
def benchmark():
start = time.time()
for _ in xrange(40):
count = len(primes(1000000))
end = time.time()
print "Benchmark duration: %r seconds" % (end-start)
benchmark()
这一节我将使用与前一节基本一样的脚本，你也可以在 GitHub 上查看：
另外，记住在 PyPy2 上，你需要使用一个支持它的 pip 版本：
pypy -m ensure pip
其它东西可以通过以下指令安装：
pypy -m pip install
cProfile
在 CPU 性能分析上最常用的一个工具是 cProfile，主要是因为它内置于 CPython2 和 PyPy2 中。这是一个确定性的分析器，也就是说它会在运行我们的负载时收集一系列统计数据，比如代码各个部分的执行次数或执行时间。此外，相比于其它内置的分析器（profile 或 hotshot），cProfile 对系统的开销更少。
当使用 CPython2 时，其使用方法是相当简单的：
python -m cProfile 03.primes-v1.py
如果你使用的是 PyPy2：
pypy -m cProfile 03.primes-v1.py
其输出如下：
Benchmark duration: 30.11158514022827 seconds
23139965 function calls in 30.112 seconds
Ordered by: standard name
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.000 0.000 30.112 30.112 03.primes.py:1(<module>)
40 19.760 0.494 29.896 0.747 03.primes.py:3(primes)
1 0.216 0.216 30.112 30.112 03.primes.py:31(benchmark)
40 0.000 0.000 0.000 0.000 {len}
23139840 6.683 0.000 6.683 0.000 {method 'append' of 'list' objects}
1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects}
40 3.453 0.086 3.453 0.086 {range}
2 0.000 0.000 0.000 0.000 {time.time}
即使是这样的文本输出，我们也可以直接看到我们脚本的大多数时间都在调用 list.append 方法。
如果我们使用 gprof2dot，我们可以用图形化的方式来查看 cProfile 的输出。要使用这个工具，我们首先必须安装 graphviz。在 Ubuntu 上，可以使用以下命令：
apt-get install graphviz
pip install gprof2dot
再次运行我们的脚本：
python -m cProfile -o output.pstats 03.primes-v1.py
gprof2dot -f pstats output.pstats | dot -Tpng -o output.png
然后我们会得到下面的 output.png 文件：
这样看起来就轻松多了。让我们仔细看看它输出了什么。你可以看到来自你的脚本的一个函数调用图（callgraph）。在每个方框中，你可以一行一行地看到：
第一行：Python 文件名、行数和方法名
第二行：这个方框所用的时间占全局时间的比例
第三行：括号中是该方法本身所用时间占全局时间的比例
第四行：调用次数
比如说，在从上到下第三个红色框中，方法 primes 占用了 98.28% 的时间，65.44% 的时间是在该方法之中做什么事情，它被调用了 40 次。剩下的时间被用在了 Python 的 list.append（22.33%）和 range（11.51%）方法中。
这是一个简单的脚本，所以我们只需要重写我们的脚本，让它不用使用那么多 append，结果如下：
import time
def primes(n):
if n==2:
return [2]
elif n<2:
return []
s=range(3,n+1,2)
mroot = n ** 0.5
half=(n+1)/2-1
i=0
m=3
while m <= mroot:
if s[i]:
j=(m*m-3)/2
s[j]=0
while j<half:
s[j]=0
j+=m
i=i+1
m=2*i+3
return [2]+[x for x in s if x]
def benchmark():
start = time.time()
for _ in xrange(40):
count = len(primes(1000000))
end = time.time()
print "Benchmark duration: %r seconds" % (end-start)
benchmark()
如果我们在此之前和之后使用 CPython2 测量脚本的时间：
python 03.primes-v1.py
Benchmark duration: 15.768115043640137 seconds
python 03.primes-v2.py
Benchmark duration: 6.56312108039856 seconds
用 PyPy2 测量：
pypy 03.primes-v1.py
Benchmark duration: 1.4009230136871338 seconds
pypy 03.primes-v2.py
Benchmark duration: 0.4542720317840576 seconds
我们在 CPython2 上得到了 2.4 倍的提升，在 PyPy2 上得到了 3.1 倍的提升。很不错，其 cProfile 调用图为：
你也可以以程序的方式查看 cProfile：
import cProfile
pr = cProfile.Profile()
pr.enable()
function_to_measure()
pr.disable()
pr.print_stats(sort='time')
这在一些场景中很有用，比如多进程性能测量。更多详情请参阅：
line_profiler
这个分析器可以提供逐行水平的负载信息。这是通过 C 语言用 Cython 实现的，与 cProfile 相比计算开销更少。
其源代码可在 GitHub 上获取： 倍的时间才能得到一个分析结果。
要使用这个工具，你首先需要通过 pip 添加：pip install pip install Cython ipython==5.4.1 line_profiler（CPython2）。这个分析器的一个主要缺点是不支持 PyPy。
就像在使用 memory_profiler 时一样，你需要在你想分析的函数上加上一个装饰。在我们的例子中，你需要在 03.primes-v1.py 中的 primes 函数的定义前加上 @profile。然后像这样调用：
kernprof -l 03.primes-v1.py
python -m line_profiler 03.primes-v1.py.lprof
你会得到一个这样的输出：
Timer unit: 1e-06 s
Total time: 181.595 s
File: 03.primes-v1.py
Function: primes at line 3
Line # Hits Time Per Hit % Time Line Contents
3 @profile
4 def primes(n):
5 40 107 2.7 0.0 if n == 2:
6 return [2]
7 40 49 1.2 0.0 elif n < 2:
8 return []
9 40 44 1.1 0.0 s = []
10 39999960 34410114 0.9 18.9 for i in range(3, n+1):
11 39999920 29570173 0.7 16.3 if i % 2 != 0:
12 19999960 14976433 0.7 8.2 s.append(i)
13 40 329 8.2 0.0 mroot = n ** 0.5
14 40 82 2.0 0.0 half = (n + 1) / 2 - 1
15 40 46 1.1 0.0 i = 0
16 40 30 0.8 0.0 m = 3
17 20000 17305 0.9 0.0 while m <= mroot:
18 19960 16418 0.8 0.0 if s[i]:
19 6680 6798 1.0 0.0 j = (m * m - 3) / 2
20 6680 6646 1.0 0.0 s[j] = 0
21 32449400 22509523 0.7 12.4 while j < half:
22 32442720 26671867 0.8 14.7 s[j] = 0
23 32442720 22913591 0.7 12.6 j += m
24 19960 15078 0.8 0.0 i = i + 1
25 19960 16170 0.8 0.0 m = 2 * i + 3
26 40 87 2.2 0.0 l = [2]
27 20000000 14292643 0.7 7.9 for x in s:
28 19999960 13753547 0.7 7.6 if x:
29 3139880 2417421 0.8 1.3 l.append(x)
30 40 33 0.8 0.0 return l
我们可以看到两个循环在反复调用 list.append，占用了脚本的大部分时间。
pprofile
地址：
据作者介绍，pprofile 是一个「行粒度的、可感知线程的确定性和统计性纯 Python 分析器」。
它的灵感来源于 line_profiler，修复了大量缺陷，但因为其完全是用 Python 写的，所以也可以通过 PyPy 使用。和 cProfile 相比，使用 CPython 时分析的时间会多 28 倍，使用 PyPy 时的分析时间会长 10 倍，但具有粒度更大的细节水平。
而且还支持 PyPy 了！除此之外，它还支持线程分析，这在很多情况下都很有用。
要使用这个工具，你首先需要通过 pip 安装：pip install pprofile（CPython2）/ pypy -m pip install pprofile（PyPy），然后像这样调用：
pprofile 03.primes-v1.py
其输出和前面工具的输出不同，如下：
Benchmark duration: 886.8774709701538 seconds
Command line: ['03.primes-v1.py']
Total duration: 886.878s
File: 03.primes-v1.py
File duration: 886.878s (100.00%)
Line #| Hits| Time| Time per hit| %|Source code
1| 2| 7.10487e-05| 3.55244e-05| 0.00%|import time
2| 0| 0| 0| 0.00%|
3| 0| 0| 0| 0.00%|
4| 41| 0.00029397| 7.17e-06| 0.00%|def primes(n):
5| 40| 0.000231266| 5.78165e-06| 0.00%| if n == 2:
6| 0| 0| 0| 0.00%| return [2]
7| 40| 0.000178337| 4.45843e-06| 0.00%| elif n < 2:
8| 0| 0| 0| 0.00%| return []
9| 40| 0.000188112| 4.70281e-06| 0.00%| s = []
10| 39999960| 159.268| 3.98171e-06| 17.96%| for i in range(3, n+1):
11| 39999920| 152.924| 3.82312e-06| 17.24%| if i % 2 != 0:
12| 19999960| 76.2135| 3.81068e-06| 8.59%| s.append(i)
13| 40| 0.00147367| 3.68416e-05| 0.00%| mroot = n ** 0.5
14| 40| 0.000319004| 7.9751e-06| 0.00%| half = (n + 1) / 2 - 1
15| 40| 0.000220776| 5.51939e-06| 0.00%| i = 0
16| 40| 0.000243902| 6.09756e-06| 0.00%| m = 3
17| 20000| 0.0777466| 3.88733e-06| 0.01%| while m <= mroot:
18| 19960| 0.0774016| 3.87784e-06| 0.01%| if s[i]:
19| 6680| 0.0278566| 4.17015e-06| 0.00%| j = (m * m - 3) / 2
20| 6680| 0.0275929| 4.13067e-06| 0.00%| s[j] = 0
21| 32449400| 114.858| 3.5396e-06| 12.95%| while j < half:
22| 32442720| 120.841| 3.72475e-06| 13.63%| s[j] = 0
23| 32442720| 114.432| 3.5272e-06| 12.90%| j += m
24| 19960| 0.0749919| 3.75711e-06| 0.01%| i = i + 1
25| 19960| 0.0765574| 3.83554e-06| 0.01%| m = 2 * i + 3
26| 40| 0.000222206| 5.55515e-06| 0.00%| l = [2]
27| 20000000| 68.8031| 3.44016e-06| 7.76%| for x in s:
28| 19999960| 67.9391| 3.39696e-06| 7.66%| if x:
29| 3139880| 10.9989| 3.50295e-06| 1.24%| l.append(x)
30| 40| 0.000155687| 3.89218e-06| 0.00%| return l
31| 0| 0| 0| 0.00%|
32| 0| 0| 0| 0.00%|
33| 2| 8.10623e-06| 4.05312e-06| 0.00%|def benchmark():
34| 1| 5.00679e-06| 5.00679e-06| 0.00%| start = time.time()
35| 41| 0.00101089| 2.4656e-05| 0.00%| for _ in xrange(40):
36| 40| 0.232263| 0.00580657| 0.03%| count = len(primes(1000000))
(call)| 40| 886.644| 22.1661| 99.97%|# 03.primes-v1.py:4 primes
37| 1| 5.96046e-06| 5.96046e-06| 0.00%| end = time.time()
38| 1| 0.000678062| 0.000678062| 0.00%| print "Benchmark duration: %r seconds" % (end-start)
39| 0| 0| 0| 0.00%|
40| 0| 0| 0| 0.00%|
41| 1| 5.79357e-05| 5.79357e-05| 0.00%|benchmark()
(call)| 1| 886.878| 886.878|100.00%|# 03.primes-v1.py:33 benchmark
我们现在可以看到更详细的细节。让我们稍微研究一下这个输出。这是这个脚本的整个输出，每一行你可以看到调用的次数、运行它所用的时间（秒）、每次调用的时间和占全局时间的比例。此外，pprofile 还为我们的输出增加了额外的行（比如 44 和 50 行，行前面写着 (call）)，这是累积指标。
同样，我们可以看到有两个循环在反复调用 list.append，占用了脚本的大部分时间。
vprof
地址：
vprof 是一个 Python 分析器，为各种 Python 程序特点提供了丰富的交互式可视化，比如运行时间和内存使用。这是一个图形化工具，基于 Node.JS，可在网页上展示结果。
使用这个工具，你可以针对相关 Python 脚本查看下面的一项或多项内容：
CPU flame graph
代码分析（code profiling）
内存图（memory graph）
代码热图（code heatmap）
要使用这个工具，你首先需要通过 pip 安装：pip install vprof（CPython2）/ pypy -m pip install vprof（PyPy）。
在 CPython2 上，要显示代码热图（下面的第一行调用）和代码分析（下面的第二行调用）：
vprof -c h 03.primes-v1.py
vprof -c p 03.primes-v1.py
在 PyPy 上，要显示代码热图（下面的第一行调用）和代码分析（下面的第二行调用）：
pypy -m vprof -c h 03.primes-v1.py
pypy -m vprof -c p 03.primes-v1.py
在上面的两个例子中，你都会看到如下的代码热图：
以及如下的代码分析：
结果是以图形化的方式展示的，你可以将鼠标悬浮或点击每一行，从而查看更多信息。
同样，我们可以看到有两个循环在反复调用 list.append，占用了脚本的大部分时间。
