Qui est le meilleur moyen pour concaténer une chaîne de caractères en Python?

La meilleur façon d'ajouter une chaîne à une variable de chaîne est d'utiliser + ou +=. C'est parce que c'est lisible et rapide. Ils sont également tout aussi rapide, celle que vous choisissez est une question de goût, le dernier est le plus commun. Voici les timings avec le timeit module:

a = a + b:
0.11338996887207031
a += b:
0.11040496826171875

Cependant, ceux qui recommandent de faire des listes et en les ajoutant à eux et ensuite se joindre à ces listes, le faire parce que ajoutant une chaîne à une liste est sans doute très rapide par rapport à l'extension d'une chaîne de caractères. Et cela peut être vrai dans certains cas. Ici, par exemple, est un
millions ajoute d'une chaîne d'un caractère, d'abord dans une chaîne de caractères, puis à une liste:

a += b:
0.10780501365661621
a.append(b):
0.1123361587524414

OK, il s'avère que, même si la chaîne résultante est d'un million de caractères, en ajoutant a été encore plus rapide.

Essayons maintenant avec l'ajout d'un millier de caractères chaîne longue d'une centaine de milliers de fois:

a += b:
0.41823482513427734
a.append(b):
0.010656118392944336

La fin de la chaîne, par conséquent, finit par être d'environ 100 mo de long. C'était assez lent, en ajoutant à une liste a été beaucoup plus rapide. Que ce calendrier n'inclut pas la finale a.join(). Alors combien de temps cela prendrait-il?

a.join(a):
0.43739795684814453

Oups. S'avère même dans ce cas, ajouter/jointure est plus lent.

D'où vient donc cette recommandation vient? Python 2?

a += b:
0.165287017822
a.append(b):
0.0132720470428
a.join(a):
0.114929914474

Bien, ajouter/join est légèrement plus rapide si vous utilisez de très longues chaînes (qui ne sont pas habituellement, qu'auriez-vous une chaîne de 100 MO en mémoire?)

Mais le facteur décisif est Python 2.3. Où je ne vais même pas vous montrer les timings, parce que c'est tellement lent qu'il n'est pas encore fini. Ces tests prennent soudainement minutes. Sauf pour l'ajout/la rejoindre, ce qui est tout aussi rapide que sous plus tard Pythons.

Yup. La concaténation de chaîne a été très lente en Python depuis l'âge de pierre. Mais sur 2.4 il n'est pas plus (ou au moins Python 2.4.7), de sorte que la recommandation de l'utilisation de ajout/join est devenu obsolète en 2008, quand Python 2.3 cessé d'être mis à jour, et vous devriez avoir cessé de l'utiliser. 🙂

(Mise à jour: s'avère quand j'ai fait le test avec plus de soin qu'à l'aide de + et += est plus rapide pour les deux chaînes sur Python 2.3 ainsi. La recommandation d'utiliser ''.join() doit être un malentendu)

Cependant, ce n'est Disponible. D'autres implémentations peuvent avoir d'autres préoccupations. Et c'est juste encore une autre raison pourquoi l'optimisation prématurée est la racine de tous les maux. Ne pas utiliser une technique qui est censé "plus vite", sauf si vous la mesurer.

Donc la "meilleure" version pour faire la concaténation de chaîne est d'utiliser + ou +=. Et si cela s'avère être lent pour vous, ce qui est assez rare, alors faites quelque chose d'autre.

Alors, pourquoi faire j'ai utiliser beaucoup de ajouter/rejoindre dans mon code? Parce que parfois, c'est plus clair. Surtout quand tout ce que vous devez concaténer doivent être séparés par des espaces ou des virgules ou des retours à la ligne.

En Python >= 3.6, la nouvelle f-chaîne est un moyen efficace pour concaténer une chaîne de caractères.

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

Si les cordes sont la concaténation sont des littéraux, utilisez Un littéral de chaîne de concaténation

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

Ceci est utile si vous voulez faire des commentaires sur une partie d'une chaîne (comme ci-dessus), ou si vous souhaitez utiliser chaînes brutes ou triple devis pour une partie d'un littéral mais pas tous.

Depuis ce qui se passe au niveau de la syntaxe de la couche, il utilise zéro des opérateurs de concaténation.

Un peu daté, Code Comme un Pythonista: Idiomatiques Python recommande join() sur + dans cette section. Comme PythonSpeedPerformanceTips dans son article sur la concaténation de chaîne, avec l'avertissement suivant:

L'exactitude de cette section est contestée à l'égard de plus tard
les versions de Python. Dans Disponible de 2,5, de concaténation de chaîne est assez
rapide, même si cela peut ne pas s'appliquer aussi à d'autres Python
les implémentations. Voir ConcatenationTestCode pour une discussion.

Comme @jdi mentionne la documentation Python suggère d'utiliser des str.join ou io.StringIO pour la concaténation de chaîne. Et dit qu'un développeur doit s'attendre quadratique du temps de += dans une boucle, même si il y a une optimisation depuis Python 2.4. Comme cette réponse dit:

Si Python détecte que la gauche argument n'a pas d'autres références, il appelle realloc pour tenter d'éviter une copie par le redimensionnement de la chaîne en place. Ce n'est pas quelque chose que vous devez jamais compter sur, parce que c'est un détail d'implémentation, et parce que si realloc finit par avoir besoin de déplacer la chaîne fréquemment, les performances se dégradent à O(n^2), de toute façon.

Je vais vous montrer un exemple de code qui naïvement invoqué += cette optimisation, mais il ne s'applique pas. Le code ci-dessous convertit un objet iterable chaînes courtes dans les gros morceaux à être utilisé dans un en vrac.

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

Ce code peut littéraire courir pendant des heures en raison de la complexité quadratique du temps. Ci-dessous sont des solutions de rechange aux suggestions de structures de données:

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

Et un micro-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()

Vous pouvez l'utiliser(la plus efficace) trop. (https://softwareengineering.stackexchange.com/questions/304445/why-is-s-better-than-for-concatenation)

s += "%s" %(stringfromelsewhere)