Quelle est la méthode de concaténation de chaînes la plus efficace en python?

Question

Est-il efficace masse de concaténation de chaîne de la méthode en Python (comme StringBuilder en C# ou StringBuffer en Java)? J'ai trouvé des méthodes suivantes ici:

• Simple concaténation de l'utilisation de '+'
• À l'aide de liste de chaînes et de rejoindre méthode
• À l'aide de UserString de MutableString module
• À l'aide de tableau de caractères et de la matrice de module
• À l'aide de cStringIO de StringIO module

Mais que faites-vous des experts de l'utilisation ou de suggérer, et pourquoi?

[Une question connexe ici]

Answer 1

Vous pouvez être intéressé par ceci: Un optimiztion anecdote par Guido. Bien qu'il est bon de rappeler aussi que c'est un vieil article et il est antérieur à l'existence de choses comme ''.join (bien que je suppose string.joinfields est plus ou moins la même chose)

Sur la force, l' array module peut être plus rapide si vous pouvez incorporer à votre problème. Mais ''.join est probablement assez rapide et a l'avantage d'être idiomatiques et donc plus facile pour les autres de python pour les programmeurs à comprendre.

Enfin, la règle d'or de l'optimisation: ne pas optimiser, sauf si vous savez vous en avez besoin, et de mesurer plutôt que de deviner.

Vous pouvez mesurer les différentes méthodes à l'aide de l' timeit module. Qui peut dire à vous qui est le plus rapide, à la place de l'aléatoire des étrangers sur internet faire des suppositions.

Answer 2

''.join(sequenceofstrings) est ce qui fonctionne habituellement le mieux - le plus simple et le plus rapide.

Answer 3

Cela dépend de ce que vous faites.

Après Python 2.5, la concaténation de chaînes avec l'opérateur + est assez rapide. Si vous êtes juste de la concaténation d'un couple de valeurs, à l'aide de l'opérateur + qui fonctionne le mieux:

>>> x = timeit.Timer(stmt="'a' + 'b'")
>>> x.timeit()
0.039999961853027344

>>> x = timeit.Timer(stmt="''.join(['a', 'b'])")
>>> x.timeit()
0.76200008392333984

Cependant, si vous mettez ensemble une chaîne de caractères dans une boucle, il est préférable d'utiliser la liste de rejoindre méthode:

>>> join_stmt = """
... joined_str = ''
... for i in xrange(100000):
...   joined_str += str(i)
... """
>>> x = timeit.Timer(join_stmt)
>>> x.timeit(100)
13.278000116348267

>>> list_stmt = """
... str_list = []
... for i in xrange(100000):
...   str_list.append(str(i))
... ''.join(str_list)
... """
>>> x = timeit.Timer(list_stmt)
>>> x.timeit(100)
12.401000022888184

...mais c'est un avis que vous devez être en train de réunir un nombre relativement élevé de chaînes avant la différence est notable.

Answer 4

il dépend de la taille relative de la nouvelle chaîne après chaque nouvelle concaténation. Avec l' + - opérateur, pour chaque concaténation d'une nouvelle chaîne est faite. Si l'intermédiaire des chaînes sont relativement long, l' + devient de plus en plus lente car le nouvel intermédiaire de la chaîne est stockée.

Considérons cet exemple:

from time import time
stri=''
a='aagsdfghfhdyjddtyjdhmfghmfgsdgsdfgsdfsdfsdfsdfsdfsdfddsksarigqeirnvgsdfsdgfsdfgfg'
l=[]
#case 1
t=time()
for i in range(1000):
    stri=stri+a+repr(i)
print time()-t

#case 2
t=time()
for i in xrange(1000):
    l.append(a+repr(i))
z=''.join(l)
print time()-t

#case 3
t=time()
for i in range(1000):
    stri=stri+repr(i)
print time()-t

#case 4
t=time()
for i in xrange(1000):
    l.append(repr(i))
z=''.join(l)
print time()-t

Résultats

1 0.00493192672729

2 0.000509023666382

3 0.00042200088501

4 0.000482797622681

Dans le cas 1 et 2, nous avons ajouter une chaîne de grande taille, et join() effectue environ 10 fois plus rapide. Dans les cas 3 et 4, nous ajoutons une petite chaîne, et '+' effectue légèrement plus rapide

Answer 5

Cette URL contient les comparaisons des différentes approches et des analyses comparatives:

http://skymind.com/~ocrow/python%5Fstring/