İki dizeyi birleştirmek için '+' kullanmamak için herhangi bir neden var mı?

Python'daki yaygın bir antipattern +, bir döngü içinde kullanarak bir dizi dizeyi birleştirmektir . Bu kötüdür çünkü Python yorumlayıcısının her yineleme için yeni bir dizgi nesnesi oluşturması gerekir ve bu, ikinci dereceden zaman alır. (CPython'un son sürümleri görünüşe göre bunu bazı durumlarda optimize edebilir, ancak diğer uygulamalar bunu yapamaz, bu nedenle programcıların buna güvenmesi önerilmez.) ''.joinBunu yapmanın doğru yoludur.

Bununla birlikte, ( burada Stack Overflow dahil ) dize birleştirme için asla ve asla kullanmamanız gerektiğini +, bunun yerine her zaman ''.joinveya bir biçim dizesi kullanmanız gerektiğini söylediğini duydum . Sadece iki dizgeyi birleştiriyorsanız neden böyle olduğunu anlamıyorum. Benim anlayış doğru ise, o kuadratik zaman almamalıdır ve bence a + bdaha temiz ve ya daha okunabilir ''.join((a, b))veya '%s%s' % (a, b).

+İki dizeyi birleştirmek için kullanmak iyi bir uygulama mı ? Yoksa farkında olmadığım bir sorun mu var?

İki dizgeyi birleştirmede yanlış bir şey yok +. Gerçekten okumaktan daha kolaydır ''.join([a, b]).

Haklısınız, ancak 2'den fazla dizeyi bitiştirmenin +bir O (n ^ 2) işlemi (O (n) için ile karşılaştırıldığında join) ve bu nedenle verimsiz hale geliyor. Ancak bunun bir döngü kullanmakla ilgisi yoktur. a + b + c + ...O (n ^ 2) bile çifttir, bunun nedeni her birleştirme işleminin yeni bir dize üretmesidir.

CPython2.4 ve üstü bunu azaltmaya çalışır, ancak yine de join2'den fazla dizeyi birleştirirken kullanılması tavsiye edilir .

Plus operatörü, iki Python dizesini birleştirmek için mükemmel bir çözümdür . Ancak ikiden fazla dizge eklemeye devam ederseniz (n> 25), başka bir şey düşünmek isteyebilirsiniz.

''.join([a, b, c]) hile bir performans optimizasyonudur.

Dize birleştirme için hiçbir zaman + kullanılmaması gerektiği, bunun yerine her zaman '' .join kullanılması gerektiği varsayımı bir efsane olabilir. Kullanmanın, +değişmez dizge nesnesinin gereksiz geçici kopyalarını oluşturduğu doğrudur, ancak çoğu kez alıntılanmayan diğer gerçek, joinbir döngü içinde çağırmanın genellikle ek yükünü ekleyeceğidir function call. Örneğinizi ele alalım.

Biri bağlantılı SO sorusundan ve diğeri daha büyük fabrikasyon olmak üzere iki liste oluşturun

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

İki işlevi oluşturmak, Lets UseJoinve UsePlusilgili kullanımı joinve +işlevselliği.

>>> 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'i ilk listeyle çalıştıralım

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

Neredeyse aynı çalışma süresine sahipler.

CProfile kullanalım

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

Ve Görünüşe göre Join kullanmak, ek yüke neden olabilecek gereksiz işlev çağrılarına neden olur.

Şimdi soruya geri dönüyoruz. Her durumda +over kullanımını caydırmak gerekir joinmi?

Hayır inanıyorum, dikkate alınması gereken şeyler

1. Söz konusu Dizenin Uzunluğu
2. Birleştirme İşlemi Sayısı.

Ve tabii ki, gelişmeden önce olgunlaşmamış bir optimizasyon kötüdür.

Birden fazla kişiyle çalışırken, bazen tam olarak ne olduğunu bilmek zordur. Birleştirme yerine bir biçim dizesi kullanmak, başımıza pek çok kez gelen belirli bir rahatsızlığı önleyebilir:

Diyelim ki, bir işlev bir argüman gerektirir ve siz onu bir dizge almayı bekleyerek yazarsınız:

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

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

Bu nedenle, bu işlev kod boyunca oldukça sık kullanılabilir. İş arkadaşlarınız tam olarak ne yaptığını biliyor olabilir, ancak dahili bileşenlerde tam olarak hızlanmayabilir ve işlevin bir dizi beklediğini bilmeyebilir. Ve böylece bununla sonuçlanabilirler:

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

Sadece bir biçim dizesi kullandıysanız sorun olmaz:

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

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

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

Aynısı __str__, aynı zamanda aktarılabilen tanımlayan tüm nesne türleri için de geçerlidir :

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

Yani evet: Bir biçim dizesi kullanabiliyorsanız bunu ve Python teklif neler yararlanmak.

Hızlı bir test yaptım:

import sys

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

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

ve zamanladı:

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

Görünüşe göre bir optimizasyon var a = a + b durum . Birinin tahmin edebileceği gibi O (n ^ 2) zamanı göstermez.

Yani en azından performans açısından kullanmak +iyidir.

Python belgelerine göre, str.join () kullanmak size çeşitli Python uygulamalarında performans tutarlılığı sağlayacaktır. CPython, s = s + t'nin ikinci dereceden davranışını optimize etse de, diğer Python uygulamaları olmayabilir.

CPython uygulama ayrıntısı : Eğer s ve t her iki dizgeyse, CPython gibi bazı Python uygulamaları genellikle s = s + t veya s + = t biçimindeki atamalar için yerinde bir optimizasyon gerçekleştirebilir. Mümkün olduğunda, bu optimizasyon ikinci dereceden çalışma zamanını çok daha az olası kılar. Bu optimizasyon hem sürüme hem de uygulamaya bağlıdır. Performansa duyarlı kod için, sürümler ve uygulamalar arasında tutarlı doğrusal birleştirme performansı sağlayan str.join () yönteminin kullanılması tercih edilir.

Python belgelerinde Dizi Türleri (dip nota [6] bakın)

Aşağıdakileri python 3.8 ile kullanıyorum

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

'' .join ([a, b]) + ' dan daha iyi bir çözümdür .

Çünkü Kod, Python'un diğer uygulamalarını (PyPy, Jython, IronPython, Cython, Psyco ve benzeri) dezavantajlı olmayacak şekilde yazılmalıdır.

formu, a + b = veya = a + b da CPython kırılgan ve uygulamalarda hiç mevcut olmayan bir kullanmayın refcounting referans sayılması için referanslar, işaretçileri veya kolları sayısını depolamak için bir tekniktir ( bir nesne, bellek bloğu, disk alanı veya diğer kaynaklar gibi kaynak )

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