Gibt es einen Grund, nicht '+' zu verwenden, um zwei Strings zu verketten?

Einer gemeinsamen antipattern in Python ist die Verkettung einer Folge von strings mit + in einer Schleife. Das ist schlecht, da der Python-interpreter hat, erstellen Sie einen neuen string-Objekt für jede iteration, und es endet, wobei quadratische Zeit. (Aktuelle Versionen von CPython kann anscheinend diese optimieren, in einigen Fällen, aber in anderen Implementierungen können nicht, so dass die Programmierer davon abgehalten werden, sich auf diese.) ''.join ist der richtige Weg, dies zu tun.

Aber ich habe gehört, es sagte (wie hier zum Beispiel auf Stack Overflow) , sollten Sie nie, nie Verwendung + für die string-Verkettung, sondern verwenden Sie immer ''.join oder eine format-string. Ich verstehe nicht, warum dies der Fall ist, wenn man nur die Verkettung von zwei Zeichenfolgen. Wenn mein Verständnis richtig ist, sollte es nicht nehmen quadratischen Zeit, und ich denke a + b ist sauberer und besser lesbar als die beiden ''.join((a, b)) oder '%s%s' % (a, b).

Ist es gute Praxis zu verwenden + um zwei strings zu verketten? Oder ist es ein problem, ich bin mir nicht bewusst?

InformationsquelleAutor der Frage Taymon | 2012-04-06

  1. 93

    Es ist nichts falsch in der Verkettung zwei strings mit +. In der Tat, es ist einfacher zu Lesen als ''.join([a, b]).

    Sind Sie richtig wenn Sie, dass die Verkettung von mehr als 2 strings mit + ist ein O(n^2) Betrieb (im Vergleich zu O(n) für join) und somit ineffizient. Aber dies hat nicht zu tun mit einer Schleife. Auch a + b + c + ... ist O(n^2), der Grund dafür ist, dass jede Verkettung erzeugt einen neuen string.

    CPython2.4 und oben versuchen zu mildern, aber es ist immer noch ratsam, zu verwenden join bei der Verkettung von mehr als 2 strings.

    InformationsquelleAutor der Antwort ggozad

  2. 43

    Plus-operator ist völlig in Ordnung, Lösung zu verketten zwei Python-strings. Aber wenn Sie halten das hinzufügen von mehr als zwei Zeichenketten (n > 25) , möchten Sie vielleicht zu denken, etwas anderes.

    ''.join([a, b, c]) trick ist eine performance-Optimierung.

    InformationsquelleAutor der Antwort Mikko Ohtamaa

  3. 6

    Beim arbeiten mit mehreren Personen, ist es manchmal schwierig, genau zu wissen, was passiert. Mit einem format-string anstelle von verketten kann, vermeiden, eine Besondere Lästigkeit, die passiert ist, eine ganze Tonne von mal zu uns:

    Sagen, eine Funktion benötigt ein argument, und Sie es schreiben erwartet man eine Zeichenfolge:

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

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

    So, diese Funktion kann benutzt werden ziemlich oft in dem gesamten code. Ihre Mitarbeiter können genau wissen, was es tut, aber nicht unbedingt vollkommen up-to-Geschwindigkeit auf die Interna, und kann nicht wissen, dass die Funktion erwartet einen string. Und so können Sie am Ende mit diesem:

    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

    Wäre es kein problem, wenn Sie nur ein format-string:

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

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

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

    Das gleiche gilt für alle Arten von Objekten, definieren __str__die möglicherweise übergeben werden müssen:

    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

    Also ja: Wenn Sie können, verwenden Sie eine format-string - tun es und nutzen, was Python zu bieten hat.

    InformationsquelleAutor der Antwort Izkata

  4. 5

    Der Annahme, dass sollte man nie, nie, verwenden Sie + für string-Verkettung, sondern immer ".- Verknüpfung kann sein, ein Mythos. Es ist wahr, dass mit + schafft unnötige temporäre Kopien unveränderliches string-Objekt, aber der andere nicht die oft zitierte Tatsache ist, dass der Aufruf join in einer Schleife würde in der Regel fügen Sie den Aufwand function call. Nehmen wir dein Beispiel.

    Erstellen Sie zwei Listen, eine aus dem verlinkten Frage ALSO und ein weiterer eine größere hergestellt

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

    Können erstellen Sie zwei Funktionen, die UseJoin und UsePlus an der jeweiligen join und + Funktionalität.

    >>> 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)]

    Lets laufen timeit mit der ersten Liste

    >>> 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
>>>

    Haben Sie fast die gleiche Laufzeit.

    Können Verwendung 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}

    Und es sieht aus, dass die Verwendung von Join-Ergebnisse in unnötige Funktionsaufrufe, die hinzufügen können, um den overhead.

    Kommen nun auch wieder die Frage. Sollte man raten von der Verwendung von + über join in allen Fällen?

    Glaube ich nicht, Dinge, die berücksichtigt werden sollten,

    1. Länge der Zeichenfolge in Frage
    2. Keine der verkettungsoperation.

    - Und off-Kurs in einer Entwicklung-pre-Reife-Optimierung ist böse.

    InformationsquelleAutor der Antwort Abhijit

  5. 2

    Ich habe eine quick-test:

    import sys

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

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

    zeitspiele:

    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

    Gibt es anscheinend eine Optimierung für die a = a + b Fall. Es nicht eine O(n^2) Zeit, wie man meinen könnte.

    Also zumindest in Bezug auf Leistung, mit + ist in Ordnung.

    InformationsquelleAutor der Antwort Michael Slade

  6. 2

    Laut Python-docs, mit str.join() geben Ihnen die Leistung, Konsistenz über verschiedene Implementierungen von Python. Obwohl CPython optimiert den Weg der quadratischen Verhalten von s = s + t, andere Python-Implementierungen möglicherweise nicht.

    CPython-Implementierung detail: Wenn s und t sind beide Zeichenfolgen, einige
    Python-Implementierungen wie CPython kann in der Regel durchführen einer in-place
    Optimierung für Zuweisungen der form s = s + t oder s += t -. Wenn
    anwendbar, wird diese Optimierung macht quadratische Laufzeit viel weniger
    wahrscheinlich. Diese Optimierung wird sowohl die version und Umsetzung
    abhängig. Für performance-sensitive code, ist es vorzuziehen, verwenden Sie die
    str.join () - Methode, die gewährleistet konsistente lineare Verkettung
    performance across-Versionen und Implementierungen.

    Sequenz-Typen in Python docs (siehe Fußnote [6])

    InformationsquelleAutor der Antwort Duke

  7. -3

    ".join([a, b]) ist die bessere Lösung als +.

    Da der Code geschrieben werden sollte in einer Weise, die nicht in Nachteil zu anderen Implementierungen von Python (PyPy, Jython, IronPython, Cython, Psyco, und so)

    form a += b oder a = a + b ist zerbrechlich, selbst in CPython und ist nicht in allen Implementierungen die nicht refcounting (reference counting ist eine Technik, bei der die Speicherung der Anzahl der Referenzen, Pointer oder handles auf eine Ressource, wie ein Objekt, block, Arbeitsspeicher, Festplattenplatz oder anderen Ressourcen)

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

    InformationsquelleAutor der Antwort muhammad ali

Schreibe einen Kommentar