Puis-je importer des littéraux de chaîne formatés (chaînes f) de Python 3.6 dans des Python 3.x, 2.x plus anciens?

Question

La nouvelle Python 3.6 f-chaînes sembler comme un grand saut dans la chaîne de convivialité pour moi, et je voudrais sauter dans et de les adopter sans réserve sur de nouveaux projets qui pourraient être en cours d'exécution sur les anciens interprètes. 2.7, 3.3-3.5 soutien serait bien, mais à tout le moins, je voudrais profiter de ces en Python 3.5 bases de code. Comment puis-je importer 3.6 mettre en forme les littéraux de chaîne pour une utilisation par les anciens interprètes?

Je comprends que formaté littéraux de chaîne comme f"Foo is {age} {units} old" ne sont pas des modifications importantes, et ne seraient donc pas être inclus dans un from __future__ import ... appel. Mais le changement n'est pas de retour-porté (autant que je sache) j'aurais besoin pour être sûr que quelque soit le code que j'ai écris avec le f-chaînes est seulement couru sur Python 3.6+, qui est un briseur d'affaire pour un grand nombre de projets.

Answer 1

future-fstrings apporte des chaînes f aux scripts Python 2.7. (Et je suppose que 3.3-3.5 basé sur la documentation.)

Une fois que vous l'avez installé via pip install future-fstrings , vous devez placer une ligne spéciale en haut de votre code. Cette ligne est:

 # -*- coding: future_fstrings -*-
 

Ensuite, vous pouvez utiliser des littéraux de chaîne formatés (chaînes f) dans votre code:

 # -*- coding: future_fstrings -*-
var = 'f-string'
print(f'hello world, this is an {var}')
 

Answer 2

Malheureusement, si vous souhaitez l'utiliser, vous devez exiger Python 3.6+, même avec la multiplication de matrice de l'opérateur @ et Python 3.5+ ou yield from (Python 3.4+ je crois)

Ces modifications apportées à la façon dont le code est interprété et donc jeter SyntaxErrors lorsqu'ils sont importés dans les anciennes versions. Cela signifie que vous devez les mettre quelque part où ils ne sont pas importés dans les anciennes Pythons ou gardés par un eval ou exec (que je ne recommande pas les deux derniers!).

Donc, oui, vous avez raison, si vous voulez en charge plusieurs versions de python, vous ne pouvez pas les utiliser facilement.

Answer 3

voici ce que j'utilise:

 text = "Foo is {age} {units} old".format(**locals())
 

il décompresse ( ** ) le dict retourné par locals() qui a toutes vos variables locales comme dict {variable_name: value}

Notez que cela ne fonctionnera pas pour les variables déclarées dans une portée externe, sauf si vous l'importez dans la portée locale avec nonlocal (Python 3.0+).

vous pouvez aussi utiliser

 text.format(**locals(),**globals())
 

pour inclure des variables globales dans votre chaîne.

Answer 4

Les chaînes f sont créées par l'interpréteur lors du lancement du préfixe f - cette fonctionnalité à elle seule éliminera toutes les chances de compatibilité.

Votre plan le plus proche consiste à utiliser la mise en forme des mots clés, comme

 'Foo is {age} {units} old'.format(age=age, units=units)
 

qui peut être plus facilement refactorisé à la fin de l'exigence de compatibilité.

Answer 5

Je viens d'écrire un arrière-port compilateur pour f-chaîne, appelés f2format. Comme vous le demande, vous pouvez écrire f-chaîne de caractères littéraux en Python 3.6 saveur, et de les compiler en une version compatible pour les utilisateurs d'exécuter, comme Babel pour le JavaScript.

f2format fournit un d'intelligent, encore imparfaite, d'une solution d'un arrière-port du compilateur. Il doit remplacer les f-chaîne de caractères littéraux avec str.format méthodes, tout en conservant la mise en page originale de code source. Vous pouvez simplement utiliser

f2format /path/to/the/file_or_directory

qui va réécrire tous les fichiers Python en place. Par exemple,

var = f'foo{(1+2)*3:>5}bar{"a", "b"!r}boo'

seront convertis en

var = ('foo{:>5}bar{!r}boo').format(((1+2)*3), ("a", "b"))

La concaténation de chaîne, la conversion, la spécification de format, multi-lignes et unicodes sont tous traités de la droite. Aussi, f2format archive des fichiers d'origine dans le cas où il y a toute la syntaxe des violations.