Au moment de poser cette question, j'utilise Python 3.8
Quand je dis efficace, je me réfère uniquement à la vitesse à laquelle les chaînes sont concaténées, ou en termes plus techniques: je pose la question de la complexité du temps, pas de la prise en compte de la complexité de l'espace.
Les seules méthodes auxquelles je peux penser pour le moment sont les 3 suivantes étant donné que:
>>> import timeit
>>> print(timeit.Timer('result = a + b', setup='a = "start"; b = " end"').timeit(number=10000))
0.0005306000000473432
>>> print(timeit.Timer('result = "".join((a, b))', setup='a = "start"; b = " end"').timeit(number=10000))
0.0011297000000354274
>>> print(timeit.Timer('result = "{0}{1}".format(a, b)', setup='a = "start"; b = " end"').timeit(number=10000))
0.002327799999989111
>>> print(timeit.Timer('result = f"{a}{b}"', setup='a = "start"; b = " end"').timeit(number=10000))
0.0005772000000092703
>>> print(timeit.Timer('result = "%s%s" % (a, b)', setup='a = "start"; b = " end"').timeit(number=10000))
0.0017815999999584164
Méthode 1
result = a + b
Méthode 2
result = ''.join((a, b))
Méthode 3
result = '{0}{1}'.format(a, b)
Je veux savoir lesquelles de ces méthodes sont les plus rapides ou s'il existe d'autres méthodes plus efficaces. De plus, si vous savez si l'une de ces méthodes fonctionne différemment avec plus de chaînes ou des chaînes plus longues, veuillez l'inclure dans votre réponse.
Éditer
Après avoir vu tous les commentaires et réponses, j'ai appris quelques nouvelles façons de concaténer des chaînes, et j'ai également découvert la bibliothèque timeit . Je rapporterai mes conclusions personnelles ci-dessous:
a = 'start' b = ' end'
Il semble que pour ces petites chaînes, la méthode traditionnelle a + b soit la plus rapide pour la concaténation de chaînes. Merci pour toutes les réponses!
3 Réponses :
Pour exactement deux chaînes a et b , utilisez simplement a + b . Les alternatives sont pour joindre plus de 2 chaînes, en évitant l'objet str temporaire créé par chaque utilisation de + , ainsi que le comportement quadratique dû à la copie répétée du contenu des opérations précédentes dans le résultat suivant.
(Il y a aussi f'{a}{b}' , mais il est syntaxiquement plus lourd et pas plus rapide que a + b .)
Pourquoi ne pas l'essayer? Vous pouvez utiliser timeit.timeit () pour exécuter une instruction plusieurs fois et renvoyer la durée globale.
Ici, nous utilisons s pour configurer les variables a et b (non incluses dans le temps global), puis exécutons les différentes options 10 millions de fois.
>>> from timeit import timeit
>>>
>>> n = 10 * 1000 * 1000
>>> s = "a = 'start'; b = ' end'"
>>>
>>> timeit("c = a + b", setup=s, number=n)
0.4452877212315798
>>>
>>> timeit("c = f'{a}{b}'", setup=s, number=n)
0.5252049304544926
>>>
>>> timeit("c = '%s%s'.format(a, b)", setup=s, number=n)
0.6849184390157461
>>>>
>>> timeit("c = ''.join((a, b))", setup=s, number=n)
0.8546998891979456
>>>
>>> timeit("c = '%s%s' % (a, b)", setup=s, number=n)
1.1699129864573479
>>>
>>> timeit("c = '{0}{1}'.format(a, b)", setup=s, number=n)
1.5954962372779846
Cela montre qu'à moins que le goulot d'étranglement de votre application ne soit la concaténation de chaînes, cela ne vaut probablement pas la peine d'être trop préoccupé par ...
Si vous effectuez littéralement des millions d'opérations, vous constaterez une amélioration de la vitesse d'environ 1 seconde.
Notez que vos résultats peuvent varier considérablement en fonction de la longueur (et du nombre) des chaînes que vous concaténez et du matériel sur lequel vous utilisez.
print(f'{a} {b}')
Faites attention! Effectuer l'opération une seule fois introduira un bruit inutile - par exemple, vous constaterez probablement que la plupart de votre temps ici est passé à l'arrière de datetime.now() , print() et à l'avant de datetime.now() , plutôt que la concaténation de chaînes que vous aviez l'intention de mesurer (environ nanosecondes, par rapport aux microsecondes que vous signalez). .join() et .format() ne sont pas plus rapides que + .
utilisez timeit ou horlogerie pour obtenir une mesure!
Vous devez profiler différentes méthodes et rapporter vos résultats pour aider les autres.
voir s'il y a un décalage horaire entre la méthode 3 et f "{a} {b}" aussi
Notez que chaque fois que les tests que vous pouvez effectuer sont sensibles à la longueur de chaque chaîne.