F-strings en Python 3.6

j'aime vraiment creuser dans le style de code et il est intéressant de savoir si à partir de maintenant dans tous les cas, il serait préférable d'utiliser le nouveau style.

j'utilise beaucoup le .format() dans mes projets Python 3.5, et je crains qu'il ne soit déprécié lors des prochaines versions Python à cause de ce nouveau type de string littérales.

>>> name = "Test"
>>> f"My app name is {name}."
'My app name is Test.'

est-ce que la fonction de chaîne formatée vient entièrement remplacer l'ancienne format() ?

je comprends qu'il repose sur l'idée que:

Simple vaut mieux que complexe.

cependant, qu'en est-il des questions de rendement, y a-t-il une différence entre elles? Ou c'est juste une apparence simple de la même fonctionnalité?

25
demandé sur Jim Fasarakis Hilliard 2017-03-30 19:25:20
la source

4 ответов

je crains qu'il ne soit déprécié lors des prochaines versions de Python

Ne pas être str.format n'apparaît pas (ni a une raison) à quitter de si tôt, le PEP, qui a introduit f préfixe-chaînes de même unis dans son Abrégé :

ce PEP ne propose pas de supprimer ou de déprécier la chaîne de caractères existante mécanismes de formatage.

chaînes formatées ont été introduites pour remédier à certains des défauts d'autres méthodes de formatage des chaînes avaient; ne pas jeter les anciennes méthodes et Dieu sait combien de projets à utiliser F-string s'ils veulent que leur code fonctionne pour Python 3.6+.


quant à l'exécution de ceux-ci, il semble que ma suspicion initiale qu'ils pourraient être plus lents est erronée, F-strings semblent résultat supérieur à leurs homologues .format :

➜ cpython git:(master) ./python -m timeit -s "a = 'test'" "f'formatting a string {a}'"
500000 loops, best of 5: 628 nsec per loop
➜ cpython git:(master) ./python -m timeit "'formatting a string {a}'.format(a='test')"
100000 loops, best of 5: 2.03 usec per loop

ceux-ci ont été faits contre la branche principale du dépôt CPython à partir de cette écriture; ils sont certainement sujets à changement:

  • f-strings , comme une nouvelle caractéristique, pourrait avoir optimisations possibles
  • les optimisations vers CPython pourraient rendre .format plus rapide (E. g Speedup method calls 1.2 x )

mais vraiment, ne vous inquiétez pas tellement de la vitesse, souciez-vous de ce qui est plus lisible pour vous et pour les autres.

dans de nombreux cas, ce sera f-strings , mais il y a quelques cas format est mieux.

29
répondu Jim Fasarakis Hilliard 2018-09-27 23:03:47
la source

pour construire sur la réponse de Jim et répondre à vos préoccupations de performance, j'ai utilisé le module dis de python pour comparer les instructions de bytecode pour deux fonctions syntaxiquement différentes, mais fonctionnellement équivalentes.

import dis

def f1():
    a = "test"
    return f"{a}"

def f2():
    return "{a}".format(a='test')

print(dis.dis(f1))
print(dis.dis(f2))

dont Le résultat est:

 11           0 LOAD_CONST               1 ('test')
              2 STORE_FAST               0 (a)

 12           4 LOAD_FAST                0 (a)
              6 FORMAT_VALUE             0
              8 RETURN_VALUE
None
 15           0 LOAD_CONST               1 ('{a}')
              2 LOAD_ATTR                0 (format)
              4 LOAD_CONST               2 ('test')
              6 LOAD_CONST               3 (('a',))
              8 CALL_FUNCTION_KW         1
             10 RETURN_VALUE
None

on peut voir que la f-string gère le formatage sans appel d'attribut ou de fonction, ce qui peut imposer la vérification de type et la mémoire au-dessus. Selon timeit il en résulte un gain de performance d'environ 3x (pour mes fonctions spécifiques)

>>> timeit.timeit('f1()', 'from __main__ import f1', number=100000)
0.012325852433775708
>>> timeit.timeit('f2()', 'from __main__ import f2', number=100000)
0.036395029920726074
20
répondu Aaron 2017-03-30 20:20:35
la source

une chose qui n'est pas mentionnée (ce qui rend impossible la dévalorisation des anciennes techniques) est que l'interpolation ne s'applique qu'à la littérature à cordes. Ce qui signifie que la chaîne est rendue une fois à l'exécution. Le modèle ne peut pas être utilisé à nouveau avec des variables mises à jour, par exemple:

str_template.format(args)

ainsi, de nombreux cas d'utilisation serait impossible sans les anciennes techniques. Profitez de l'interpolation des chaînes de caractères, mais ne l'utilisez pas là où ce n'est pas approprié, c'est-à-dire là où vous avez besoin d'un réutilisable. modèle.

6
répondu Gringo Suave 2017-09-26 01:27:39
la source

si vous voulez continuer à supporter python 3.5, vous pouvez utiliser fstring

pip install fstring

from fstring import fstring

x = 1

y = 2.0

plus_result = "3.0"

print fstring("{x}+{y}={plus_result}")

# Prints: 1+2.0=3.0
1
répondu RinSlow 2018-04-22 09:32:23
la source

Autres questions sur