Python 성능 최적화 기술 요약

스크립트 언어를 선택하면 속도를 견뎌야 합니다. 이 문장은 스크립트로서 Python의 단점 중 하나를 어느 정도 보여줍니다. 즉, 특히 성능이 좋지 않은 시스템에서는 실행 효율성과 성능이 이상적이지 않습니다. 따라서 프로그램의 실행 효율성을 향상하려면 특정 코드 최적화를 수행해야 합니다. Python 성능을 최적화하는 방법은 이 기사에서 논의되는 주요 문제입니다. 이 기사에서는 일반적인 코드 최적화 방법, 성능 최적화 도구 사용 및 코드 성능 병목 현상을 진단하는 방법을 다루며 Python 개발자에게 참고 자료가 될 수 있기를 바랍니다.

Python 코드 최적화에 대한 일반적인 팁

코드 최적화는 80/20 원칙에 따라 프로그램 실행 결과를 변경하지 않고도 프로그램을 더 빠르게 실행할 수 있습니다. , 프로그램 재구성, 최적화, 확장 및 문서 관련 문제를 구현하는 데 일반적으로 작업 부하의 80%가 소비됩니다. 최적화에는 일반적으로 코드 크기를 줄이는 것과 코드의 운영 효율성을 높이는 두 가지 측면이 포함됩니다.

알고리즘을 개선하고 적절한 데이터 구조를 선택하세요

좋은 알고리즘은 성능에 중요한 역할을 할 수 있으므로 성능 개선의 첫 번째 포인트는 알고리즘 개선입니다. 알고리즘의 시간 복잡도는 다음과 같습니다.

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

따라서 시간 복잡도 측면에서 알고리즘을 수정할 수 있다면 성능 향상은 자명합니다. 그러나 특정 알고리즘에 대한 개선 사항은 이 문서의 범위를 벗어나며 독자는 이 정보를 스스로 참조할 수 있습니다. 다음 내용은 데이터 구조 선택에 중점을 둡니다.

사전과 목록

파이썬 사전에서는 해시 테이블을 사용하므로 검색 연산의 복잡도는 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

세트로 변경 후 프로그램의 러닝타임이 8.75초로 4배 이상 개선되어 러닝타임이 대폭 단축되었습니다. 독자는 테스트를 위해 표 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로 바꾸고, 세 번째 레이어 계산 lista[ a를 바꿉니다. ]는 루프의 두 번째 수준을 나타냅니다.

목록 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로 단축되었습니다. Listing 4에서는 lista[a]의 계산 횟수가 1000000*10*10인데, 최적화된 코드에서는 계산 횟수가 1000000*10으로 대폭 단축되어 성능이 떨어진다. 개선되었습니다.

지연 if 평가 기능 최대한 활용하기

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