Python 性能分析入门指南

www.net130.com     日期:2014-8-15    浏览次数:
出处:51CTO

虽然并非你编写的每个 Python 程序都要求一个严格的性能分析,但是让人放心的是,当问题发生的时候,Python 生态圈有各种各样的工具可以处理这类问题。

分析程序的性能可以归结为回答四个基本问题:

正运行的多快
速度瓶颈在哪里
内存使用率是多少
内存泄露在哪里
下面,我们将用一些神奇的工具深入到这些问题的答案中去。

time 粗粒度的计算时间

让我们开始通过使用一个快速和粗暴的方法计算我们的代码:传统的 unix time 工具。

  1.  $ time python yourprogram.py  
  2. real    0m1.028s 
  3. user    0m0.001s 
  4. sys     0m0.003s 

三个输出测量值之间的详细意义在这里 stackoverflow article,但简介在这:

  • real -- 指的是实际耗时
  • user -- 指的是内核之外的 CPU 耗时
  • sys -- 指的是花费在内核特定函数的 CPU 耗时

你会有你的应用程序用完了多少 CPU 周期的即视感,不管系统上其他运行的程序添加的系统和用户时间。

如果 sys 和 user 时间之和小于 real 时间,然后你可以猜测到大多数程序的性能问题最有可能与 IO wait 相关。

用 timing context 管理器细粒度的计算时间

我们下一步的技术包括直接嵌入代码来获取细粒度的计时信息。下面是我进行时间测量的代码的一个小片段

timer.py

  1. import time  
  2.  
  3. class Timer(object):  
  4.     def __init__(self, verbose=False):  
  5.         self.verbose = verbose  
  6.  
  7.     def __enter__(self):  
  8.         self.start = time.time()  
  9.         return self 
  10.  
  11.     def __exit__(self, *args):  
  12.         self.end = time.time()  
  13.         self.secs = self.end - self.start  
  14.         self.msecs = self.secs * 1000  # millisecs  
  15.         if self.verbose:  
  16.             print 'elapsed time: %f ms' % self.msecs 

为了使用它,使用 Python 的 with 关键字和 Timer 上下文管理器来包装你想计算的代码。当您的代码块开始执行,它将照顾启动计时器,当你的代码块结束的时候,它将停止计时器。

这个代码片段示例:

  1. from timer import Timer  
  2. from redis import Redis  
  3. rdb = Redis()  
  4.  
  5. with Timer() as t:  
  6.     rdb.lpush("foo""bar")  
  7. print "=> elasped lpush: %s s" % t.secs  
  8.  
  9. with Timer() as t:  
  10.     rdb.lpop("foo")  
  11. print "=> elasped lpop: %s s" % t.secs 

为了看看我的程序的性能随着时间的演化的趋势,我常常记录这些定时器的输出到一个文件中。

使用 profiler 逐行计时和分析执行的频率

罗伯特·克恩有一个不错的项目称为 line_profiler , 我经常使用它来分析我的脚本有多快,以及每行代码执行的频率:

为了使用它,你可以通过使用 pip 来安装它:

  1. pip install line_profiler  

安装完成后,你将获得一个新模块称为 line_profilerkernprof.py 可执行脚本。

为了使用这个工具,首先在你想测量的函数上设置 @profile 修饰符。不用担心,为了这个修饰符,你不需要引入任何东西。kernprof.py 脚本会在运行时自动注入你的脚本。

primes.py

  1. @profile 
  2. def primes(n):   
  3.     if n==2:  
  4.         return [2]  
  5.     elif n<2:  
  6.         return []  
  7.     s=range(3,n+1,2)  
  8.     mroot = n ** 0.5 
  9.     half=(n+1)/2-1 
  10.     i=0 
  11.     m=3 
  12.     while m <= mroot:  
  13.         if s[i]:  
  14.             j=(m*m-3)/2 
  15.             s[j]=0 
  16.             while j<half:  
  17.                 s[j]=0 
  18.                 j+=m  
  19.         i=i+1 
  20.         m=2*i+3 
  21.     return [2]+[x for x in s if x]  
  22. primes(100

一旦你得到了你的设置了修饰符 @profile 的代码,使用 kernprof.py 运行这个脚本。

  1. kernprof.py -l -v fib.py 

-l 选项告诉 kernprof 把修饰符 @profile 注入你的脚本,-v 选项告诉 kernprof 一旦你的脚本完成后,展示计时信息。这是一个以上脚本的类似输出:

  1. Wrote profile results to primes.py.lprof  
  2. Timer unit: 1e-06 s  
  3.  
  4. File: primes.py  
  5. Function: primes at line 2 
  6. Total time: 0.00019 s  
  7.  
  8. Line #      Hits         Time  Per Hit   % Time  Line Contents  
  9. ==============================================================  
  10.      2                                           @profile  
  11.      3                                           def primes(n):   
  12.      4         1            2      2.0      1.1      if n==2:  
  13.      5                                                   return [2]  
  14.      6         1            1      1.0      0.5      elif n<2:  
  15.      7                                                   return []  
  16.      8         1            4      4.0      2.1      s=range(3,n+1,2)  
  17.      9         1           10     10.0      5.3      mroot = n ** 0.5 
  18.     10         1            2      2.0      1.1      half=(n+1)/2-1 
  19.     11         1            1      1.0      0.5      i=0 
  20.     12         1            1      1.0      0.5      m=3 
  21.     13         5            7      1.4      3.7      while m <= mroot:  
  22.     14         4            4      1.0      2.1          if s[i]:  
  23.     15         3            4      1.3      2.1              j=(m*m-3)/2 
  24.     16         3            4      1.3      2.1              s[j]=0 
  25.     17        31           31      1.0     16.3              while j<half:  
  26.     18        28           28      1.0     14.7                  s[j]=0 
  27.     19        28           29      1.0     15.3                  j+=m  
  28.     20         4            4      1.0      2.1          i=i+1 
  29.     21         4            4      1.0      2.1          m=2*i+3 
  30.     22        50           54      1.1     28.4      return [2]+[x for x  

寻找 hits 值比较高的行或是一个高时间间隔。这些地方有最大的优化改进空间。

它使用了多少内存?

现在我们掌握了很好我们代码的计时信息,让我们继续找出我们的程序使用了多少内存。我们真是非常幸运, Fabian Pedregosa 仿照 Robert Kern 的 line_profiler 实现了一个很好的内存分析器 [memory profiler][5]

首先通过 pip 安装它:

  1. $ pip install -U memory_profiler  
  2. $ pip install psutil  

在这里建议安装 psutil 是因为该包能提升 memory_profiler 的性能。

line_profiler 一样, memory_profiler 要求在你设置 @profile 来修饰你的函数:

  1. @profile 
  2. def primes(n):   
  3.     ...  
  4.     ...  

运行如下命令来显示你的函数使用了多少内存:

  1. $ python -m memory_profiler primes.py  

一旦你的程序退出,你应该可以看到这样的输出:

  1. Filename: primes.py  
  2.  
  3. Line #    Mem usage  Increment   Line Contents  
  4. ==============================================  
  5.      2                           @profile  
  6.      3    7.9219 MB  0.0000 MB   def primes(n):   
  7.      4    7.9219 MB  0.0000 MB       if n==2:  
  8.      5                                   return [2]  
  9.      6    7.9219 MB  0.0000 MB       elif n<2:  
  10.      7                                   return []  
  11.      8    7.9219 MB  0.0000 MB       s=range(3,n+1,2)  
  12.      9    7.9258 MB  0.0039 MB       mroot = n ** 0.5 
  13.     10    7.9258 MB  0.0000 MB       half=(n+1)/2-1 
  14.     11    7.9258 MB  0.0000 MB       i=0 
  15.     12    7.9258 MB  0.0000 MB       m=3 
  16.     13    7.9297 MB  0.0039 MB       while m <= mroot:  
  17.     14    7.9297 MB  0.0000 MB           if s[i]:  
  18.     15    7.9297 MB  0.0000 MB               j=(m*m-3)/2 
  19.     16    7.9258 MB -0.0039 MB               s[j]=0 
  20.     17    7.9297 MB  0.0039 MB               while j<half:  
  21.     18    7.9297 MB  0.0000 MB                   s[j]=0 
  22.     19    7.9297 MB  0.0000 MB                   j+=m  
  23.     20    7.9297 MB  0.0000 MB           i=i+1 
  24.     21    7.9297 MB  0.0000 MB           m=2*i+3 
  25.     22    7.9297 MB  0.0000 MB       return [2]+[x for x in s if x]  
  26.  

line_profilermemory_profiler 的 IPython 快捷命令

line_profilermemory_profiler 一个鲜为人知的特性就是在 IPython 上都有快捷命令。你所能做的就是在 IPython 上键入以下命令:

  1. %load_ext memory_profiler  
  2. %load_ext line_profiler  

这样做了以后,你就可以使用魔法命令 %lprun%mprun 了,它们表现的像它们命令行的副本,最主要的不同就是你不需要给你需要分析的函数设置 @profile 修饰符。直接在你的 IPython 会话上继续分析吧。

  1. In [1]: from primes import primes  
  2. In [2]: %mprun -f primes primes(1000)  
  3. In [3]: %lprun -f primes primes(1000)  

这可以节省你大量的时间和精力,因为使用这些分析命令,你不需要修改你的源代码。

本新闻共2页,当前在第1页  1  2  

分享道
相关新闻