Comment utiliser la nouvelle ligne '\ n' dans la chaîne f pour formater la sortie en Python 3.6?

J'aimerais savoir comment formater ce boîtier de manière pythonique avec des f-strings:

names = ['Adam', 'Bob', 'Cyril']
text = f"Winners are:\n{'\n'.join(names)}"
print(text)

Le problème est qu'il '\'ne peut pas être utilisé dans les {...}parties d'expression d'une chaîne f. Production attendue:

Winners are:
Adam
Bob
Cyril

Vous ne pouvez pas. Les barres obliques inverses ne peuvent pas apparaître à l'intérieur des accolades {}; cela se traduit par SyntaxError:

>>> f'{\}'
SyntaxError: f-string expression part cannot include a backslash

Ceci est spécifié dans le PEP pour les chaînes f:

Les barres obliques inverses peuvent ne pas apparaître dans les parties d'expression des chaînes f, [...]

Une option consiste à attribuer '\n'un nom, puis .joinà celui-ci dans la fchaîne -string; c'est-à-dire sans utiliser de littéral:

names = ['Adam', 'Bob', 'Cyril']
nl = '\n'
text = f"Winners are:{nl}{nl.join(names)}"
print(text)

Résulte en:

Winners are:
Adam
Bob
Cyril

Une autre option, telle que spécifiée par @wim, consiste à utiliser chr(10)pour être \nrenvoyé, puis à y rejoindre.f"Winners are:\n{chr(10).join(names)}"

Encore une autre, bien sûr, consiste à '\n'.joinajouter au préalable le nom en conséquence:

n = "\n".join(names)
text = f"Winners are:\n{n}"

ce qui donne le même résultat.

Remarque:

C'est l'une des petites différences entre f-strings et str.format. Dans ce dernier, vous pouvez toujours utiliser la ponctuation à condition qu'un dict loufoque correspondant soit décompressé qui contient ces clés:

>>> "{\\} {*}".format(**{"\\": 'Hello', "*": 'World!'})
"Hello World!"

_{(Veuillez ne pas faire ça.)}

Dans le premier cas, la ponctuation n'est pas autorisée car vous ne pouvez pas avoir d'identificateurs qui les utilisent.

À part: j'opterais certainement pour printou format, comme le suggèrent les autres réponses comme alternative. Les options que j'ai données ne s'appliquent que si vous devez pour une raison quelconque utiliser des chaînes f.

Ce n'est pas parce que quelque chose est nouveau que vous devriez essayer de tout faire avec ;-)

Vous n'avez pas besoin de chaînes f ou d'autres formateurs pour imprimer une liste de chaînes avec un séparateur. Utilisez simplement l' separgument mot - clé pour print():

names = ['Adam', 'Bob', 'Cyril']
print('Winners are:', *names, sep='\n')

Production:

Winners are:
Adam
Bob
Cyril

Cela dit, utiliser str.join()/str.format() here serait sans doute plus simple et plus lisible que toute solution de contournement de chaîne f:

print('\n'.join(['Winners are:', *names]))
print('Winners are:\n{}'.format('\n'.join(names)))

Vous ne pouvez pas utiliser de barres obliques inverses dans les chaînes f comme d'autres l'ont dit, mais vous pouvez contourner cela en utilisant os.linesep(bien que notez que cela ne sera pas \nsur toutes les plates-formes et n'est pas recommandé à moins de lire / écrire des fichiers binaires; voir les commentaires de Rick ):

>>> import os
>>> names = ['Adam', 'Bob', 'Cyril']
>>> print(f"Winners are:\n{os.linesep.join(names)}")
Winners are:
Adam
Bob
Cyril 

Ou peut-être d'une manière moins lisible, mais garantie d'être \n, avec chr():

>>> print(f"Winners are:\n{chr(10).join(names)}")
Winners are:
Adam
Bob
Cyril

Les autres réponses donnent des idées sur la façon de mettre le caractère de nouvelle ligne dans un champ de chaîne f. Cependant, je dirais que pour l'exemple donné par l'OP (qui peut ou non être indicatif du cas d'utilisation réel de l'OP), aucune de ces idées ne devrait réellement être utilisée.

L'intérêt de l'utilisation de chaînes f est d'augmenter la lisibilité du code. Il n'y a rien que vous puissiez faire avec des chaînes f que vous ne pouvez pas faire format. Examinez attentivement s'il y a quelque chose de plus lisible à ce sujet (si vous pouviez le faire):

f"Winners are:\n{'\n'.join(names)}"

...ou ca:

newline = '\n'
f"Winners are:\n{newline.join(names)}"

...ou ca:

"Winners are:\n{chr(10).join(names)}"

vs ceci:

"Winners are:\n{}".format('\n'.join(names))

Le dernier moyen est au moins aussi lisible, sinon plus.

En bref: n'utilisez pas de marteau lorsque vous avez besoin d'un tournevis simplement parce que vous en avez un neuf brillant. Le code est lu beaucoup plus souvent qu'il n'est écrit.

Pour d'autres cas d'utilisation, oui, il est possible que l' chr(10)idée ou l' newlineidée soit appropriée. Mais pas pour celui donné.