การต่อสตริงที่มีประสิทธิภาพมากที่สุดในไพ ธ อนคืออะไร?

มีวิธีการเรียงสตริงจำนวนมากที่มีประสิทธิภาพใน Python (เช่นStringBuilderใน C # หรือStringBufferใน Java) หรือไม่? ฉันพบวิธีการต่อไปนี้ที่นี่ :

• การต่อข้อมูลอย่างง่ายโดยใช้ +
• ใช้รายการสตริงและjoinวิธีการ
• ใช้UserStringจากMutableStringโมดูล
• การใช้อาร์เรย์อักขระและarrayโมดูล
• ใช้cStringIOจากStringIOโมดูล

แต่คุณใช้ผู้เชี่ยวชาญหรือแนะนำอะไรและเพราะอะไร

[ คำถามที่เกี่ยวข้องที่นี่ ]

คุณอาจจะสนใจสิ่งนี้: เรื่องเล็ก ๆ น้อย ๆจากการเพิ่มประสิทธิภาพโดยกุยโด้ แม้ว่ามันจะคุ้มค่าที่จะจำได้ว่านี่เป็นบทความเก่าและมีการมีอยู่ของสิ่งต่าง ๆ เช่น''.join(แม้ว่าฉันเดาว่าเหมือนกันstring.joinfieldsมากหรือน้อย)

ด้วยความแข็งแกร่งของarrayโมดูลนั้นอาจเร็วที่สุดหากคุณสามารถแก้ปัญหาของคุณได้ แต่''.joinอาจเร็วพอและมีประโยชน์ในการใช้สำนวนและง่ายกว่าสำหรับผู้เขียนโปรแกรมไพ ธ อนคนอื่น ๆ ที่จะเข้าใจ

ในที่สุดกฎทองแห่งการเพิ่มประสิทธิภาพ: อย่าปรับให้เหมาะสมเว้นแต่คุณจะรู้ว่าคุณต้องการและวัดผลแทนที่จะคาดเดา

คุณสามารถวัดวิธีการต่าง ๆ โดยใช้timeitโมดูล ที่สามารถบอกคุณได้ว่าอะไรเร็วที่สุดแทนที่จะเป็นคนแปลกหน้าบนอินเทอร์เน็ตที่เดาได้

''.join(sequenceofstrings) อะไรที่มักจะใช้ได้ดีที่สุด - ง่ายที่สุดและเร็วที่สุด

งูหลาม 3.6 เปลี่ยนเกมสำหรับสตริงของส่วนประกอบที่รู้จักกันกับตัวอักษร String แก้ไข

รับกรณีทดสอบจากคำตอบของ mkoistinenมีสตริง

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

ผู้เข้าชิงคือ

• f'http://{domain}/{lang}/{path}'- 0.151 µs

• 'http://%s/%s/%s' % (domain, lang, path) - 0.321 µs

• 'http://' + domain + '/' + lang + '/' + path - 0.356 µs

• ''.join(('http://', domain, '/', lang, '/', path))- 0.249 (s (โปรดสังเกตว่าการสร้าง tuple ที่มีความยาวคงที่นั้นเร็วกว่าการสร้างรายการที่มีความยาวคงที่เล็กน้อย)

ดังนั้นในปัจจุบันรหัสที่สั้นที่สุดและสวยงามที่สุดจึงเป็นวิธีที่เร็วที่สุด

ในเวอร์ชันอัลฟ่าของ Python 3.6 การใช้งานf''สตริงนั้นช้าที่สุด - จริง ๆ แล้วโค้ดไบต์ที่สร้างนั้นค่อนข้างจะเทียบเท่ากับ''.join()กรณีที่มีการเรียกที่ไม่จำเป็นstr.__format__ซึ่งไม่มีข้อโต้แย้งใดselfๆ ความไร้ประสิทธิภาพเหล่านี้ได้รับการแก้ไขก่อน 3.6 ขั้นสุดท้าย

ความเร็วสามารถตัดกับวิธีที่เร็วที่สุดสำหรับ Python 2 ซึ่งเป็นการ+ต่อข้อมูลบนคอมพิวเตอร์ของฉัน และนั่นใช้0.203 withsกับสตริง 8 บิตและ0.259 µs ถ้าสตริงเป็น Unicode ทั้งหมด

ขึ้นอยู่กับสิ่งที่คุณทำ

หลังจาก Python 2.5 การต่อสตริงกับตัวดำเนินการ + ค่อนข้างเร็ว หากคุณกำลังต่อค่าสองสามค่าเข้าด้วยกันการใช้เครื่องหมาย + จะทำงานได้ดีที่สุด:

>>> x = timeit.Timer(stmt="'a' + 'b'")
>>> x.timeit()
0.039999961853027344

>>> x = timeit.Timer(stmt="''.join(['a', 'b'])")
>>> x.timeit()
0.76200008392333984

อย่างไรก็ตามหากคุณรวมสตริงเข้าด้วยกันคุณควรใช้วิธีการเข้าร่วมรายการ:

>>> join_stmt = """
... joined_str = ''
... for i in xrange(100000):
...   joined_str += str(i)
... """
>>> x = timeit.Timer(join_stmt)
>>> x.timeit(100)
13.278000116348267

>>> list_stmt = """
... str_list = []
... for i in xrange(100000):
...   str_list.append(str(i))
... ''.join(str_list)
... """
>>> x = timeit.Timer(list_stmt)
>>> x.timeit(100)
12.401000022888184

... แต่โปรดสังเกตว่าคุณจะต้องใส่จำนวนสตริงที่ค่อนข้างสูงก่อนที่จะเห็นความแตกต่าง

ในฐานะที่เป็นคำตอบต่อจอห์น 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 ด้วยผลลัพธ์ที่นี่ ใน Python 2.6 ตัวดำเนินการบวกเร็วที่สุด! บน Python 3 เข้าร่วมรับรางวัล หมายเหตุ: การทดสอบเหล่านี้สามารถทำซ้ำได้ในระบบของฉัน ดังนั้น 'plus' จะเร็วขึ้นเสมอบน 2.6 'intp' จะเร็วขึ้นเสมอที่ 2.7 และ 'เข้าร่วม' จะเร็วขึ้นใน 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)

บทเรียน:

• บางครั้งสมมติฐานของฉันผิดไป
• ทดสอบกับระบบ env คุณจะทำงานในการผลิต
• การแก้ไขสตริงยังไม่ตาย!

TL; DR:

• หากคุณใช้ 2.6 ให้ใช้ตัวดำเนินการ +
• หากคุณใช้ 2.7 ให้ใช้โอเปอเรเตอร์ '%'
• หากคุณใช้ 3.x use '' .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

ผล

1 0.00493192672729

2 0.000509023666382

3 0.00042200088501

4 0.000482797622681

ในกรณีที่ 1 & 2 เราเพิ่มสตริงขนาดใหญ่และเข้าร่วม () ทำงานได้เร็วขึ้นประมาณ 10 เท่า ในกรณีที่ 3 และ 4 เราเพิ่มสตริงขนาดเล็กและ '+' จะทำงานได้เร็วขึ้นเล็กน้อย

ฉันวิ่งเข้าไปในสถานการณ์ที่ฉันต้องมีสตริงที่ไม่รู้จักขนาดที่ต่อท้ายได้ เหล่านี้คือผลการเปรียบเทียบ (python 2.7.3):

$ 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

ดูเหมือนว่าจะแสดงว่า '+ =' เร็วที่สุด ผลลัพธ์จากลิงค์ skymind นั้นล้าสมัยไปเล็กน้อย

(ฉันรู้ว่าตัวอย่างที่สองไม่สมบูรณ์รายการสุดท้ายจะต้องเข้าร่วมอย่างไรก็ตามจะแสดงให้เห็นว่าการเตรียมรายการใช้เวลานานกว่าการเชื่อมโยงสตริง)

หนึ่งปีต่อมามาทดสอบคำตอบของ mkoistinen กับ python 3.4.3:

• บวก 0.963564149000 (เร็วที่สุด 95.83%)
• เข้าร่วม 0.923408469000 (เร็วที่สุด 100.00%)
• แบบฟอร์ม 1.501130934000 (เร็วถึง 61.51%)
• intp 1.019677452000 (เร็ว 90.56%)

ไม่มีอะไรเปลี่ยนแปลง เข้าร่วมยังคงเป็นวิธีที่เร็วที่สุด ด้วยการที่ intp เป็นเนื้อหาที่ดีที่สุดในแง่ของการอ่านคุณอาจต้องการใช้ intp อย่างไรก็ตาม

แรงบันดาลใจจากมาตรฐานของ @ JasonBaker ต่อไปนี้เป็นวิธีเปรียบเทียบง่ายๆ 10 "abcdefghijklmnopqrstuvxyz"สตริงซึ่งแสดงว่า.join()เร็วกว่า แม้ว่าตัวแปรเพิ่มขึ้นเล็กน้อยนี้:

Catenation

>>> x = timeit.Timer(stmt='"abcdefghijklmnopqrstuvxyz" + "abcdefghijklmnopqrstuvxyz" + "abcdefghijklmnopqrstuvxyz" + "abcdefghijklmnopqrstuvxyz" + "abcdefghijklmnopqrstuvxyz" + "abcdefghijklmnopqrstuvxyz" + "abcdefghijklmnopqrstuvxyz" + "abcdefghijklmnopqrstuvxyz" + "abcdefghijklmnopqrstuvxyz" + "abcdefghijklmnopqrstuvxyz" + "abcdefghijklmnopqrstuvxyz"')
>>> x.timeit()
0.9828147209324385

ร่วม

>>> x = timeit.Timer(stmt='"".join(["abcdefghijklmnopqrstuvxyz", "abcdefghijklmnopqrstuvxyz", "abcdefghijklmnopqrstuvxyz", "abcdefghijklmnopqrstuvxyz", "abcdefghijklmnopqrstuvxyz", "abcdefghijklmnopqrstuvxyz", "abcdefghijklmnopqrstuvxyz", "abcdefghijklmnopqrstuvxyz", "abcdefghijklmnopqrstuvxyz", "abcdefghijklmnopqrstuvxyz", "abcdefghijklmnopqrstuvxyz"])')
>>> x.timeit()
0.6114138159765048

สำหรับชุดสั้น ๆของสตริงขนาดเล็ก (เช่น 2 หรือ 3 สายอักขระที่มีความยาวไม่เกินสองสามตัว) บวกยังคงเร็วกว่า การใช้สคริปต์ที่ยอดเยี่ยมของ mkoistinen ใน Python 2 และ 3:

plus 2.679107467004 (100.00% as fast)
join 3.653773699996 (73.32% as fast)
form 6.594011374000 (40.63% as fast)
intp 4.568015249999 (58.65% as fast)

ดังนั้นเมื่อรหัสของคุณทำการเรียงต่อกันขนาดเล็กจำนวนมากบวกกับเป็นวิธีที่ต้องการถ้าความเร็วเป็นสิ่งสำคัญ

"f-strings ใหม่ใน Python 3.6" น่าจะเป็นวิธีที่มีประสิทธิภาพมากที่สุดในการเชื่อมสตริง

ใช้% s

>>> timeit.timeit("""name = "Some"
... age = 100
... '%s is %s.' % (name, age)""", number = 10000)
0.0029734770068898797

ใช้. ฟอร์แมต

>>> timeit.timeit("""name = "Some"
... age = 100
... '{} is {}.'.format(name, age)""", number = 10000)
0.004015227983472869

ใช้ f

>>> timeit.timeit("""name = "Some"
... age = 100
... f'{name} is {age}.'""", number = 10000)
0.0019175919878762215

ที่มา: https://realpython.com/python-f-strings/