像老大一样优化Python

我们应该忘掉一些小的效率问题，在 97% 的情况下是这么说的：过早优化是万恶之源。—— Donald Knuth

在昌邑等地区，都构建了全面的区域性战略布局，加强发展的系统性、市场前瞻性、产品创新能力，以专注、极致的服务理念，为客户提供成都网站设计、成都网站制作 网站设计制作定制网站制作,公司网站建设,企业网站建设,品牌网站建设,成都营销网站建设,成都外贸网站建设,昌邑网站建设费用合理。

如果不首先想想这句Knuth的名言，就开始进行优化工作是不明智的。可是，你很快写出来加入一些特性的代码，可能会很丑陋，你需要注意了。这篇文章就是为这时候准备的。

那么接下来就是一些很有用的工具和模式来快速优化Python。它的主要目的很简单：尽快发现瓶颈，修复它们并且确认你修复了它们。

写一个测试

在你开始优化前，写一个高级测试来证明原来代码很慢。你可能需要采用一些最小值数据集来复现它足够慢。通常一两个显示运行时秒的程序就足够处理一些改进的地方了。

有一些基础测试来保证你的优化没有改变原有代码的行为也是很必要的。你也能够在很多次运行测试来优化代码的时候稍微修改这些测试的基准。

那么现在，我们来来看看优化工具把。

简单的计时器

计时器很简单，这是一个最灵活的记录执行时间的方法。你可以把它放到任何地方并且副作用很小。运行你自己的计时器非常简单，并且你可以将其定制，使它以你期望的方式工作。例如，你个简单的计时器如下：

 
 
 
    
  
  
  
  1. import time 
    2. 
  
  
  
  2.   
    3. 
  
  
  
  3. def timefunc(f): 
    4. 
  
  
  
  4.     def f_timer(*args, **kwargs): 
    5. 
  
  
  
  5.         start = time.time() 
    6. 
  
  
  
  6.         result = f(*args, **kwargs) 
    7. 
  
  
  
  7.         end = time.time() 
    8. 
  
  
  
  8.         print f.__name__, 'took', end - start, 'time' 
    9. 
  
  
  
  9.         return result 
    10. 
  
  
  
  10.     return f_timer 
    11. 
  
  
  
  11.   
    12. 
  
  
  
  12. def get_number(): 
    13. 
  
  
  
  13.     for x in xrange(5000000): 
    14. 
  
  
  
  14.         yield x 
    15. 
  
  
  
  15.   
    16. 
  
  
  
  16. @timefunc 
    17. 
  
  
  
  17. def expensive_function(): 
    18. 
  
  
  
  18.     for x in get_number(): 
    19. 
  
  
  
  19.         i = x ^ x ^ x 
    20. 
  
  
  
  20.     return 'some result!' 
    21. 
  
  
  
  21.   
    22. 
  
  
  
  22. # prints "expensive_function took 0.72583088875 seconds" 
    23. 
  
  
  
  23. result = expensive_function() 
    24.

当然，你可以用上下文管理来让它功能更加强大，添加一些检查点或者一些其他的功能：

 
 
 
    
  
  
  
  1. import time 
    2. 
  
  
  
  2.   
    3. 
  
  
  
  3. class timewith(): 
    4. 
  
  
  
  4.     def __init__(self, name=''): 
    5. 
  
  
  
  5.         self.name = name 
    6. 
  
  
  
  6.         self.start = time.time() 
    7. 
  
  
  
  7.   
    8. 
  
  
  
  8.     @property 
    9. 
  
  
  
  9.     def elapsed(self): 
    10. 
  
  
  
  10.         return time.time() - self.start 
    11. 
  
  
  
  11.   
    12. 
  
  
  
  12.     def checkpoint(self, name=''): 
    13. 
  
  
  
  13.         print '{timer} {checkpoint} took {elapsed} seconds'.format( 
    14. 
  
  
  
  14.             timer=self.name, 
    15. 
  
  
  
  15.             checkpoint=name, 
    16. 
  
  
  
  16.             elapsed=self.elapsed, 
    17. 
  
  
  
  17.         ).strip() 
    18. 
  
  
  
  18.   
    19. 
  
  
  
  19.     def __enter__(self): 
    20. 
  
  
  
  20.         return self 
    21. 
  
  
  
  21.   
    22. 
  
  
  
  22.     def __exit__(self, type, value, traceback): 
    23. 
  
  
  
  23.         self.checkpoint('finished') 
    24. 
  
  
  
  24.         pass 
    25. 
  
  
  
  25.   
    26. 
  
  
  
  26. def get_number(): 
    27. 
  
  
  
  27.     for x in xrange(5000000): 
    28. 
  
  
  
  28.         yield x 
    29. 
  
  
  
  29.   
    30. 
  
  
  
  30. def expensive_function(): 
    31. 
  
  
  
  31.     for x in get_number(): 
    32. 
  
  
  
  32.         i = x ^ x ^ x 
    33. 
  
  
  
  33.     return 'some result!' 
    34. 
  
  
  
  34.   
    35. 
  
  
  
  35. # prints something like: 
    36. 
  
  
  
  36. # fancy thing done with something took 0.582462072372 seconds 
    37. 
  
  
  
  37. # fancy thing done with something else took 1.75355315208 seconds 
    38. 
  
  
  
  38. # fancy thing finished took 1.7535982132 seconds 
    39. 
  
  
  
  39. with timewith('fancy thing') as timer: 
    40. 
  
  
  
  40.     expensive_function() 
    41. 
  
  
  
  41.     timer.checkpoint('done with something') 
    42. 
  
  
  
  42.     expensive_function() 
    43. 
  
  
  
  43.     expensive_function() 
    44. 
  
  
  
  44.     timer.checkpoint('done with something else') 
    45. 
  
  
  
  45.   
    46. 
  
  
  
  46. # or directly 
    47. 
  
  
  
  47. timer = timewith('fancy thing') 
    48. 
  
  
  
  48. expensive_function() 
    49. 
  
  
  
  49. timer.checkpoint('done with something') 
    50.

计时器还需要你做一些挖掘。包装一些更高级的函数，并且确定瓶颈在哪，然后深入的函数里，能够不停的重现。当你发现一些不合适的代码，修复它，然后测试一遍以确认它被修复了。

一些小技巧：不要忘了好用的timeit模块！它对小块代码做基准测试而不是实际调查更加有用。

  • Timer 优点：很容易理解和实现。也非常容易在修改后进行比较。对于很多语言都适用。
  • Timer 缺点：有时候对于非常复杂的代码有点过于简单，你可能会花更多时间放置或移动引用代码而不是修复问题！

#p#

内建优化器

启用内建的优化器就像是用一门大炮。它非常强大，但是有点不太好用，使用和解释起来比较复杂。

你可以了解更多关于profile模块的东西，但是它的基础是非常简单的：你能够启用和禁用优化器，而且它能打印所有的函数调用和执行时间。它能给你编译和打印出输出。一个简单的装饰器如下：

 
 
 
    
  
  
  
  1. import cProfile 
    2. 
  
  
  
  2.   
    3. 
  
  
  
  3. def do_cprofile(func): 
    4. 
  
  
  
  4.     def profiled_func(*args, **kwargs): 
    5. 
  
  
  
  5.         profile = cProfile.Profile() 
    6. 
  
  
  
  6.         try: 
    7. 
  
  
  
  7.             profile.enable() 
    8. 
  
  
  
  8.             result = func(*args, **kwargs) 
    9. 
  
  
  
  9.             profile.disable() 
    10. 
  
  
  
  10.             return result 
    11. 
  
  
  
  11.         finally: 
    12. 
  
  
  
  12.             profile.print_stats() 
    13. 
  
  
  
  13.     return profiled_func 
    14. 
  
  
  
  14.   
    15. 
  
  
  
  15. def get_number(): 
    16. 
  
  
  
  16.     for x in xrange(5000000): 
    17. 
  
  
  
  17.         yield x 
    18. 
  
  
  
  18.   
    19. 
  
  
  
  19. @do_cprofile 
    20. 
  
  
  
  20. def expensive_function(): 
    21. 
  
  
  
  21.     for x in get_number(): 
    22. 
  
  
  
  22.         i = x ^ x ^ x 
    23. 
  
  
  
  23.     return 'some result!' 
    24. 
  
  
  
  24.   
    25. 
  
  
  
  25. # perform profiling 
    26. 
  
  
  
  26. result = expensive_function() 
    27.

在上面代码的情况下，你应该看到有些东西在终端打印出来，打印的内容如下：

 
 
 
    
  
  
  
  1. 5000003 function calls in 1.626 seconds 
    2. 
  
  
  
  2.   
    3. 
  
  
  
  3.    Ordered by: standard name 
    4. 
  
  
  
  4.   
    5. 
  
  
  
  5.    ncalls  tottime  percall  cumtime  percall filename:lineno(function) 
    6. 
  
  
  
  6.   5000001    0.571    0.000    0.571    0.000 timers.py:92(get_number) 
    7. 
  
  
  
  7.         1    1.055    1.055    1.626    1.626 timers.py:96(expensive_function) 
    8. 
  
  
  
  8.         1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects} 
    9.

你可以看到，它给出了不同函数的调用次数，但它遗漏了一些关键的信息：是哪个函数让运行这么慢？

可是，这对于基础优化来说是个好的开始。有时候甚至能用更少的精力找到解决方案。我经常用它来在深入挖掘究竟是哪个函数慢或者调用次数过多之前来调试程序。

  • 内建优点：没有额外的依赖并且非常快。对于快速的高等级检查非常有用。
  • 内建缺点：信息相对有限，需要进一步的调试；报告有点不太直接，尤其是对于复杂的代码。

Line Profiler

如果内建的优化器是一门大炮，那么line profiler可以看作是一门离子加农炮。它非常的重量级和强大。

在这个例子里，我们会用非常棒的line_profiler库。为了容易使用，我们会再次用装饰器包装一下，这种简单的方法也可以防止把它放在生产代码里。

 
 
 
    
  
  
  
  1. try: 
    2. 
  
  
  
  2.     from line_profiler import LineProfiler 
    3. 
  
  
  
  3.   
    4. 
  
  
  
  4.     def do_profile(follow=[]): 
    5. 
  
  
  
  5.         def inner(func): 
    6. 
  
  
  
  6.             def profiled_func(*args, **kwargs): 
    7. 
  
  
  
  7.                 try: 
    8. 
  
  
  
  8.                     profiler = LineProfiler() 
    9. 
  
  
  
  9.                     profiler.add_function(func) 
    10. 
  
  
  
  10.                     for f in follow: 
    11. 
  
  
  
  11.                         profiler.add_function(f) 
    12. 
  
  
  
  12.                     profiler.enable_by_count() 
    13. 
  
  
  
  13.                     return func(*args, **kwargs) 
    14. 
  
  
  
  14.                 finally: 
    15. 
  
  
  
  15.                     profiler.print_stats() 
    16. 
  
  
  
  16.             return profiled_func 
    17. 
  
  
  
  17.         return inner 
    18. 
  
  
  
  18.   
    19. 
  
  
  
  19. except ImportError: 
    20. 
  
  
  
  20.     def do_profile(follow=[]): 
    21. 
  
  
  
  21.         "Helpful if you accidentally leave in production!" 
    22. 
  
  
  
  22.         def inner(func): 
    23. 
  
  
  
  23.             def nothing(*args, **kwargs): 
    24. 
  
  
  
  24.                 return func(*args, **kwargs) 
    25. 
  
  
  
  25.             return nothing 
    26. 
  
  
  
  26.         return inner 
    27. 
  
  
  
  27.   
    28. 
  
  
  
  28. def get_number(): 
    29. 
  
  
  
  29.     for x in xrange(5000000): 
    30. 
  
  
  
  30.         yield x 
    31. 
  
  
  
  31.   
    32. 
  
  
  
  32. @do_profile(follow=[get_number]) 
    33. 
  
  
  
  33. def expensive_function(): 
    34. 
  
  
  
  34.     for x in get_number(): 
    35. 
  
  
  
  35.         i = x ^ x ^ x 
    36. 
  
  
  
  36.     return 'some result!' 
    37. 
  
  
  
  37.   
    38. 
  
  
  
  38. result = expensive_function() 
    39. 
  
  
  
  39.  
    40. 
  
  
  
  40. 如果你运行上面的代码，你就可以看到一下的报告： 
    41. 
  
  
  
  41. 1 
    42. 
  
  
  
  42. 2 
    43. 
  
  
  
  43. 3 
    44. 
  
  
  
  44. 4 
    45. 
  
  
  
  45. 5 
    46. 
  
  
  
  46. 6 
    47. 
  
  
  
  47. 7 
    48. 
  
  
  
  48. 8 
    49. 
  
  
  
  49. 9 
    50. 
  
  
  
  50. 10 
    51. 
  
  
  
  51. 11 
    52. 
  
  
  
  52. 12 
    53. 
  
  
  
  53. 13 
    54. 
  
  
  
  54. 14 
    55. 
  
  
  
  55. 15 
    56. 
  
  
  
  56. 16 
    57. 
  
  
  
  57. 17 
    58. 
  
  
  
  58. 18 
    59. 
  
  
  
  59. 19 
    60. 
  
  
  
  60. 20 
    61. 
  
  
  
  61. 21 
    62. 
  
  
  
  62. 22 
    63. 
  
  
  
  63.      
    64. 
  
  
  
  64. Timer unit: 1e-06 s 
    65. 
  
  
  
  65.   
    66. 
  
  
  
  66. File: test.py 
    67. 
  
  
  
  67. Function: get_number at line 43 
    68. 
  
  
  
  68. Total time: 4.44195 s 
    69. 
  
  
  
  69.   
    70. 
  
  
  
  70. Line #      Hits         Time  Per Hit   % Time  Line Contents 
    71. 
  
  
  
  71. ============================================================== 
    72. 
  
  
  
  72.     43                                           def get_number(): 
    73. 
  
  
  
  73.     44   5000001      2223313      0.4     50.1      for x in xrange(5000000): 
    74. 
  
  
  
  74.     45   5000000      2218638      0.4     49.9          yield x 
    75. 
  
  
  
  75.   
    76. 
  
  
  
  76. File: test.py 
    77. 
  
  
  
  77. Function: expensive_function at line 47 
    78. 
  
  
  
  78. Total time: 16.828 s 
    79. 
  
  
  
  79.   
    80. 
  
  
  
  80. Line #      Hits         Time  Per Hit   % Time  Line Contents 
    81. 
  
  
  
  81. ============================================================== 
    82. 
  
  
  
  82.     47                                           def expensive_function(): 
    83. 
  
  
  
  83.     48   5000001     14090530      2.8     83.7      for x in get_number(): 
    84. 
  
  
  
  84.     49   5000000      2737480      0.5     16.3          i = x ^ x ^ x 
    85. 
  
  
  
  85.     50         1            0      0.0      0.0      return 'some result!' 
    86.

你可以看到，有一个非常详细的报告，能让你完全洞悉代码运行的情况。不想内建的cProfiler，它能计算话在语言核心特性的时间，比如循环和导入并且给出在不同的行花费的时间。

这些细节能让我们更容易理解函数内部。如果你在研究某个第三方库，你可以直接将其导入并加上装饰器来分析它。

一些小技巧：只装饰你的测试函数并将问题函数作为接下来的参数。

  •  Line Profiler 优点：有非常直接和详细的报告。能够追踪第三方库里的函数。
  •  Line Profiler 缺点：因为它会让代码比真正运行时慢很多，所以不要用它来做基准测试。这是额外的需求。

总结和最佳实践

你应该用更简单的工具来对测试用例进行根本的检查，并且用更慢但能显示更多细节的line_profiler来深入到函数内部。

九成情况下，你可能会发现在一个函数里循环调用或一个错误的数据结构消耗了90%的时间。一些调整工具是非常适合你的。

如果你仍然觉得这太慢，而是用一些你自己的秘密武器，如比较属性访问技术或调整平衡检查技术。你也可以用如下的方法：

1．忍受缓慢或者缓存它们

2．重新思考整个实现

3．更多使用优化的数据结构

4．写一个C扩展

注意了，优化代码是种罪恶的快感！用合适的方法来为你的Python代码加速很有意思，但是注意不要破坏了本身的逻辑。可读的代码比运行速度更重要。先把它缓存起来再进行优化其实更好。

原文链接：https://zapier.com/engineering/profiling-python-boss/

译文链接：http://blog.jobbole.com/54057/

当前标题：像老大一样优化Python
分享URL：http://www.mswzjz.com/qtweb/news38/160388.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

解决方案知识

行业网站建设

腾讯免备案主机　　 　网站建设　　 　成都网站推广　　 　响应式网站建设　　 　内江网站建设　　 　网站快速收录　　 　高端网站设计　　 　成都模板网站　　 　四川内江电信机房　　 　域名申请　　 　成都网站建设　　 　成都门窗定制　　 　电信成都枢纽中心　　 　成都定制网站开发　　 　营销型网站建设　　 　成都枢纽中心　　 　成都定制网站　　 　四川电信高防服务器托管　　 　bgp多线机房托管　　 　蓬溪网站建设