Jaki jest preferowany sposób łączenia łańcuchów w Pythonie?

Jeśli łączysz wiele wartości, to żadne z nich. Dołączanie listy jest drogie. Możesz użyć do tego StringIO. Zwłaszcza, jeśli budujesz go w ciągu wielu operacji.

from cStringIO import StringIO
# python3:  from io import StringIO

buf = StringIO()

buf.write('foo')
buf.write('foo')
buf.write('foo')

buf.getvalue()
# 'foofoofoo'

Jeśli masz już pełną listę zwróconą z innej operacji, po prostu użyj ''.join(aList)

Z PYTHONOWEGO FAQ: jaki jest najskuteczniejszy sposób łączenia wielu łańcuchów?

Obiekty Str i bytes są niezmienne, dlatego konkatenacja wielu ciągi razem są nieefektywne, ponieważ każda konkatenacja tworzy nową obiekt. W ogólnym przypadku całkowity koszt wykonania jest kwadratowy w całkowita długość sznurka.

Aby zgromadzić wiele obiektów str, zalecanym idiomem jest umieszczenie ich do listy i wywołania str.join () na końcu:

chunks = []
for s in my_strings:
    chunks.append(s)
result = ''.join(chunks)

(innym dość wydajnym idiomem jest używanie io.StringIO)

Aby zgromadzić wiele obiektów bajtowych, zalecanym idiomem jest rozszerzenie bytearray obiekt wykorzystujący konkatenację in-place (operator+=):

result = bytearray()
for b in my_bytes_objects:
    result += b

Edit: byłem głupi i miałem wyniki wklejone do tyłu, dzięki czemu wyglądało to tak, jakby dodawanie do listy było szybsze niż cStringIO. Dodałem również testy dla bytearray / str concat, a także drugą rundę testów z większą listą z większymi ciągami. (python 2.7.3)

Przykład testu Ipython dla dużych list łańcuchów

try:
    from cStringIO import StringIO
except:
    from io import StringIO

source = ['foo']*1000

%%timeit buf = StringIO()
for i in source:
    buf.write(i)
final = buf.getvalue()
# 1000 loops, best of 3: 1.27 ms per loop

%%timeit out = []
for i in source:
    out.append(i)
final = ''.join(out)
# 1000 loops, best of 3: 9.89 ms per loop

%%timeit out = bytearray()
for i in source:
    out += i
# 10000 loops, best of 3: 98.5 µs per loop

%%timeit out = ""
for i in source:
    out += i
# 10000 loops, best of 3: 161 µs per loop

## Repeat the tests with a larger list, containing
## strings that are bigger than the small string caching 
## done by the Python
source = ['foo']*1000

# cStringIO
# 10 loops, best of 3: 19.2 ms per loop

# list append and join
# 100 loops, best of 3: 144 ms per loop

# bytearray() +=
# 100 loops, best of 3: 3.8 ms per loop

# str() +=
# 100 loops, best of 3: 5.11 ms per loop

Zalecaną metodą jest nadal używanie append I join.

Stosowanie konkatenacji w miejscu przez ' + ' jest najgorszą metodą konkatenacji pod względem stabilności i implementacji krzyżowej, ponieważ nie obsługuje wszystkich wartości. Standard PEP8 zniechęca do tego i zachęca do używania format(), join() i append() do długotrwałego używania.

Jeśli łańcuchy, które konkatenujesz, są literałami, użyj literalnej konkatenacji

re.compile(
        "[A-Za-z_]"       # letter or underscore
        "[A-Za-z0-9_]*"   # letter, digit or underscore
    )

Jest to przydatne, jeśli chcesz skomentować część łańcucha znaków (jak powyżej) lub jeśli chcesz użyć surowych łańcuchów lub potrójnych cudzysłowów dla części literału, ale nie wszystkich.

Ponieważ dzieje się tak w warstwie składni, używa ona zerowych operatorów konkatenacji.

Choć nieco przestarzały, Kod jak Python: Idiomatic Python poleca join() nad + w tej sekcji . Podobnie jak PythonSpeedPerformanceTips w sekcji string concatenation , z następującym zastrzeżeniem:

[[2]}dokładność tej sekcji jest kwestionowana w odniesieniu do późniejszych wersje Pythona. W CPython 2.5 konkatenacja ciągów jest dość szybko, chociaż może to nie dotyczyć również innych Pythonów wdrożenia. Zobacz też ConcatenationTestCode do dyskusji.

W Pythonie > = 3.6, nowy łańcuch f jest efektywnym sposobem łączenia łańcuchów.

>>> name = 'some_name'
>>> number = 123
>>>
>>> f'Name is {name} and the number is {number}.'
'Name is some_name and the number is 123.'

Możesz również użyć tego (bardziej wydajnego). (https://softwareengineering.stackexchange.com/questions/304445/why-is-s-better-than-for-concatenation)

s += "%s" %(stringfromelsewhere)

Piszesz tę funkcję

def str_join(*args):
    return ''.join(map(str, args))

Wtedy możesz zadzwonić gdziekolwiek chcesz

str_join('Pine')  # Returns : Pine
str_join('Pine', 'apple')  # Returns : Pineapple
str_join('Pine', 'apple', 3)  # Returns : Pineapple3

Jak wspomina @JDI dokumentacja Pythona sugeruje użycie str.join lub io.StringIO do łączenia łańcuchów. I mówi, że programista powinien oczekiwać kwadratowego czasu od += W pętli, mimo że jest optymalizacja od Pythona 2.4. Jak ta odpowiedź mówi:

Jeśli Python wykryje, że lewy argument nie ma innych referencji, wywoła realloc, aby uniknąć kopii poprzez zmianę rozmiaru łańcucha znaków. To nie jest coś, na czym powinieneś kiedykolwiek polegać, ponieważ jest to szczegóły implementacji i ponieważ jeśli realloc Kończy się koniecznością częstego przesuwania łańcucha, wydajność i tak spada do O(N^2).

Pokażę przykład prawdziwego kodu, który naiwnie opierał się na += tej optymalizacji, ale nie miał zastosowania. Poniższy kod konwertuje powtarzalne krótkie ciągi na większe kawałki, które mają być używane w zbiorczym API.

def test_concat_chunk(seq, split_by):
    result = ['']
    for item in seq:
        if len(result[-1]) + len(item) > split_by: 
            result.append('')
        result[-1] += item
    return result

Ten kod może działać godzinami ze względu na kwadratową złożoność czasową. Poniżej znajdują się alternatywy z sugerowanymi danymi struktury:

import io

def test_stringio_chunk(seq, split_by):
    def chunk():
        buf = io.StringIO()
        size = 0
        for item in seq:
            if size + len(item) <= split_by:
                size += buf.write(item)
            else:
                yield buf.getvalue()
                buf = io.StringIO()
                size = buf.write(item)
        if size:
            yield buf.getvalue()

    return list(chunk())

def test_join_chunk(seq, split_by):
    def chunk():
        buf = []
        size = 0
        for item in seq:
            if size + len(item) <= split_by:
                buf.append(item)
                size += len(item)
            else:
                yield ''.join(buf)                
                buf.clear()
                buf.append(item)
                size = len(item)
        if size:
            yield ''.join(buf)

    return list(chunk())

I mikro-benchmark:

import timeit
import random
import string
import matplotlib.pyplot as plt

line = ''.join(random.choices(
    string.ascii_uppercase + string.digits, k=512)) + '\n'
x = []
y_concat = []
y_stringio = []
y_join = []
n = 5
for i in range(1, 11):
    x.append(i)
    seq = [line] * (20 * 2 ** 20 // len(line))
    chunk_size = i * 2 ** 20
    y_concat.append(
        timeit.timeit(lambda: test_concat_chunk(seq, chunk_size), number=n) / n)
    y_stringio.append(
        timeit.timeit(lambda: test_stringio_chunk(seq, chunk_size), number=n) / n)
    y_join.append(
        timeit.timeit(lambda: test_join_chunk(seq, chunk_size), number=n) / n)
plt.plot(x, y_concat)
plt.plot(x, y_stringio)
plt.plot(x, y_join)
plt.legend(['concat', 'stringio', 'join'], loc='upper left')
plt.show()

Mój przypadek użycia był nieco inny. Musiałem skonstruować zapytanie, w którym ponad 20 pól było dynamicznych. Zastosowałem metodę formatowania

query = "insert into {0}({1},{2},{3}) values({4}, {5}, {6})"
query.format('users','name','age','dna','suzan',1010,'nda')

To było stosunkowo prostsze dla mnie zamiast używać + lub innych sposobów