一个功能的实现，可以用多种语句来实现，比如说:while语句、for语句、生成器、列表推导、内置函数等实现，然而他们的效率并不一样。写了一个小程序来测试它们执行的效率。


测试内容: 

将一个数字大小为20万的数字，依次取绝对值，放到列表中，测试重复1千次.

测试程序:
  1. import time,sys  
  2. reps = 1000                #测试重复次数  
  3. nums = 200000              #测试时数字大小  
  4.   
  5.   
  6. def tester(func,*args):    #总体测试函数  
  7.     startTime = time.time()  
  8.     for i in range(reps):  
  9.         func(*args)  
  10.     elapsed = time.time() - startTime #用time模块来测试，结束时间与开始时间差  
  11.     return elapsed  
  12.   
  13. def while_Statement():     #while循环实现  
  14.     res = []  
  15.     x   = 0  
  16.     while nums > x:  
  17.         x += 1  
  18.         res.append(abs(x))  
  19.   
  20. def for_Statement():       #for循环实现  
  21.     res = []  
  22.     for x in range(nums):  
  23.         res.append(abs(x))  
  24.   
  25. def generator_Expression():#生成器实现  
  26.     res = list(abs(x) for x in range(nums))  
  27.   
  28. def list_Comprehension():  #列表解析实现  
  29.     res = [abs(x) for x in range(nums)]  
  30.   
  31.   
  32. def map_Function():        #内置函数map实现  
  33.     res = map(abs, range(nums))  
  34.   
  35.   
  36. print sys.version          #打印系统版本  
  37. tests = [while_Statement, for_Statement, generator_Expression, list_Comprehension, map_Function]  
  38. for testfunc in tests:     #将待测函数放置列表中依次遍历  
  39.     print testfunc.__name__.ljust(20),': ',tester(testfunc)  #  

测试结果:

  1. >>>   
  2. 2.7.4 (default, Apr  6 2013, 19:55:15) [MSC v.1500 64 bit (AMD64)]  
  3. while_Statement      :  84.5769999027  
  4. for_Statement        :  75.2709999084  
  5. generator_Expression :  62.3519999981  
  6. list_Comprehension   :  60.4090001583  
  7. map_Function         :  47.5629999638  

改写程序:

  1. import sys  
  2. nums = 100  
  3.   
  4. def while_Statement():  
  5.     res = []  
  6.     x   = 0  
  7.     while nums > x:  
  8.         x += 1  
  9.         res.append(abs(x))  
  10.   
  11. def for_Statement():  
  12.     res = []  
  13.     for x in range(nums):  
  14.         res.append(abs(x))  
  15.   
  16. def generator_Expression():  
  17.     res = list(abs(x) for x in range(nums))  
  18.   
  19. def list_Comprehension():  
  20.     res = [abs(x) for x in range(nums)]  
  21.   
  22.   
  23. def map_Function():  
  24.     res = map(abs, range(nums))  
  25.   
  26. if __name__=='__main__':  
  27.     import timeit            #用timeit模块来测试  
  28.     print sys.version  
  29.     funcs = [while_Statement, for_Statement, generator_Expression, list_Comprehension, map_Function]  
  30.     for func in funcs:  
  31.         print func.__name__.ljust(20),': ',timeit.timeit("func()", setup="from __main__ import func")  

测试结果:

  1. >>>   
  2. 2.7.4 (default, Apr  6 2013, 19:55:15) [MSC v.1500 64 bit (AMD64)]  
  3. while_Statement      :  37.1800067428  
  4. for_Statement        :  30.3999109329  
  5. generator_Expression :  27.2597866441  
  6. list_Comprehension   :  17.386223449  
  7. map_Function         :  12.7386868963  
测试分析:

用time模块，和timeit模块两种测试方式测试了很多组数字，得出的结果是执行内置函数最快，其次就是列表推导，再其次生成器和for循环，while循环最慢。一般最快的使用内置函数的方法要比使用最慢的while快一倍左右。简单分析下原因:内置函数比如说map,filter,reduce(在Python3.0中移除)基本上都是用C语言来实现的,所以速度是最快的，列表推导和for循环里面含range()，相对速度也会快些，while语句是纯粹用Python代码写成，所以速度最慢。所以函数式编程最好使用内置函数，然后才考虑使用列表推导或for循环。最好不用while循环.