파이썬 수행속도 개선 팁

이 페이지는 파이썬 프로그램의 수행속도를 증진시키는 팁과 꼼수들을 위하여 바치고 있습니다. 정보가 다른 어떤이로부터 올 때마다, 나는 그 출처를 밝히려고 노력하고 있습니다.

이 주제에 관하여 밝은 빛을 비추어 주시려면, 알려 주세요.

목차

• 코드 윤곽잡기(profile)
  • 모듈 윤곽잡기
  • 모듈 추척하기
• 정렬
• 문자열 연결
• 회돌이
• 점을 피하기...
• 지역 변수
• 사전 요소를 초기화하기
• Import 서술문 충돌부담
• map을 사전과 함께 사용하기
• 데이타 모으기
• 자주 일어나지 않는 사건 처리하기

여러분의 프로그램 속도를 증가시키는 첫째 단계는 병목이 어디에 있는지 알아내는 것입니다. 절대로 실행되지 않거나 이미 빠르게 실행되는 코드를 최적화한다는 것은 전혀 의미가 없습니다. 나는 두 개의 모듈, profile과 trace를 사용해서 나의 코드에 있는 문제점을 찾는데 도움을 받고 있습니다.

Profile 모듈

profile 모듈은 파이썬 배포본의 표준 모듈로 포함되어 있습니다. 그것을 사용하면 대단히 용이하게 일단의 함수의 실행을 윤곽지울 수 있습니다. 여러분의 주함수가 main이라고 불리우며, 아무런 인수도 취하지 아니하며 그리고 프로파일 모듈의 통제하에서 그것을 실행시키기를 원한다고 가정해 봅시다. 가장 간단히 형태는, 단지 다음과 같이 실행하는 겁니다

import profile
profile.run('main()')

trace 모듈은 profile 모듈의 부산물로서 원래는 어떤 미완성 서술문 수준의 테스트 범위(some crude statement level test coverage)를 수행하기 위하여 내가 작성하였습니다 . 파이썬 2.0현재부로 여러-분은 파이썬 배포본의 Tools/scripts 디렉토리에 있는 trace.py를 찾아 보아야 합니다. 앤드류 달크(Andrew Dalke)의 덕분으로 명령어 라인으로부터 실행하여 전체 스크립트의 실행을 매우 쉽게 추적할 수 있습니다:

% trace.py -t spam.py eggs

귀도 반 로섬(Guido van Rossum)으로부터 인용

기본적인 파이썬 객체의 리스트를 정렬하는 것은 일반적으로 효율적입니다. 리스트용 sort 메쏘드는 선택적인 비교 함수를 인수로 받는데 그 인수는 정렬 행위를 변경하는 데 사용될 수 있습니다. 이것은 대단히 편리합니다, 그렇지만, 실제로는 정렬 속도를 떨어 뜨릴 수 있습니다.

정렬 속도를 높이는 또 다른 대안적인 방식은 터플을 담은 리스트를 구성하는 것으로서 첫 번째 요소는 정렬키이며 기본 비교행위를 사용하여 적절하게 정렬할 것입니다, 그리고 그의 두 번째 요소는 원래의 리스트 요소입니다.

예를 들어, 여러분은 터플을 담을 리스틀 가지고 있고 각 터플의 n-번째 필드로 정렬하기를 원한다고 가정해 봅시다. 다음의 함수가 그렇게 해 줄 것입니다.

def sortby(list, n):
    nlist = map(lambda x, n=n: (x[n], x), list)
    nlist.sort()
    return map(lambda (key, x): x, nlist)

>>> list = [(1, 2, 'def'), (2, -4, 'ghi'), (3, 6, 'abc')]
>>> list.sort()
>>> list 
[(1, 2, 'def'), (2, -4, 'ghi'), (3, 6, 'abc')]
>>> sortby(list, 2)
[(3, 6, 'abc'), (1, 2, 'def'), (2, -4, 'ghi')]
>>> sortby(list, 1) 
[(2, -4, 'ghi'), (1, 2, 'def'), (3, 6, 'abc')]

파이썬에서 문자열을 변경불가입니다. 이 사실은 아주 자주 초보 파이썬 프로그래머의 엉덩이를 몰래 타고 올라와 물어버립니다. 변경불가라고 하는 것은 어떤 면에서는 이점이 그리고 어떤 면에서는 단점이 있습니다. 장점이라면, 문자열은 사전에서 키로 사용될 수 있으며 그리고 개별적인 복사본들은 다중 변수 엮기에서 공유될 수 있습니다. (파이썬은 자동적으로 한개- 와 두개짜리-문자 문자열을 공유합니다.) 단점이라면, 주어진 문자열에서 "모든 a를 모두 b로 바꾼다는 것"과 같은 것들을 장담할 수 없습니다. 대신에, 원하는 바의 속성을 가지는 새로운 문자열을 생성해야만 합니다. 이런 계속적인 복사는 파이썬 프로그램에서 중대한 비효율성을 야기할 수 있습니다.

다음은 아론 워터스(Aaron Watters)의 보고로부터 인용합니다:

이것을 피하세요:

str = ""
   for substring in list:
       str = str + substring

대신에 "".join(list)을 사용하세요. 앞의 것은 거대한 문자열을 구축할 때 대단히 흔한 그리고 재앙을 일으킬 만한 실수가 됩니다. 비슷하게, 만약 여러분이 일련의 문자열을 연속적으로 생성하려면, 다음과 같이 사용하는 대신에,

str = ""
   for x list:
       str = str + some_function(x)

str = [None]*len(list):
   for i in range(len(list):
       str[i] = some_function(list[i])
   str = "".join(str)

다음은 피하세요:

out = "" + head + prologue + query + tail + "

out = "%s%s%s%s" % (head, prologue, query, tail)

이것이 훨씬 빠르며, 변경하기도 역시 더 쉽습니다. 게다가, 일을 처리하는 그 느린 방법은 파이썬 2.0에서 풍부한 연산자가 추가됨에 따라서 더욱 느려졌습니다. 이제 파이썬 가상 기계는 많은 시간을 들여야 문자열을 연결하는 법을 이해합니다. (파이썬은 모든 메쏘드 참조를 실행시에 한다는 것을 잊지 마세요.)

회돌이

파이썬은 많은 회돌이 구조를 제공합니다. for 서술문이 가장 흔하게 사용됩니다. 그것은 연속열의 요소들을 회돌이 하면서, 각 요소를 회돌이 변수에 할당합니다. 만약 회돌이 몸체가 간결하다면, for 회돌이 그 자체의 인터프리터 부담이 실제적인 부담일 것입니다. 이 때가 바로 map 함수가 편리한 곳입니다. 여러분은 map을 C 코드로 이동한 for라고 생각할 수 있습니다. 오직 유일한 제한은 map의 "회돌이 몸체"가 반드시 함수 호출이어야 한다는 것입니다.

여기에 쉬운 예제 하나가 있습니다. 단어들의 리스트를 회돌이하여 그것들을 대문자로 변경하는 대신에:

newlist = []
for word in list:
    newlist.append(word.upper())

import string
newlist = map(string.upper, list)

리스트 번역은 파이썬 2.0에도 추가되었습니다. 구문적으로 더욱 간결하게 위의 for 회돌이를 작성하는 방법을 제공합니다:

newlist = [s.upper() for s in list]

귀도 반 로섬(Guido van Rossum)은 회돌이 최적화에 대하여 더욱 더 자세한 예제를 작성하였는데 분명히 읽을 만한 가치가 있습니다.

점을 피하기...

import string
upper = string.upper
newlist = []
append = newlist.append
for word in list:
    append(upper(word))

for 회돌이의 비-map 버전을 위해 이용가능한 마지막 속도증가 방법은 가능하면 지역 변수를 사용하는 것입니다. 위의 회돌이가 함수로서 주어지면, append와 upper는 지역 변수가 됩니다.

def func():
    upper = string.upper
    newlist = []
    append = newlist.append
    for word in words:
	append(upper(word))
    return newlist

map을 사용하여 회돌이 부담을 제거하는 것은 가끔은 가장 효율적인 선택입니다. 그렇지만, 회돌이의 복잡성 때문에 사용이 망설여진다면, 다른 테크닉 또한 회돌이의 속도를 증가시키는데 이용가능합니다.

사전 요소들을 초기화하기

단어의 출현 빈도를 담은 사전을 구축하고 있고 이미 단어들을 리스트로 쪼개었다고 가정해 보세요. 아마 다음과 같이 실행하겠지요:

wdict = {}
for word in words:
    if not wdict.has_key(word): wdict[word] = 0
    wdict[word] = wdict[word] + 1

최초를 제외하고, 단어가 발견될 때 마다 if 서술문의 테스트는 실패합니다. 만약 엄청난 개수의 단어들을 세려고 한다면, 여러번 출현하는 것이 아마도 많을 것입니다. 하나의 값을 초기화하는 것이 단 한번만 일어날 것이고 그 값의 증가는 여러번 일어나는 상황에서는, try 서술문을 사용하는 것이 품이 덜 듭니다:

wdict = {}
for word in words:
    try:
        wdict[word] = wdict[word] + 1
    except KeyError:
        wdict[word] = 1

중요한 것은 예상되는 예외를 나포하는 것이지, 여러분이 실제로 try 절에서 서술문으로 예외를 처리하지 못할 때 그 예외로부터 복구하려는 시도를 회피하려는 의도로, 기본 except절을 가지는 것이 중요한 것이 아닙니다.

주목할 것은 만약 try 절이 대부분의 경우에 예외를 생성한다면, 예외를 일으키고 그것으로부터 복구하는 것보다는 예외적인 조건을 테스트하는 것이 때로는 더욱 효과적일 것입니다.

Import 서술문 부담

import 서술문은 어느 곳에서나 실행될 수 있습니다. 때로는 그것들을 함수안에 두어 그들의 가시성을 제한하거나 초기화 기동시간을 감소시키는 것이 유용합니다. 파이썬 인터프리터는 같은 모듈을 여러번 수입하지 않도록 최적화 되어 있기는 하지만, 수입 서술문을 반복적으로 실행하면 어떤 상황에서는 수행속도에 심각한 영향을 줄 수 있습니다.

다음의 두 개의 조각 코드를 연구해 보세요 (내가 믿기로, 그레그 맥팔레인(Greg McFarlane)으로 부터 인용함, - comp.lang.python/python-list@python.org에 올려진 글에서는 누군이지 몰랐으나 나중에 다른 소스로부터 그의 글인지 알았습니다):

def doit():
    import string             ###### import statement inside function
    string.lower('Python')

for num in range(100000):
    doit()

import string             ###### import statement outside function
def doit():
    string.lower('Python')

for num in range(100000):
    doit()

def doit():
    'Python'.lower()

for num in range(100000):
    doit()

위의 예제는 겉보기에 약간 꾸민감이 있지만, 일반 원리는 유지하고 있습니다.

map을 사전과 사용하기

map을 사용하여 다음과 같은 간단한 for 회돌이를 제거하려고 할때 당황스러웠는데 그 이유는:

dict = {}
nil = []
for s in list:
    dict[s] = nil

dict = {}
map(operator.setitem, [dict]*len(list), list, [])
list = statedict.keys()

(아론 워터스(Aaron Watters)의 메모로부터 인용함)

파이썬에서 함수 호출 부담은, 특히 내장 함수의 실행 속도에 비교해 본다면 상대적으로 높습니다. 이것으로 확실히 알 수 있는 것은, 확장 모듈 함수는 데이타 모음을 가능한 곳에서 처리해야한다는 것입니다. 여기에 파이썬으로 작성되어 고안된 예제가 있습니다. (단지 그 함수가 C 로 작성된 것처럼 가장하고 있습니다. :-)

x = 0
def doit(i):
    global x
    x = x + i

list = range(10000)
for i in list:
    doit(i)

x = 0
def doit(list):
    global x
    for i in list:
	x = x + i

list = range(10000)
doit(list)

파이썬 인터프리터는 약간의 주기적인 점검을 수행합니다. 특히, 또 다른 쓰레드를 수행하도록 할 것인가 말것인가를 결정하고 정지된 호출을 (전형적으로 신호 처리자에 의해 구축된 호출을) 실행할 것인지 말지인지를 결정합니다. 대부분의 경우에는 할일이 없습니다, 그래서 이러한 점검을 수행하게 되면 인터프리터의 회돌이를 통과할 때 마다 속도를 떨어뜨릴 수 있습니다. sys 모듈에는, 함수 setcheckinterval이 있는데, 그것을 호출하여 이러한 주기적인 점검을 얼마나 자주 할 것인가를 인터프리터에게 명령할 수 있습니다. 파이썬 1.4 에서 기본 값은 10입니다. 만약 쓰레드로 실행하지 않을 것이라면 그리고 수 많은 신호를 나포할 것 같지 않다면, 이것을 큰 값으로 설정하면 인터프리터의 성능을, 어떤 때는 상당히, 증진 시킬 수 있습니다.

마지막으로 수정됨: Thu Jul 12 12:02:02 CDT 2001