[转] Python 代码性能优化技巧

时间  2019-11-06
标签 python 代码 性能 优化 技巧 栏目 Python 繁體版
原文   原文链接

　　选择了脚本语言就要忍受其速度，这句话在某种程度上说明了 python 做为脚本的一个不足之处，那就是执行效率和性能不够理想，特别是在 performance 较差的机器上，所以有必要进行必定的代码优化来提升程序的执行效率。如何进行 Python 性能优化，是本文探讨的主要问题。本文会涉及常见的代码优化方法，性能优化工具的使用以及如何诊断代码的性能瓶颈等内容，但愿能够给 Python 开发人员必定的参考。html

　Python 代码优化常见技巧

　　代码优化可以让程序运行更快，它是在不改变程序运行结果的状况下使得程序的运行效率更高，根据 80/20 原则，实现程序的重构、优化、扩展以及文档相关的事情一般须要消耗 80% 的工做量。优化一般包含两方面的内容：减少代码的体积，提升代码的运行效率。python

　　改进算法，选择合适的数据结构

　　一个良好的算法可以对性能起到关键做用，所以性能改进的首要点是对算法的改进。在算法的时间复杂度排序上依次是：linux

　　O(1) -> O(lg n) -> O(n lg n) -> O(n^2) -> O(n^3) -> O(n^k) -> O(k^n) -> O(n!)git

　　所以若是可以在时间复杂度上对算法进行必定的改进，对性能的提升不言而喻。但对具体算法的改进不属于本文讨论的范围，读者能够自行参考这方面资料。下面的内容将集中讨论数据结构的选择。正则表达式

  • 字典 (dictionary) 与列表 (list)

　　Python 字典中使用了 hash table，所以查找操做的复杂度为 O(1)，而 list 实际是个数组，在 list 中，查找须要遍历整个 list，其复杂度为 O(n)，所以对成员的查找访问等操做字典要比 list 更快。算法

　　清单 1. 代码 dict.pyexpress

1
2
3
4
5
6
7
8
9
10
11
12
13
from time import time
  t = time()
  list = [ 'a' , 'b' , 'is' , 'python' , 'jason' , 'hello' , 'hill' , 'with' , 'phone' , 'test' ,
'dfdf' , 'apple' , 'pddf' , 'ind' , 'basic' , 'none' , 'baecr' , 'var' , 'bana' , 'dd' , 'wrd' ]
  #list = dict.fromkeys(list,True)
  print list
  filter = []
  for i in range ( 1000000 ):
      for find in [ 'is' , 'hat' , 'new' , 'list' , 'old' , '.' ]:
          if find not in list :
              filter .append(find)
  print "total run time:"
  print time() - t

　　上述代码运行大概须要 16.09seconds。若是去掉行 #list = dict.fromkeys(list,True) 的注释，将 list 转换为字典以后再运行，时间大约为 8.375 seconds，效率大概提升了一半。所以在须要多数据成员进行频繁的查找或者访问的时候，使用 dict 而不是 list 是一个较好的选择。windows

  • 集合 (set) 与列表 (list)

　　set 的 union， intersection，difference 操做要比 list 的迭代要快。所以若是涉及到求 list 交集，并集或者差的问题能够转换为 set 来操做。数组

　　清单 2. 求 list 的交集：缓存

1
2
3
4
5
6
7
8
9
10
11
12
13
from time import time
  t = time()
  lista = [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 13 , 34 , 53 , 42 , 44 ]
  listb = [ 2 , 4 , 6 , 9 , 23 ]
  intersection = []
  for i in range ( 1000000 ):
      for a in lista:
          for b in listb:
              if a = = b:
                  intersection.append(a)
 
  print "total run time:"
  print time() - t

　　上述程序的运行时间大概为：

1
2
total run time:
38.4070000648

　　清单 3. 使用 set 求交集

1
2
3
4
5
6
7
8
9
from time import time
  t = time()
  lista=[1,2,3,4,5,6,7,8,9,13,34,53,42,44]
  listb=[2,4,6,9,23]
  intersection=[]
  for i in range (1000000):
      list(set(lista)&set(listb))
  print "total run time:"
  print time()-t

　　改成 set 后程序的运行时间缩减为 8.75，提升了 4 倍多，运行时间大大缩短。读者能够自行使用表 1 其余的操做进行测试。

　　表 1. set 常见用法

语法 操做 说明
set(list1) | set(list2) union 包含 list1 和 list2 全部数据的新集合
set(list1) & set(list2) intersection 包含 list1 和 list2 中共同元素的新集合
set(list1) – set(list2) difference 在 list1 中出现但不在 list2 中出现的元素的集合

　　对循环的优化

　　对循环的优化所遵循的原则是尽可能减小循环过程当中的计算量，有多重循环的尽可能将内层的计算提到上一层。 下面经过实例来对比循环优化后所带来的性能的提升。程序清单 4 中，若是不进行循环优化，其大概的运行时间约为 132.375。

　　清单 4. 为进行循环优化前

1
2
3
4
5
6
7
8
9
10
from time import time
  t = time()
  lista = [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ]
  listb = [ 0.1 , 0.2 , 0.3 , 0.4 , 0.5 , 0.6 , 0.7 , 0.8 , 0.9 , 0.01 ]
  for i in range ( 1000000 ):
      for a in range ( len (lista)):
          for b in range ( len (listb)):
              x = lista[a] + listb[b]
  print "total run time:"
  print time() - t

　　如今进行以下优化，将长度计算提到循环外，range 用 xrange 代替，同时将第三层的计算 lista[a] 提到循环的第二层。

　　清单 5. 循环优化后

1
2
3
4
5
6
7
8
9
10
11
12
13
from time import time
  t = time()
  lista = [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ]
  listb = [ 0.1 , 0.2 , 0.3 , 0.4 , 0.5 , 0.6 , 0.7 , 0.8 , 0.9 , 0.01 ]
  len1 = len (lista)
  len2 = len (listb)
  for i in xrange ( 1000000 ):
      for a in xrange (len1):
          temp = lista[a]
          for b in xrange (len2):
              x = temp + listb[b]
  print "total run time:"
  print time() - t

　　上述优化后的程序其运行时间缩短为 102.171999931。在清单 4 中 lista[a] 被计算的次数为 1000000*10*10，而在优化后的代码中被计算的次数为 1000000*10，计算次数大幅度缩短，所以性能有所提高。

　　充分利用 Lazy if-evaluation 的特性

　　python 中条件表达式是 lazy evaluation 的，也就是说若是存在条件表达式 if x and y，在 x 为 false 的状况下 y 表达式的值将再也不计算。所以能够利用该特性在必定程度上提升程序效率。

　　清单 6. 利用 Lazy if-evaluation 的特性

1
2
3
4
5
6
7
8
9
10
from time import time
  t = time()
  abbreviations = [ 'cf.' , 'e.g.' , 'ex.' , 'etc.' , 'fig.' , 'i.e.' , 'Mr.' , 'vs.' ]
  for i in range ( 1000000 ):
      for w in ( 'Mr.' , 'Hat' , 'is' , 'chasing' , 'the' , 'black' , 'cat' , '.' ):
          if w in abbreviations:
          #if w[-1] == '.' and w in abbreviations:
              pass
  print "total run time:"
  print time() - t

　　在未进行优化以前程序的运行时间大概为 8.84，若是使用注释行代替第一个 if，运行的时间大概为 6.17。

　　字符串的优化

　　python 中的字符串对象是不可改变的，所以对任何字符串的操做如拼接，修改等都将产生一个新的字符串对象，而不是基于原字符串，所以这种持续的 copy 会在必定程度上影响 python 的性能。对字符串的优化也是改善性能的一个重要的方面，特别是在处理文本较多的状况下。字符串的优化主要集中在如下几个方面：

  1. 在字符串链接的使用尽可能使用 join() 而不是 +：在代码清单 7 中使用 + 进行字符串链接大概须要 0.125 s，而使用 join 缩短为 0.016s。所以在字符的操做上 join 比 + 要快，所以要尽可能使用 join 而不是 +。

　　清单 7. 使用 join 而不是 + 链接字符串

1
2
3
4
5
6
7
8
9
10
from time import time
 
  t = time()
  s = ""
  list = [ 'a' , 'b' , 'b' , 'd' , 'e' , 'f' , 'g' , 'h' , 'i' , 'j' , 'k' , 'l' , 'm' , 'n' ]
  for i in range ( 10000 ):
      for substr in list :
          s + = substr    
  print "total run time:"
  print time() - t

　　同时要避免：

1
2
3
s = ""
  for x in list :
     s + = func(x)

　　而是要使用：

1
2
slist = [func(elt) for elt in somelist]
  s = "".join(slist)

　　2.当对字符串可使用正则表达式或者内置函数来处理的时候，选择内置函数。如 str.isalpha()，str.isdigit()，str.startswith((‘x’, ‘yz’))，str.endswith((‘x’, ‘yz’))

　　3.对字符进行格式化比直接串联读取要快，所以要使用

1
out = "<html>%s%s%s%s</html>" % (head, prologue, query, tail)

　　而避免

1
out = "<html>" + head + prologue + query + tail + "</html>"

　　使用列表解析（list comprehension）和生成器表达式（generator expression）

　　列表解析要比在循环中从新构建一个新的 list 更为高效，所以咱们能够利用这一特性来提升运行的效率。

1
2
3
4
5
6
7
8
9
10
from time import time
  t = time()
  list = [ 'a' , 'b' , 'is' , 'python' , 'jason' , 'hello' , 'hill' , 'with' , 'phone' , 'test' ,
'dfdf' , 'apple' , 'pddf' , 'ind' , 'basic' , 'none' , 'baecr' , 'var' , 'bana' , 'dd' , 'wrd' ]
  total = []
  for i in range ( 1000000 ):
      for w in list :
          total.append(w)
  print "total run time:"
  print time() - t

　　使用列表解析：

1
2
for i in range ( 1000000 ):
      a = [w for w in list ]

　　上述代码直接运行大概须要 17s，而改成使用列表解析后 ，运行时间缩短为 9.29s。将近提升了一半。生成器表达式则是在 2.4 中引入的新内容，语法和列表解析相似，可是在大数据量处理时，生成器表达式的优点较为明显，它并不建立一个列表，只是返回一个生成器，所以效率较高。在上述例子上中代码 a = [w for w in list] 修改成 a = (w for w in list)，运行时间进一步减小，缩短约为 2.98s。

　　其余优化技巧

　　一、若是须要交换两个变量的值使用 a,b=b,a 而不是借助中间变量 t=a;a=b;b=t；

1
2
3
4
5
6
>>> from timeit import Timer
  >>> Timer( "t=a;a=b;b=t" , "a=1;b=2" ).timeit()
  0.25154118749729365
  >>> Timer( "a,b=b,a" , "a=1;b=2" ).timeit()
  0.17156677734181258
  >>>

　　二、在循环的时候使用 xrange 而不是 range；使用 xrange 能够节省大量的系统内存，由于 xrange() 在序列中每次调用只产生一个整数元素。而 range() 將直接返回完整的元素列表，用于循环时会有没必要要的开销。在 python3 中 xrange 再也不存在，里面 range 提供一个能够遍历任意长度的范围的 iterator。

　　三、使用局部变量，避免”global” 关键字。python 访问局部变量会比全局变量要快得多，因 此能够利用这一特性提高性能。

　　四、if done is not None 比语句 if done != None 更快，读者能够自行验证；

　　五、在耗时较多的循环中，能够把函数的调用改成内联的方式；

　　六、使用级联比较 “x < y < z” 而不是 “x < y and y < z”；

　　七、while 1 要比 while True 更快（固然后者的可读性更好）；

　　八、build in 函数一般较快，add(a,b) 要优于 a+b。

　定位程序性能瓶颈

　　对代码优化的前提是须要了解性能瓶颈在什么地方，程序运行的主要时间是消耗在哪里，对于比较复杂的代码能够借助一些工具来定位，python 内置了丰富的性能分析工具，如 profile,cProfile 与 hotshot 等。其中 Profiler 是 python 自带的一组程序，可以描述程序运行时候的性能，并提供各类统计帮助用户定位程序的性能瓶颈。Python 标准模块提供三种 profilers:cProfile,profile 以及 hotshot。

　　profile 的使用很是简单，只须要在使用以前进行 import 便可。具体实例以下：

　　清单 8. 使用 profile 进行性能分析

1
2
3
4
5
6
7
8
9
import profile
  def profileTest():
     Total = 1 ;
     for i in range ( 10 ):
         Total = Total * (i + 1 )
         print Total
     return Total
  if __name__ = = "__main__" :
     profile.run( "profileTest()" )

　　程序的运行结果以下：

　　图 1. 性能分析结果

image001

 

　　其中输出每列的具体解释以下：

  • ncalls：表示函数调用的次数；
  • tottime：表示指定函数的总的运行时间，除掉函数中调用子函数的运行时间；
  • percall：（第一个 percall）等于 tottime/ncalls；
  • cumtime：表示该函数及其全部子函数的调用运行的时间，即函数开始调用到返回的时间；
  • percall：（第二个 percall）即函数运行一次的平均时间，等于 cumtime/ncalls；
  • filename:lineno(function)：每一个函数调用的具体信息；

　　若是须要将输出以日志的形式保存，只须要在调用的时候加入另一个参数。如 profile.run(“profileTest()”,”testprof”)。

　　对于 profile 的剖析数据，若是以二进制文件的时候保存结果的时候，能够经过 pstats 模块进行文本报表分析，它支持多种形式的报表输出，是文本界面下一个较为实用的工具。使用很是简单：

1
2
3
import pstats
  p = pstats.Stats( 'testprof' )
  p.sort_stats( "name" ).print_stats()

　　其中 sort_stats() 方法可以对剖分数据进行排序， 能够接受多个排序字段，如 sort_stats(‘name’, ‘file’) 将首先按照函数名称进行排序，而后再按照文件名进行排序。常见的排序字段有 calls( 被调用的次数 )，time（函数内部运行时间），cumulative（运行的总时间）等。此外 pstats 也提供了命令行交互工具，执行 python – m pstats 后能够经过 help 了解更多使用方式。

　　对于大型应用程序，若是可以将性能分析的结果以图形的方式呈现，将会很是实用和直观，常见的可视化工具备 Gprof2Dot，visualpytune，KCacheGrind 等，读者能够自行查阅相关官网，本文不作详细讨论。

　Python 性能优化工具

　　Python 性能优化除了改进算法，选用合适的数据结构以外，还有几种关键的技术，好比将关键 python 代码部分重写成 C 扩展模块，或者选用在性能上更为优化的解释器等，这些在本文中统称为优化工具。python 有不少自带的优化工具，如 Psyco，Pypy，Cython，Pyrex 等，这些优化工具各有千秋，本节选择几种进行介绍。

　　Psyco

　　psyco 是一个 just-in-time 的编译器，它可以在不改变源代码的状况下提升必定的性能，Psyco 将操做编译成有点优化的机器码，其操做分红三个不一样的级别，有”运行时”、”编译时”和”虚拟时”变量。并根据须要提升和下降变量的级别。运行时变量只是常规 Python 解释器处理的原始字节码和对象结构。一旦 Psyco 将操做编译成机器码，那么编译时变量就会在机器寄存器和可直接访问的内存位置中表示。同时 python 能高速缓存已编译的机器码以备从此重用，这样能节省一点时间。但 Psyco 也有其缺点，其自己运行所占内存较大。目前 psyco 已经不在 python2.7 中支持，并且再也不提供维护和更新了，对其感兴趣的能够参考 http://psyco.sourceforge.net/

　　Pypy

　　PyPy 表示 “用 Python 实现的 Python”，但实际上它是使用一个称为 RPython 的 Python 子集实现的，可以将 Python 代码转成 C， .NET， Java 等语言和平台的代码。PyPy 集成了一种即时 (JIT) 编译器。和许多编译器，解释器不一样，它不关心 Python 代码的词法分析和语法树。 由于它是用 Python 语言写的，因此它直接利用 Python 语言的 Code Object.。 Code Object 是 Python 字节码的表示，也就是说， PyPy 直接分析 Python 代码所对应的字节码 ,，这些字节码即不是以字符形式也不是以某种二进制格式保存在文件中， 而在 Python 运行环境中。目前版本是 1.8. 支持不一样的平台安装，windows 上安装 Pypy 须要先下载 https://bitbucket.org/pypy/pypy/downloads/pypy-1.8-win32.zip，而后解压到相关的目录，并将解压后的路径添加到环境变量 path 中便可。在命令行运行 pypy，若是出现以下错误：”没有找到 MSVCR100.dll, 所以这个应用程序未能启动，从新安装应用程序可能会修复此问题”，则还须要在微软的官网上下载 VS 2010 runtime libraries 解决该问题。具体地址为http://www.microsoft.com/download/en/details.aspx?displaylang=en&id=5555

　　安装成功后在命令行里运行 pypy，输出结果以下：

1
2
3
4
5
6
7
C:\Documents and Settings\Administrator>pypy
  Python 2.7 . 2 ( 0e28b379d8b3 , Feb 09 2012 , 18 : 31 : 47 )
  [PyPy 1.8 . 0 with MSC v. 1500 32 bit] on win32
  Type "help" , "copyright" , "credits" or "license" for more information.
  And now for something completely different: ``PyPy is vast, and contains
  multitudes''
  >>>>

　　以清单 5 的循环为例子，使用 python 和 pypy 分别运行，获得的运行结果分别以下：

1
2
3
4
5
6
7
C:\Documents and Settings\Administrator\ 桌面 \doc\python>pypy loop.py
  total run time:
  8.42199993134
 
  C:\Documents and Settings\Administrator\ 桌面 \doc\python>python loop.py
  total run time:
  106.391000032

　　可见使用 pypy 来编译和运行程序，其效率大大的提升。

　　Cython

　　Cython 是用 python 实现的一种语言，能够用来写 python 扩展，用它写出来的库均可以经过 import 来载入，性能上比 python 的快。cython 里能够载入 python 扩展 ( 好比 import math)，也能够载入 c 的库的头文件 ( 好比 :cdef extern from “math.h”)，另外也能够用它来写 python 代码。将关键部分重写成 C 扩展模块

　　Linux Cpython 的安装：

　　第一步：下载

1
2
3
4
5
6
7
8
9
10
11
[root@v5254085f259 cpython] # wget -N http://cython.org/release/Cython-0.15.1.zip
  - - 2012 - 04 - 16 22 : 08 : 35 - -  http: / / cython.org / release / Cython - 0.15 . 1.zip
  Resolving cython.org... 128.208 . 160.197
  Connecting to cython.org| 128.208 . 160.197 |: 80. .. connected.
  HTTP request sent, awaiting response... 200 OK
  Length: 2200299 ( 2.1M ) [application / zip ]
  Saving to: `Cython - 0.15 . 1.zip '
 
  100 % [ = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = >] 2 , 200 , 299   1.96M / s   in 1.1s
 
  2012 - 04 - 16 22 : 08 : 37 ( 1.96 MB / s) - `Cython - 0.15 . 1.zip ' saved [ 2200299 / 2200299 ]

　　第二步：解压

1
[root@v5254085f259 cpython]# unzip -o Cython-0.15.1.zip

　　第三步：安装

1
python setup.py install

　　安装完成后直接输入 cython，若是出现以下内容则代表安装成功。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
[root@v5254085f259 Cython - 0.15 . 1 ] # cython
  Cython (http: / / cython.org) is a compiler for code written in the
  Cython language.  Cython is based on Pyrex by Greg Ewing.
 
  Usage: cython [options] sourcefile.{pyx,py} ...
 
  Options:
   - V, - - version                  Display version number of cython compiler
   - l, - - create - listing           Write error messages to a listing file
   - I, - - include - dir <directory>  Search for include files in named directory
                                  (multiple include directories are allowed).
   - o, - - output - file <filename>   Specify name of generated C file
   - t, - - timestamps               Only compile newer source files
   - f, - - force                    Compile all source files (overrides implied - t)
   - q, - - quiet                    Don't print module names in recursive mode
   - v, - - verbose                  Be verbose, print file names on multiple compil ation
   - p, - - embed - positions          If specified, the positions in Cython files of each
   function definition is embedded in its docstring.
   - - cleanup <level>
   Release interned objects on python exit, for memory debugging.
     Level indicates aggressiveness, default 0 releases nothing.
   - w, - - working <directory>
   Sets the working directory for Cython (the directory modules are searched from )
   - - gdb Output debug information for cygdb
   - D, - - no - docstrings
               Strip docstrings from the compiled module.
   - a, - - annotate
               Produce a colorized HTML version of the source.
   - - line - directives
               Produce #line directives pointing to the .pyx source
   - - cplus
               Output a C + + rather than C file .
   - - embed[ = <method_name>]
               Generate a main() function that embeds the Python interpreter.
   - 2          Compile based on Python - 2 syntax and code seman tics.
   - 3          Compile based on Python - 3 syntax and code seman tics.
   - - fast - fail     Abort the compilation on the first error
   - - warning - error, - Werror       Make all warnings into errors
   - - warning - extra, - Wextra       Enable extra warnings
   - X, - - directive <name> = <value>
   [,<name = value,...] Overrides a compiler directive

　　其余平台上的安装能够参考文档：http://docs.cython.org/src/quickstart/install.html

　　Cython 代码与 python 不一样，必须先编译，编译通常须要通过两个阶段，将 pyx 文件编译为 .c 文件，再将 .c 文件编译为 .so 文件。编译有多种方法：

  • 经过命令行编译：假设有以下测试代码，使用命令行编译为 .c 文件。
1
2
3
4
5
6
7
8
9
10
11
def sum ( int a, int b):
         print a + b
 
  [root@v5254085f259 test] # cython sum.pyx
  [root@v5254085f259 test] # ls
  total 76
  4 drwxr - xr - x 2 root root  4096 Apr 17 02 : 45 .
  4 drwxr - xr - x 4 root root  4096 Apr 16 22 : 20 ..
  4 - rw - r - - r - - 1 root root    35 Apr 17 02 : 45 1
  60 - rw - r - - r - - 1 root root 55169 Apr 17 02 : 45 sum .c
  4 - rw - r - - r - - 1 root root    35 Apr 17 02 : 45 sum .pyx

　　在 linux 上利用 gcc 编译为 .so 文件：

1
2
3
4
5
6
7
8
9
10
[root@v5254085f259 test] # gcc -shared -pthread -fPIC -fwrapv -O2
  - Wall - fno - strict - aliasing - I / usr / include / python2. 4 - o sum .so sum .c
  [root@v5254085f259 test] # ls
  total 96
  4 drwxr - xr - x 2 root root  4096 Apr 17 02 : 47 .
  4 drwxr - xr - x 4 root root  4096 Apr 16 22 : 20 ..
  4 - rw - r - - r - - 1 root root    35 Apr 17 02 : 45 1
  60 - rw - r - - r - - 1 root root 55169 Apr 17 02 : 45 sum .c
  4 - rw - r - - r - - 1 root root    35 Apr 17 02 : 45 sum .pyx
  20 - rwxr - xr - x 1 root root 20307 Apr 17 02 : 47 sum .so

　　使用 distutils 编译

　　创建一个 setup.py 的脚本：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
from distutils.core import setup
  from distutils.extension import Extension
  from Cython.Distutils import build_ext
 
  ext_modules = [Extension( "sum" , [ "sum.pyx" ])]
 
  setup(
     name = 'sum app' ,
     cmdclass = { 'build_ext' : build_ext},
     ext_modules = ext_modules
  )
 
 
  [root@v5254085f259 test] #  python setup.py build_ext --inplace
  running build_ext
  cythoning sum .pyx to sum .c
  building 'sum' extension
  gcc - pthread - fno - strict - aliasing - fPIC - g - O2 - DNDEBUG - g - fwrapv - O3
  - Wall - Wstrict - prototypes - fPIC - I / opt / ActivePython - 2.7 / include / python2. 7
   - c sum .c - o build / temp.linux - x86_64 - 2.7 / sum .o
  gcc - pthread - shared build / temp.linux - x86_64 - 2.7 / sum .o
  - o / root / cpython / test / sum .so

　　编译完成以后能够导入到 python 中使用：

1
2
3
4
5
6
7
8
[root@v5254085f259 test] # python
  ActivePython 2.7 . 2.5 (ActiveState Software Inc.) based on
  Python 2.7 . 2 (default, Jun 24 2011 , 11 : 24 : 26 )
  [GCC 4.0 . 2 20051125 (Red Hat 4.0 . 2 - 8 )] on linux2
  Type "help" , "copyright" , "credits" or "license" for more information.
  >>> import pyximport; pyximport.install()
  >>> import sum
  >>> sum . sum ( 1 , 3 )

　　下面来进行一个简单的性能比较：

　　清单 9. Cython 测试代码

1
2
3
4
5
6
7
8
9
10
11
12
from time import time
  def test( int n):
         cdef int a = 0
         cdef int i
         for i in xrange (n):
                 a + = i
         return a
 
  t = time()
  test( 10000000 )
  print "total run time:"
  print time() - t

　　测试结果：

1
2
3
4
5
6
[GCC 4.0 . 2 20051125 (Red Hat 4.0 . 2 - 8 )] on linux2
  Type "help" , "copyright" , "credits" or "license" for more information.
  >>> import pyximport; pyximport.install()
  >>> import ctest
  total run time:
  0.00714015960693

　　清单 10. Python 测试代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from time import time
  def test(n):
         a = 0 ;
         for i in xrange (n):
                 a + = i
         return a
 
  t = time()
  test( 10000000 )
  print "total run time:"
  print time() - t
 
  [root@v5254085f259 test] # python test.py
  total run time:
  0.971596002579
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程