¿Cómo puedo usar la nueva línea ‘\ n’ en una cadena f para formatear la salida?

Probé este código:

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

Sin embargo, '\' no se puede utilizar dentro del {...} partes de expresión de una cadena f. ¿Cómo puedo hacer que funcione? El resultado debería ser:

Winners are:
Adam
Bob
Cyril

_{Consulte ¿Por qué no es posible usar barras invertidas dentro de las llaves de cuerdas f? ¿Cómo puedo solucionar el problema? para una discusión adicional de por qué la limitación existe.}

no puedes Las barras invertidas no pueden aparecer dentro de las llaves {}; hacerlo resulta en un SyntaxError:

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

Esto se especifica en el ENERGÍA para cuerdas f:

Es posible que las barras invertidas no aparezcan dentro de las partes de expresión de f-strings, […]

Una opción es asignar '\n' a un nombre y luego .join en eso dentro de la f-cadena; es decir, sin usar un literal:

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

Resultados en:

Winners are:
Adam
Bob
Cyril

Otra opción, según lo especificado por @wim, es usar chr(10) Llegar \n regresó y luego unirse allí. f"Winners are:\n{chr(10).join(names)}"

Otro, por supuesto, es '\n'.join de antemano y luego agregue el nombre en consecuencia:

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

lo que da como resultado la misma salida.

Nota:

Esta es una de las pequeñas diferencias entre f-cuerdas y str.format. En este último, siempre puede usar la puntuación siempre que se haya desempaquetado un dictado loco correspondiente que contenga esas claves:

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

_{(Por favor, no hagas esto.)}

En el primero, la puntuación no está permitida porque no puede tener identificadores que los usen.

Aparte: definitivamente optaría por print o format, como sugieren las otras respuestas como alternativa. Las opciones que he dado solo se aplican si debe por alguna razón use f-strings.

El hecho de que algo sea nuevo no significa que debas intentar hacer todo con él 😉

No necesita f-strings u otros formateadores para imprimir una lista de cadenas con un separador. solo usa el sep argumento de palabra clave para print():

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

Producción:

Winners are:
Adam
Bob
Cyril

Dicho esto, usando str.join()/str.format() aquí podría decirse que sería más simple y más legible que cualquier solución alternativa de f-string:

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

No puede usar barras invertidas en f-strings como han dicho otros, pero puede evitar esto usando os.linesep (aunque tenga en cuenta que esto no será \n en todas las plataformas, y no se recomienda a menos que lea/escriba archivos binarios; ver los comentarios de Rick):

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

O tal vez de una manera menos legible, pero garantizado para ser \ncon chr():

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

Las otras respuestas dan ideas sobre cómo colocar el carácter de nueva línea en un campo de cadena f. Sin embargo, diría que para el ejemplo que dio OP (que puede o no ser indicativo del caso de uso real de OP), ninguna de estas ideas debería usarse.

El objetivo de usar f-strings es aumentar la legibilidad del código. No hay nada que puedas hacer con f-strings que no puedas hacer con format. Considere cuidadosamente si hay algo más legible sobre esto (si pudieras hacerlo):

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

…o esto:

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

…o esto:

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

contra esto:

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

La última forma es al menos igual de legible, si no más.

En resumen: no use un martillo cuando necesite un destornillador solo porque tiene uno nuevo y brillante. El código se lee mucho más a menudo de lo que se escribe.

Para otros casos de uso, sí, es posible que el chr(10) idea o newline la idea puede ser apropiada. Pero no para el dado.

print(f'{"blah\n"}')

La declaración anterior planteará SyntaxErrorPero para evitar el error, simplemente puede asignar la cadena que contiene \n a una variable y usarla en f-string.

x = "blah\n"
print(f'{x}')

Si (¡y solo si!) la legibilidad es la máxima prioridad, y la velocidad realmente no es un factor, las cadenas f son muy útiles para hacer que una función simple se autodocumente, incluso si hay formas más simples de programarla. La legibilidad se maximiza con f-strings cuando: (1) las declaraciones que cambian el estado del argumento son claramente obvias, y (2) cuando los argumentos se imprimen, la declaración de impresión se formatea cuidadosamente y se presenta visualmente para que los argumentos se destaquen:

'''
function to print out an identification header, consisting
of the programmer supplied title, lastname, and firstname:
''' 
FORMAT_DATE = "%m-%d-%y %H:%M:%S"

date_and_time = datetime.now()
name_line = f"* {lastname}, {firstname}"
title_line = f"* {title}"
date_line = f"* {date_and_time.strftime(FORMAT_DATE)}"
print(name_line
    + '\n'
    + title_line
    + '\n'
    + date_line)

producción:

* Lovelace, Ada
* Bernoulli Numbers algorithm implemented in Python
* 10-28-42 20:13:22