[python] 파이썬에서 가장 효율적인 문자열 연결 방법은 무엇입니까?

John Fouhy의 답변에 따르면, 필요한 경우가 아니라면 최적화하지 마십시오. 그러나 여기에 있고이 질문을하는 경우 반드시 해야하기 때문일 수 있습니다 . 필자의 경우 문자열 변수에서 일부 URL을 빨리 조립해야했습니다. 나는 (지금까지) 문자열 형식 방법을 고려하고있는 사람이 없다는 것을 알았습니다. 그래서 나는 그것을 시도 할 것이라고 생각했으며, 주로 약간의 관심을 끌기 위해 좋은 보간을 위해 거기에 문자열 보간 연산자를 던질 것이라고 생각했습니다. 솔직히 말해서, 나는 이들 중 어느 것이 직접적인 ‘+’연산이나 ”.join ()까지 쌓을 것이라고 생각하지 않았습니다. 하지만 그거 알아? Python 2.7.5 시스템 에서 문자열 보간 연산자는 모두 규칙을 지정 하고 string.format ()이 가장 나쁜 성능을 나타냅니다.

# concatenate_test.py

from __future__ import print_function
import timeit

domain = 'some_really_long_example.com'
lang = 'en'
path = 'some/really/long/path/'
iterations = 1000000

def meth_plus():
    '''Using + operator'''
    return 'http://' + domain + '/' + lang + '/' + path

def meth_join():
    '''Using ''.join()'''
    return ''.join(['http://', domain, '/', lang, '/', path])

def meth_form():
    '''Using string.format'''
    return 'http://{0}/{1}/{2}'.format(domain, lang, path)

def meth_intp():
    '''Using string interpolation'''
    return 'http://%s/%s/%s' % (domain, lang, path)

plus = timeit.Timer(stmt="meth_plus()", setup="from __main__ import meth_plus")
join = timeit.Timer(stmt="meth_join()", setup="from __main__ import meth_join")
form = timeit.Timer(stmt="meth_form()", setup="from __main__ import meth_form")
intp = timeit.Timer(stmt="meth_intp()", setup="from __main__ import meth_intp")

plus.val = plus.timeit(iterations)
join.val = join.timeit(iterations)
form.val = form.timeit(iterations)
intp.val = intp.timeit(iterations)

min_val = min([plus.val, join.val, form.val, intp.val])

print('plus %0.12f (%0.2f%% as fast)' % (plus.val, (100 * min_val / plus.val), ))
print('join %0.12f (%0.2f%% as fast)' % (join.val, (100 * min_val / join.val), ))
print('form %0.12f (%0.2f%% as fast)' % (form.val, (100 * min_val / form.val), ))
print('intp %0.12f (%0.2f%% as fast)' % (intp.val, (100 * min_val / intp.val), ))

결과 :

# python2.7 concatenate_test.py
plus 0.360787868500 (90.81% as fast)
join 0.452811956406 (72.36% as fast)
form 0.502608060837 (65.19% as fast)
intp 0.327636957169 (100.00% as fast)

더 짧은 도메인과 더 짧은 경로를 사용하면 여전히 보간이 성공합니다. 그러나 그 차이는 줄이 길수록 더 두드러집니다.

좋은 테스트 스크립트를 얻었으므로 Python 2.6, 3.3 및 3.4에서도 테스트했습니다. 결과는 다음과 같습니다. 파이썬 2.6에서는 더하기 연산자가 가장 빠릅니다! Python 3에서는 join이 승리합니다. 참고 :이 테스트는 시스템에서 매우 반복 가능합니다. 따라서 ‘plus’는 2.6에서 항상 빠르며 ‘intp’는 2.7에서 항상 빠르며 ‘join’은 Python 3.x에서 항상 빠릅니다.

# python2.6 concatenate_test.py
plus 0.338213920593 (100.00% as fast)
join 0.427221059799 (79.17% as fast)
form 0.515371084213 (65.63% as fast)
intp 0.378169059753 (89.43% as fast)

# python3.3 concatenate_test.py
plus 0.409130576998 (89.20% as fast)
join 0.364938726001 (100.00% as fast)
form 0.621366866995 (58.73% as fast)
intp 0.419064424001 (87.08% as fast)

# python3.4 concatenate_test.py
plus 0.481188605998 (85.14% as fast)
join 0.409673971997 (100.00% as fast)
form 0.652010936996 (62.83% as fast)
intp 0.460400978001 (88.98% as fast)

# python3.5 concatenate_test.py
plus 0.417167026084 (93.47% as fast)
join 0.389929617057 (100.00% as fast)
form 0.595661019906 (65.46% as fast)
intp 0.404455224983 (96.41% as fast)

교훈 :

• 때로는 내 가정이 잘못되었습니다.
• 시스템 환경에 대해 테스트하십시오. 프로덕션 환경에서 실행됩니다.
• 문자열 보간은 아직 죽지 않았습니다!

tl; dr :

• 2.6을 사용하는 경우 + 연산자를 사용하십시오.
• 2.7을 사용하는 경우 ‘%’연산자를 사용하십시오.
• 3.x를 사용하는 경우 ”.join ()을 사용하십시오.

답변

from time import time
stri=''
a='aagsdfghfhdyjddtyjdhmfghmfgsdgsdfgsdfsdfsdfsdfsdfsdfddsksarigqeirnvgsdfsdgfsdfgfg'
l=[]
#case 1
t=time()
for i in range(1000):
    stri=stri+a+repr(i)
print time()-t

#case 2
t=time()
for i in xrange(1000):
    l.append(a+repr(i))
z=''.join(l)
print time()-t

#case 3
t=time()
for i in range(1000):
    stri=stri+repr(i)
print time()-t

#case 4
t=time()
for i in xrange(1000):
    l.append(repr(i))
z=''.join(l)
print time()-t

$ python -m timeit -s 's=""' 's+="a"'
10000000 loops, best of 3: 0.176 usec per loop
$ python -m timeit -s 's=[]' 's.append("a")'
10000000 loops, best of 3: 0.196 usec per loop
$ python -m timeit -s 's=""' 's="".join((s,"a"))'
100000 loops, best of 3: 16.9 usec per loop
$ python -m timeit -s 's=""' 's="%s%s"%(s,"a")'
100000 loops, best of 3: 19.4 usec per loop