chaînes f dans Python 3.6

Question

J'ai vraiment envie de plonger dans le code de style 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 l' .format() dans mon Python 3.5 projets, et je crains que cela sera déconseillée au cours de la prochaine versions de Python en raison de ce nouveau type de chaîne de caractères littéraux.

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

La chaîne mise en forme caractéristique de venir à remplacer complètement le vieux - format() ?

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

Simple est mieux que complexe.

Cependant, ce sujet de problèmes de performances, ne fait aucune différence entre eux? Ou est-ce juste un simple coup d'oeil de la même fonction?

Answer 1

Je crains que cela sera déconseillée au cours de la prochaine versions de Python

Ne soyez pas, str.format n'apparaît pas (ni a une raison) à quitter de si tôt, le PEP, qui a introduit fpréfixé chaînes de caractères, même les états dans son Résumé:

Ce PEP ne propose pas de supprimer ou de désapprouver toute existantes de la chaîne de mise en forme des mécanismes.

Formaté chaînes ont été introduites afin de combler certaines lacunes d'autres méthodes pour les chaînes de mise en forme a; ne pas jeter les anciennes méthodes de distance et de la force de dieu sait combien de projets pour l'utilisation de f-string s'ils veulent que leur code de travail pour Python 3.6+.

---

Quant à la performance de ceux-ci, il semble que mon soupçon qu'ils pourraient être plus lent est mauvais, f-cordes semblent facilement surpasser leurs .format homologues:

➜ 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

Ceci a été fait à l'encontre de la branche principale de la Disponible référentiel de cette écriture; ils sont certainement sous réserve de modification:

• f-strings, comme une nouvelle fonctionnalité, pourrait avoir des optimisations possibles
• Les optimisations de Disponible peut faire .format plus vite (e.g l'Accélération de la méthode des appels 1.2 x)

Mais vraiment, ne vous inquiétez pas à propos de la vitesse, donc beaucoup de, se soucier de ce qui est plus lisible pour vous et pour les autres.

Dans de nombreux cas, cela va être f-strings, mais il y a certains cas où l' format , c'est mieux.

Answer 2

Pour construire sur Jim répondre et résoudre votre souci de performances, j'ai utilisé python dis module de comparer le bytecode des instructions pour les deux syntaxiquement différents, mais fonctionnellement équivalent fonctions.

import dis

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

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

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

Le résultat de ce qui 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
Aucun
 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
Aucun

On peut voir que le f-chaîne gère la mise en forme sans attribut ou d'appels de fonction, qui peut imposer la vérification du type et de la surcharge de la mémoire. Selon timeit il en résulte une moins 3x gain de performance (pour mes fonctions spécifiques)

>>> timeit.timeit (f1()', 'à partir de __principaux__ importer f1", number=100000)
0.012325852433775708
>>> timeit.timeit('f2()', 'à partir de __principaux__ importer f2', nombre=100000)
0.036395029920726074

Answer 3

Une chose n'a pas mentionné (ce qui fait de la dépréciation de la techniques anciennes est impossible), c'est que l'interpolation est pour les littéraux de chaîne seulement. Sens, la chaîne est rendu une fois au moment de l'exécution. Le modèle ne peut pas être utilisé à nouveau avec la mise à jour des variables, par exemple:

str_template.format(args)

Un autre cas est i18n, où la chaîne.Le modèle est utilisé. De nombreux cas d'utilisation serait impossible sans les techniques plus anciennes. Profitez de la chaîne d'interpolation, mais ne l'utilisez pas, où il n'est pas approprié, c'est à dire des endroits où vous avez besoin d'un modèle réutilisable.

Answer 4

Si vous souhaitez continuer à prendre en charge 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