Python のパフォーマンス最適化手法の概要

スクリプト言語を選択する場合は、その速度に耐える必要があります。この文は、スクリプトとしての Python の欠点の 1 つをある程度示しています。つまり、特にパフォーマンスの低いマシンでは、実行効率とパフォーマンスが理想的ではありません。したがって、プログラムの実行効率を向上させるために、特定のコードの最適化を実行する必要があります。 Python のパフォーマンスを最適化する方法が、この記事で説明する主な問題です。この記事では、一般的なコード最適化方法、パフォーマンス最適化ツールの使用方法、コード パフォーマンスのボトルネックを診断する方法について説明します。Python 開発者にとって参考になると幸いです。

Python コード最適化に関する一般的なヒント

コードを最適化すると、プログラムの実行結果を変えることなく、プログラムをより効率的に実行できます。80/20 原則に従って、プログラムを再構築して最適化できます。 . 、拡張機能、およびドキュメント関連の作業が通常、作業の 80% を消費します。最適化には通常、コードのサイズの削減とコードの動作効率の向上という 2 つの側面が含まれます。

アルゴリズムを改善し、適切なデータ構造を選択します

優れたアルゴリズムはパフォーマンスに重要な役割を果たす可能性があるため、パフォーマンス向上の最初のポイントはアルゴリズムを改善することです。アルゴリズムの時間計算量の順序は次のとおりです:

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

したがって、時間計算量の観点からアルゴリズムを改善できても、パフォーマンスは向上しません。それは言うまでもない。ただし、特定のアルゴリズムの改善についてはこの記事の範囲を超えており、読者はこの情報を自分で参照することができます。次の内容は、データ構造の選択に焦点を当てます。

辞書とリスト

Python 辞書はハッシュ テーブルを使用するため、検索操作の複雑さは O(1) であり、リストでは実際にはリスト全体を検索する必要があります。複雑さは O(n) であるため、メンバーの検索やアクセスなどの辞書操作はリストよりも高速です。

リスト 1. コード dict.py

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.09 秒かかります。 #list = dict.fromkeys(list,True) 行のコメントを削除し、リストを辞書に変換して実行すると、時間は約 8.375 秒となり、効率が約半分になります。したがって、複数のデータ メンバーを頻繁に検索またはアクセスする必要がある場合は、リストの代わりに dict を使用することをお勧めします。

セットとリストの和集合、積集合、差分演算

セットは、リストの反復よりも高速です。したがって、リストの共通部分、和集合、または差分を見つける必要がある場合は、集合演算に変換できます。

リスト 2. リストの交差を見つける:

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

上記のプログラムの実行時間はおおよそ次のとおりです:

total run time: 
 38.4070000648

リスト 3. set を使用して交差を見つける

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 に変更した後のプログラムの実行時間が4倍の8.75に減少し、走行時間が大幅に短縮されました。読者は、表 1 の他の操作をテストに使用できます。

表 1. set の一般的な使用法

ループの最適化

ループの最適化に従う原則は、ループ プロセス内の計算量を最小限に抑えることです。複数のループがある場合は、内部の計算を入れるようにしてください。上の層。 次の例は、ループの最適化によってもたらされるパフォーマンスの向上を比較するために使用されます。リスト 4 では、ループ最適化なしのおおよその実行時間は約 132.375 です。

リスト 4. ループを最適化する前に

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 に置き換え、第 3 レベルの計算 lista[a] をループの第 2 レベルに移動します。

リスト 5. ループ最適化後

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 的特性

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 的性能。对字符串的优化也是改善性能的一个重要的方面，特别是在处理文本较多的情况下。字符串的优化主要集中在以下几个方面：

在字符串连接的使用尽量使用 join() 而不是 +：在代码清单 7 中使用 + 进行字符串连接大概需要 0.125 s，而使用 join 缩短为 0.016s。因此在字符的操作上 join 比 + 要快，因此要尽量使用 join 而不是 +。

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

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

同时要避免：

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

而是要使用：

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

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

对字符进行格式化比直接串联读取要快，因此要使用

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

而避免

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

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

列表解析要比在循环中重新构建一个新的 list 更为高效，因此我们可以利用这一特性来提高运行的效率。

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

使用列表解析：

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；

>>> 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

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 进行性能分析

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. 性能分析结果

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

ncalls：表示函数调用的次数；

tottime：表示指定函数的总的运行时间，除掉函数中调用子函数的运行时间；

percall：（第一个 percall）等于 tottime/ncalls；

cumtime：表示该函数及其所有子函数的调用运行的时间，即函数开始调用到返回的时间；

percall：（第二个 percall）即函数运行一次的平均时间，等于 cumtime/ncalls；

filename:lineno(function)：每个函数调用的具体信息；

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

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

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 等，读者可以自行查阅相关官网，本文不做详细讨论。