มีเหตุผลใดที่จะไม่ใช้ '+' เพื่อเชื่อมสองสตริงเข้าด้วยกัน?

antipattern ทั่วไปใน Python คือการต่อลำดับของสตริงโดยใช้+ในลูป สิ่งนี้ไม่ดีเนื่องจากล่าม Python ต้องสร้างออบเจ็กต์สตริงใหม่สำหรับการวนซ้ำแต่ละครั้งและจะใช้เวลากำลังสอง (เห็นได้ชัดว่า CPython เวอร์ชันล่าสุดสามารถปรับให้เหมาะสมได้ในบางกรณี แต่การใช้งานอื่น ๆ ไม่สามารถทำได้ดังนั้นโปรแกรมเมอร์จึงไม่สามารถพึ่งพาสิ่งนี้ได้) ''.joinเป็นวิธีที่ถูกต้องในการดำเนินการนี้

อย่างไรก็ตามฉันเคยได้ยินมาว่า ( รวมถึงที่นี่ใน Stack Overflow ) ว่าคุณไม่ควรใช้+สำหรับการต่อสายอักขระ แต่ควรใช้''.joinหรือใช้สตริงรูปแบบแทน ฉันไม่เข้าใจว่าเหตุใดจึงเป็นเช่นนี้หากคุณเชื่อมต่อเพียงสองสตริง ถ้าความเข้าใจของฉันถูกต้องก็ไม่ควรใช้เวลาในการกำลังสองและผมคิดว่าa + bเป็นที่สะอาดและอ่านได้มากขึ้นกว่าหรือ''.join((a, b))'%s%s' % (a, b)

เป็นแนวทางปฏิบัติที่ดีที่จะใช้+เพื่อเชื่อมสองสตริงเข้าด้วยกันหรือไม่? หรือมีปัญหาที่ฉันไม่ทราบ?

ไม่มีอะไรผิดในการเชื่อมสองสตริงเข้าด้วย+กัน ''.join([a, b])อันที่จริงมันง่ายต่อการอ่านกว่า

คุณพูดถูกแม้ว่าการเชื่อมต่อมากกว่า 2 สตริงด้วยกัน+นั้นเป็นการดำเนินการ O (n ^ 2) (เทียบกับ O (n) สำหรับjoin) และทำให้ไม่มีประสิทธิภาพ อย่างไรก็ตามสิ่งนี้ไม่เกี่ยวข้องกับการใช้ลูป คู่a + b + c + ...คือ O (n ^ 2) เหตุผลที่การเรียงต่อกันทำให้เกิดสตริงใหม่

CPython2.4 ขึ้นไปพยายามลดปัญหานั้น แต่ยังแนะนำให้ใช้joinเมื่อเชื่อมต่อมากกว่า 2 สตริง

ตัวดำเนินการ Plus เป็นโซลูชันที่ดีอย่างสมบูรณ์แบบในการเชื่อมต่อสตริง Python สองสตริง แต่ถ้าคุณเพิ่มมากกว่าสองสตริง (n> 25) ไปเรื่อย ๆ คุณอาจต้องคิดอย่างอื่น

''.join([a, b, c]) เคล็ดลับคือการเพิ่มประสิทธิภาพ

สมมติฐานที่ว่าไม่ควรเคยใช้ + สำหรับการต่อสตริง แต่ใช้ ".join แทนเสมออาจเป็นตำนาน เป็นความจริงที่ว่าการใช้+สร้างสำเนาชั่วคราวที่ไม่จำเป็นของอ็อบเจ็กต์สตริงที่ไม่เปลี่ยนรูปแบบ แต่ข้อเท็จจริงอื่น ๆ ที่ไม่ได้ยกมาก็คือการเรียกjoinแบบวนซ้ำโดยทั่วไปจะเพิ่มค่าโสหุ้ยของfunction call. ลองใช้ตัวอย่างของคุณ

สร้างสองรายการรายการหนึ่งมาจากคำถาม SO ที่เชื่อมโยงและอีกรายการหนึ่งที่มีขนาดใหญ่กว่า

>>> myl1 = ['A','B','C','D','E','F']
>>> myl2=[chr(random.randint(65,90)) for i in range(0,10000)]

ให้สร้างสองฟังก์ชันUseJoinและUsePlusใช้ตามลำดับjoinและ+ฟังก์ชันการทำงาน

>>> def UsePlus():
    return [myl[i] + myl[i + 1] for i in range(0,len(myl), 2)]

>>> def UseJoin():
    [''.join((myl[i],myl[i + 1])) for i in range(0,len(myl), 2)]

ให้รัน timeit กับรายการแรก

>>> myl=myl1
>>> t1=timeit.Timer("UsePlus()","from __main__ import UsePlus")
>>> t2=timeit.Timer("UseJoin()","from __main__ import UseJoin")
>>> print "%.2f usec/pass" % (1000000 * t1.timeit(number=100000)/100000)
2.48 usec/pass
>>> print "%.2f usec/pass" % (1000000 * t2.timeit(number=100000)/100000)
2.61 usec/pass
>>> 

มีรันไทม์เกือบเหมือนกัน

ให้ใช้ cProfile

>>> myl=myl2
>>> cProfile.run("UsePlus()")
         5 function calls in 0.001 CPU seconds

   Ordered by: standard name

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.001    0.001    0.001    0.001 <pyshell#1376>:1(UsePlus)
        1    0.000    0.000    0.001    0.001 <string>:1(<module>)
        1    0.000    0.000    0.000    0.000 {len}
        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}
        1    0.000    0.000    0.000    0.000 {range}


>>> cProfile.run("UseJoin()")
         5005 function calls in 0.029 CPU seconds

   Ordered by: standard name

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.015    0.015    0.029    0.029 <pyshell#1388>:1(UseJoin)
        1    0.000    0.000    0.029    0.029 <string>:1(<module>)
        1    0.000    0.000    0.000    0.000 {len}
        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}
     5000    0.014    0.000    0.014    0.000 {method 'join' of 'str' objects}
        1    0.000    0.000    0.000    0.000 {range}

และดูเหมือนว่าการใช้ Join จะทำให้เกิดการเรียกใช้ฟังก์ชันที่ไม่จำเป็นซึ่งอาจเพิ่มค่าใช้จ่าย

ตอนนี้กลับมาที่คำถาม เราควรกีดกันการใช้+มากกว่าjoinในทุกกรณีหรือไม่?

ฉันเชื่อว่าไม่ควรคำนึงถึงสิ่งต่างๆ

1. ความยาวของสตริงในคำถาม
2. ไม่มีการดำเนินการเชื่อมต่อ

และนอกหลักสูตรในการเพิ่มประสิทธิภาพก่อนวัยพัฒนาเป็นสิ่งที่ชั่วร้าย

เมื่อทำงานกับคนหลายคนบางครั้งก็ยากที่จะรู้ว่าเกิดอะไรขึ้น การใช้สตริงรูปแบบแทนการเชื่อมต่อสามารถหลีกเลี่ยงความรำคาญโดยเฉพาะอย่างยิ่งที่เกิดขึ้นกับเรามากมาย:

สมมติว่าฟังก์ชันต้องการอาร์กิวเมนต์และคุณเขียนโดยคาดหวังว่าจะได้สตริง:

In [1]: def foo(zeta):
   ...:     print 'bar: ' + zeta

In [2]: foo('bang')
bar: bang

ดังนั้นฟังก์ชันนี้อาจใช้บ่อยตลอดโค้ด เพื่อนร่วมงานของคุณอาจรู้แน่ชัดว่ามันทำอะไร แต่ไม่จำเป็นต้องเร่งความเร็วเต็มที่ในการทำงานภายในและอาจไม่ทราบว่าฟังก์ชันนั้นต้องการสตริง ดังนั้นพวกเขาอาจจบลงด้วยสิ่งนี้:

In [3]: foo(23)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)

/home/izkata/<ipython console> in <module>()

/home/izkata/<ipython console> in foo(zeta)

TypeError: cannot concatenate 'str' and 'int' objects

จะไม่มีปัญหาถ้าคุณใช้สตริงรูปแบบ:

In [1]: def foo(zeta):
   ...:     print 'bar: %s' % zeta
   ...:     
   ...:     

In [2]: foo('bang')
bar: bang

In [3]: foo(23)
bar: 23

เช่นเดียวกับออบเจ็กต์ทุกประเภทที่กำหนด__str__ซึ่งอาจส่งผ่านได้เช่นกัน:

In [1]: from datetime import date

In [2]: zeta = date(2012, 4, 15)

In [3]: print 'bar: ' + zeta
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)

/home/izkata/<ipython console> in <module>()

TypeError: cannot concatenate 'str' and 'datetime.date' objects

In [4]: print 'bar: %s' % zeta
bar: 2012-04-15

ใช่: หากคุณสามารถใช้สตริงรูปแบบให้ทำได้และใช้ประโยชน์จากสิ่งที่ Python นำเสนอ

ฉันได้ทำการทดสอบอย่างรวดเร็ว:

import sys

str = e = "a xxxxxxxxxx very xxxxxxxxxx long xxxxxxxxxx string xxxxxxxxxx\n"

for i in range(int(sys.argv[1])):
    str = str + e

และหมดเวลา:

mslade@mickpc:/binks/micks/ruby/tests$ time python /binks/micks/junk/strings.py  8000000
8000000 times

real    0m2.165s
user    0m1.620s
sys     0m0.540s
mslade@mickpc:/binks/micks/ruby/tests$ time python /binks/micks/junk/strings.py  16000000
16000000 times

real    0m4.360s
user    0m3.480s
sys     0m0.870s

เห็นได้ชัดว่ามีการเพิ่มประสิทธิภาพสำหรับa = a + bกรณี ไม่แสดงเวลา O (n ^ 2) อย่างที่อาจสงสัย

ดังนั้นอย่างน้อยในแง่ของประสิทธิภาพการใช้งาน+ก็ใช้ได้

ตามเอกสาร Python การใช้ str.join () จะทำให้คุณมีความสม่ำเสมอของประสิทธิภาพในการใช้งาน Python ต่างๆ แม้ว่า CPython จะปรับพฤติกรรมกำลังสองของ s = s + t ให้เหมาะสม แต่การใช้งาน Python อื่น ๆ ก็ไม่อาจทำได้

รายละเอียดการใช้งาน CPython : หาก s และ t เป็นทั้งสองสตริงการใช้งาน Python บางอย่างเช่น CPython มักจะสามารถทำการเพิ่มประสิทธิภาพแบบแทนที่สำหรับการกำหนดรูปแบบ s = s + t หรือ s + = t เมื่อทำได้การเพิ่มประสิทธิภาพนี้จะทำให้เวลาทำงานกำลังสองมีโอกาสน้อยลง การเพิ่มประสิทธิภาพนี้ขึ้นอยู่กับทั้งเวอร์ชันและการใช้งาน สำหรับโค้ดที่ไวต่อประสิทธิภาพควรใช้วิธี str.join () ซึ่งรับรองประสิทธิภาพการเชื่อมต่อเชิงเส้นที่สอดคล้องกันในเวอร์ชันและการนำไปใช้งาน

ประเภทลำดับในเอกสาร Python (ดูเชิงอรรถ [6])

ฉันใช้สิ่งต่อไปนี้กับ python 3.8

string4 = f'{string1}{string2}{string3}'

'' .join ([a, b])เป็นวิธีการแก้ดีกว่า+

เนื่องจากโค้ดควรเขียนในลักษณะที่ไม่เสียเปรียบการใช้งาน Python อื่น ๆ (PyPy, Jython, IronPython, Cython, Psyco และอื่น ๆ )

รูปแบบ + b = หรือ = A + B จะเปราะบางแม้ใน CPython และไม่อยู่ในที่ทั้งหมดในการใช้งานที่ไม่ได้ใช้ refcounting (อ้างอิงนับเป็นเทคนิคในการจัดเก็บจำนวนการอ้างอิงตัวชี้หรือมือจับไปที่ ทรัพยากรเช่นวัตถุบล็อกหน่วยความจำพื้นที่ดิสก์หรือทรัพยากรอื่น ๆ )

https://www.python.org/dev/peps/pep-0008/#programming-recommendations