如何对你的Python代码进行基准测试

啥叫做基准测试(benchmark)代码?其实主要就是测试(benchmarking)和分析(profiling)你的代码执行多快，并且找到代码瓶颈(bottlenecks)在哪里。 执行该动作的主要的目的就是优化(optimization)。也许因为业务需要你并且让你的代码执行更快一些。 当面临这种情况时，你就需要找出你的代码是在哪些部分慢的。

本文覆盖如何使用不同工具进行代码测试。

timeit

Python再带一个模块timeit。你可以使用它来对小代码进行计时。timeit模块使用针对平台的时间函数，你可以得到非常准确的一个时间结果。

timeit模块有个命令行接口，也可以通过导入的方式。我们将从命令行中使用开始。打开终端执行如下命令：

$ python3 -m timeit -s "[ord(x) for x in 'abcdfghi']"
100000000 loops, best of 3: 0.00907 usec per loop

$ python3 -m timeit -s "[chr(int(x)) for x in '123456789']"
100000000 loops, best of 3: 0.00897 usec per loop

发生啥啦？好吧，当你执行Python命令并且传递-m参数时，你是在告诉解释器去找该模块并且作为主要程序执行。 -s告知timeit模块执行一次代码。然后timeit就行执行代码三次，并且返回该三次的平均结果。该例子太过减少，它们 之间的区别可能不太明显。

你的机器上运行的结果可能跟我的会有一些偏差。

我们再写个简单函数，看看是否可以从命令行测试

# simple_func.py
def my_function():
    try:
        1 / 0
    except ZeroDivisionError:
        pass

整个函数的功能就是抛出一个异常然后直接忽略。很烂的例子。要通过命令使用timeit来测试，我们需要在命令空间中导入它，确保工作目录在当前文件目录下，然后执行：

$ python3 -m timeit "import simple_func; simple_func.my_function()"
1000000 loops, best of 3: 0.753 usec per loop

这里我们就导入该模块并且直接my_function()函数。注意我们使用了;来分来导入和执行代码。现在可以开始学习如何在Python脚本代码内部使用timeit了。

导入timeit测试

在代码中使用timeit模块也是相当容易的。我们还是使用之前很烂的例子：

def my_function():
    try:
        1 / 0
    except ZeroDivisionError:
        pass

if __name__ == "__main__":
    import timeit
    setup = "from __main__ import my_function"
    print(timeit.timeit("my_function()", setup=setup))

我们执行通过执行该脚本来验证。我们导入了timeit模块，然后调用timeit函数，参数的setup字符串将导入要测试函数到timeit的作用域中。现在 我们实现自己的装饰器测试函数。

使用装饰器

实现自己的装饰器计时函数是一件很有趣的事情，虽然不一定有timeit精确。

import random
import time

def timerfunc(func):
    """
    A timer decorator
    """
    def function_timer(*args, **kwargs):
        """
        A nested function for timing other functions
        """
        start = time.time()
        value = func(*args, **kwargs)
        end = time.time()
        runtime = end - start
        msg = "The runtime for {func} took {time} seconds to complete"
        print(msg.format(func=func.__name__, time=runtime))
        return value
    return function_timer

@timerfunc
def long_runner():
    for x in range(5):
        sleep_time = random.choice(range(1, 5))
        time.sleep(sleep_time)

if __name__ == "__main__":
    long_runner()

该例子中，我们导入了Python标准库的random和time模块。然后我们创建了装饰器函数。你将注意到它接收了一个函数以及 包含了另一函数。嵌套的函数在调用实际函数时将抓取时间，然后等待函数返回并抓取结束时间。现在我们知道函数所花费的时间，我们将它 打印出来。当然该装饰器函数也需要将实际函数执行返回的结果返回回来。

接下来的函数就是包装了该计时装饰器函数。你可以看到这里使用了随机休眠，该操作只是用来模拟耗时长程序。 也许你用来执行连接数据库（或者较大查询），跑线程或其他事情。

每次跑这段代码，结果都会有些不同。自己试试！

创建计时上下文管理器

一些码农可能更喜欢使用上下文的方式来测试小段代码。我们来构建看看：

import random
import time

class MyTimer:
    def __init__(self):
        self.start = time.time()

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        end = time.time()
        runtime = end - self.start
        msg = 'The function took {time} seconds to complete'
        print(msg.format(time=runtime))

def long_runner():
    for x in range(5):
        sleep_time = random.choice(range(1, 5))
        time.sleep(sleep_time)

if __name__ == "__main__":
    with MyTimer():
        long_runner()

本例中，我们使用__init__方法来开始我们计时，__enter__方法不做任何事情，仅仅返回它自己。__exit__方法 中抓取了结束时间，计算了总执行时间并打印。

然后我们就使用上下文管理器来测试我们执行的代码。

cProfile

Python内建了分析器。profile和cProfile模块。profile模块是纯Python实现，在测试过程中可能会增加很多额外的开支。所以推荐还是使用更快的cProfile。

我们不会过细的讲解该模块，我们来看看一些例子。

>>> import cProfile
>>> cProfile.run("[x for x in range(1500)]")
         4 function calls in 0.000 seconds

   Ordered by: standard name

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.000    0.000    0.000    0.000 <string>:1(<listcomp>)
        1    0.000    0.000    0.000    0.000 <string>:1(<module>)
        1    0.000    0.000    0.000    0.000 {built-in method exec}
        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}

我们来了解一下内容。第一行显示了有4个函数调用。下一行告诉结果排序方式。根据文档，standard name指的是最右边的列。 这里我们有好多列数据：

• ncalls: 调用了多少次
• tottime: 函数所花费的总时间
• percall: ncalls / tottime
• cumtime: 涵盖了该函数下的所有子函数（甚至地柜）函数所话费的时间
• 第二个percall: cumtime / 原始钓鱼那个
• filename: fileno (function) 每个函数响应信息

你也可以像timeit模块一样在命令行执行cProfile。主要的区别就是需要传递Python脚本而不是代码作为参数。

python3 -m cProfile test.py

尝试执行下该命令，看看执行结果。

line_profiler

有个第三方提供的项目叫line_profiler，它用来分析每行代码执行时间。它也有一个叫做kenprof的脚本使用line_profiler来分析Python应用和脚本。只需使用pip来安装该包。

 pip install line_profiler

在使用line_profiler之前我们需要一些代码来分析。不过我向先告诉你命令行中如何调用line_profiler.实际上需要执行kernprof脚本来调用line_profiler。

 kernprof -l silly_functions.py

执行完后将会打印出：Wrote profile results to silly_functions.py.lpro。该文件不能直接查看，是一个二进制文件。 当我们执行kernprof时，其实是在__builtins__命名空间中注入LineProfiler实例。该实例称为profile，用来作为装饰器函数。让我们来写实际脚本:

import time

@profile
def fast_function():
    print("I'm fast function!")

@profile
def slow_function():
    time.sleep(2)
    print("I'm slow function!")

if __name__ == "__main__":
    fast_function()
    slow_function()

现在我们拥有使用了profile装饰的函数。如果你直接执行该脚本将会报NameError错误，因为并没有定义profile。 所以记得再实际使用时移除@profile装饰器函数。

我们来学习如果查看分析器的结果。有两种办法，第一使用line_profiler模块读结果文件：

$ python -m line_profiler silly_functions.py.lprof

还有种是在执行kernprof时带上-v参数：

$ kernprof -l -v silly_functions.py

无论哪种办法你都将得到如下结果：

I'm fast function!
I'm slow function!
Wrote profile results to silly_functions.py.lprof
Timer unit: 1e-06 s

Total time: 4e-05 s
File: silly_functions.py
Function: fast_function at line 3

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
     3                                           @profile
     4                                           def fast_function():
     5         1           40     40.0    100.0      print("I'm fast function!")

Total time: 2.00227 s
File: silly_functions.py
Function: slow_function at line 7

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
     7                                           @profile
     8                                           def slow_function():
     9         1      2002114 2002114.0    100.0      time.sleep(2)
    10         1          157    157.0      0.0      print("I'm slow function!")

我们可以看到结果中显示了每行代码的执行时间相关信息。有6列内容。我们来看看每列代表的意思。

• Line#: 分析的代码行数
• Hits: 执行次数
• Time: 该行代码执行时间
• Per Hit: 每次执行时间
• % Time: 函数中所占时间比率
• Line Contents: 执行的代码

如果你用IPython，你可能想知道IPython的魔术方法%lprun可以分析制定函数，甚至是具体代码。

memory_profiler

另一个用来分析的第三方包叫做memory_profiler.它用来分析每行代码在进程中所消耗的内存。我们也使用pip来安装它。

pip install memory_profiler

装好后，我们也需要代码来评测。memory_prifiler执行方式和line_profiler非常相似，它将在__builtins__注入profiler装饰器来测试函数。

@profile
def mem_func():
    lots_of_numbers = list(range(1500))
    x = ['letters'] * (5 ** 10)
    del lots_of_numbers
    return None

if __name__ == "__main__":
    mem_func()

本例中我们创建了1500整形list。然后我们又创建了9765625(5的10次方)字符串李彪。最后我们删除了第一个list并返回。memory_profiler没有提供另外一个脚本来让你执行该程序，而是直接通过-m参数来调用模块。

$ python -m memory_profiler memo_prof.py
Filename: memo_prof.py

Line #    Mem usage    Increment   Line Contents
================================================
     1   13.133 MiB    0.000 MiB   @profile
     2                             def mem_func():
     3   13.387 MiB    0.254 MiB       lots_of_numbers = list(range(1500))
     4   87.824 MiB   74.438 MiB       x = ['letters'] * (5 ** 10)
     5   87.938 MiB    0.113 MiB       del lots_of_numbers
     6   87.938 MiB    0.000 MiB       return None

结果的提供的信息就非常直观了。包含代码行数和改行执行完后的内存使用，接下来是内存增加量，最后是执行的代码。

memory_profiler也提供mprof用来创建完整的内存使用报表，而不是每行结果。

$ mprof run memo_prof.py
mprof: Sampling memory every 0.1s
running as a Python program...

mprof也提供来图示来查看应用内存消耗，需要查看图表前我们需要先安装matplotlib

$ pip install matplotlib

然后执行:

$ mprof plot

我们得到如下图：

profilehooks

最后个要介绍的第三方包是profilehooks.它拥有一系列包装器来分期函数。安装：

pip install profilehooks

安装完后，我们修改上次例子替换成profilehooks:

from profilehooks import profile

@profile
def mem_func():
    lots_of_numbers = list(range(1500))
    x = ['letters'] * (5 ** 10)
    del lots_of_numbers
    return None

if __name__ == "__main__":
    mem_func()

仅仅要做的是导入profilehooks并且包装到要测试的函数中。执行后：

*** PROFILER RESULTS ***
mem_func (profhooks.py:3)
function called 1 times

         2 function calls in 0.036 seconds

   Ordered by: cumulative time, internal time, call count

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.036    0.036    0.036    0.036 profhooks.py:3(mem_func)
        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}
        0    0.000             0.000          profile:0(profiler)

输出的结果和cProfile是一样的，你可以看看我之前对这些列的描述。profilehooks提供了两个装饰器。我们来看看第一个timecall，它提供了函数执行时间。

from profilehooks import timecall

@timecall
def mem_func():
    lots_of_numbers = list(range(1500))
    x = ['letters'] * (5 ** 10)
    del lots_of_numbers
    return None

if __name__ == "__main__":
    mem_func()

执行后你将看到如下输出：

  mem_func (profhooks2.py:3):
    0.056 seconds

整个包装其输出整个函数执行时间，和timeit是一样的。

另一个profilehooks提供的装饰器是coverage。它用来打印函数每行代码涵盖数。不过我看来用处到不是很大，你可以自己试试：

*** COVERAGE RESULTS ***
mem_func (profhooks3.py:3)
function called 1 times

       @coverage
       def mem_func():
    1:     lots_of_numbers = list(range(1500))
    1:     x = ['letters'] * (5 ** 10)
    1:     del lots_of_numbers
    1:     return None

最后要告诉你的是，你也可以通过-m参数来从命令行中执行profilehooks.

python -m profilehooks mymodule.py

profilehooks是一个新包，不过我到觉得应该会很有前途。

总结

本文涵盖了需要信息。分享了如何使用Python内建模块,timeit和cProfile来测试和分期你的代码，我还学会了如何自己包装计时包装 器和上下文管理器。然后我们还学习了一些第三方包：line_profiler, memory_profiler和profilehooks。就目前，你已经学会如何分析你的代码，查找代码瓶颈。