Les chaînes de Format vs concaténation

Je vois beaucoup de personnes utilisant le format des chaînes de caractères comme ceci:

root = "sample"
output = "output"
path = "{}/{}".format(root, output)

Au lieu de simplement la concaténation de chaînes de caractères comme ceci:

path = root + '/' + output

Ne les chaînes de format de meilleures performances ou est-ce juste pour le look?

Je dirais qu'ils ont de moins bonnes performances. Mais je préfère encore les chaînes de format dans la non-performance des endroits critiques.
Double Possible de Python mise en forme de chaîne: % vs concaténation

OriginalL'auteur wjk2a1 | 2016-08-02

python string-formatting

C'est juste pour le look. Vous pouvez voir en un coup d'œil ce que le format est. Beaucoup d'entre nous aiment la lisibilité de mieux que de micro-optimisation.

Voyons ce que IPython est %timeit dit:

Python 3.7.2 (default, Jan  3 2019, 02:55:40)
IPython 5.8.0
Intel(R) Core(TM) i5-4590T CPU @ 2.00GHz

In [1]: %timeit root = "sample"; output = "output"; path = "{}/{}".format(root, output)
The slowest run took 12.44 times longer than the fastest. This could mean that an intermediate result is being cached.
1000000 loops, best of 5: 223 ns per loop

In [2]: %timeit root = "sample"; output = "output"; path = root + '/' + output
The slowest run took 13.82 times longer than the fastest. This could mean that an intermediate result is being cached.
10000000 loops, best of 5: 101 ns per loop

In [3]: %timeit root = "sample"; output = "output"; path = "%s/%s" % (root, output)
The slowest run took 27.97 times longer than the fastest. This could mean that an intermediate result is being cached.
10000000 loops, best of 5: 155 ns per loop

In [4]: %timeit root = "sample"; output = "output"; path = f"{root}/{output}"
The slowest run took 19.52 times longer than the fastest. This could mean that an intermediate result is being cached.
10000000 loops, best of 5: 77.8 ns per loop

A noter que depuis Python 3.6, vous pouvez utiliser path = "{racine}/{sortie}" qui est assez simple...
vous avez besoin d'un f en face d'elle, mais oui.

OriginalL'auteur kay

9

Comme avec la plupart des choses, il y aura une différence de performance, mais demandez-vous "est-il vraiment si c'est ns plus vite?". Le root + '/' output méthode est rapide et facile à saisir. Mais cela peut être difficile de se lire très vite lorsque vous avez plusieurs variables à imprimer
```
foo = "X = " + myX + " | Y = " + someY + " Z = " + Z.toString()
```
vs
```
foo = "X = {} | Y= {} | Z = {}".format(myX, someY, Z.toString())
```
Qui est plus facile à comprendre ce qui se passe? À moins que vous vraiment besoin de eak de la performance, choisi la voie qui sera plus facile pour les gens à lire et à comprendre

OriginalL'auteur FuriousGeorge
7

Chaîne de format est libre de type de données lors de la liaison de données. Alors que dans la concaténation nous devons type de fonte ou de convertir les données en conséquence.

Par exemple:
```
a = 10
b = "foo"
c = str(a) + " " + b
print c
> 10 foo
```
Il pourrait être réalisée par mise en forme de chaîne:
```
a = 10
b = "foo"
c = "{} {}".format(a, b)
print c
> 10 foo
```
Tels que, avec-dans les espaces réservés {} {}, nous supposons que les deux choses sont encore à venir c'est à dire, dans ce cas, sont a et b.

C'est la raison je voudrais utiliser .format, il évite les erreurs comme Cannot concatenate 'str' and 'int' objects

OriginalL'auteur Half Genius
7

Ce n'est pas seulement pour les "looks", ou, pour puissant lexicale conversions de type; c'est également un must pour l'internationalisation.

Vous pouvez changer de chaîne de format en fonction de ce que la langue est sélectionnée.

Avec une longue ligne de concaténations de chaîne de boulangerie dans le code source, cela devient effectivement impossible de le faire correctement.

OriginalL'auteur Lightness Races in Orbit

Je suis d'accord que la mise en forme est principalement utilisé pour des raisons de lisibilité, mais depuis la sortie de f-chaînes en 3.6, les tables ont tourné en termes de performances. Il est aussi de mon avis que le f-les cordes sont plus lisible et maintenable car 1) ils peuvent être lus de gauche à droite comme la plupart de texte normal et 2) l'espacement des handicaps liés de concaténation sont évitées car les variables sont dans les cordes.

L'exécution de ce code:

from timeit import timeit

runs = 1000000


def print_results(time, start_string):
    print(f'{start_string}\n'
          f'Total: {time:.4f}s\n'
          f'Avg: {(time/runs)*1000000000:.4f}ns\n')


t1 = timeit('"%s, %s" % (greeting, loc)',
            setup='greeting="hello";loc="world"',
            number=runs)
t2 = timeit('f"{greeting}, {loc}"',
            setup='greeting="hello";loc="world"',
            number=runs)
t3 = timeit('greeting + ", " + loc',
            setup='greeting="hello";loc="world"',
            number=runs)
t4 = timeit('"{}, {}".format(greeting, loc)',
            setup='greeting="hello";loc="world"',
            number=runs)

print_results(t1, '% replacement')
print_results(t2, 'f strings')
print_results(t3, 'concatenation')
print_results(t4, '.format method')

les rendements de ce résultat sur ma machine:

% replacement
Total: 0.3044s
Avg: 304.3638ns

f strings
Total: 0.0991s
Avg: 99.0777ns

concatenation
Total: 0.1252s
Avg: 125.2442ns

.format method
Total: 0.3483s
Avg: 348.2690ns

Une semblable réponse à une autre question est donnée sur cette réponse.

OriginalL'auteur Eric Ed Lohmar

4

De Python 3.6 vous pouvez faire chaîne littérale de l'interpolation par prepeding f à la chaîne:
```
root = "sample"
output = "output"
path = f"{root}/{output}"
```
OriginalL'auteur Cyzanfar
2

C'est pour des regards et de la maintenance du code. C'est vraiment plus facile de modifier votre code si vous avez utilisé le format. Aussi lorsque vous utilisez +, vous risquez de manquer les détails comme les espaces. Utiliser le format pour votre et possible responsable de la bonne.

OriginalL'auteur Doruk

Vous devez vous connecter pour publier un commentaire.