How can I use newline '\n' in an f-string to format a list of strings?

Question

I tried this code:

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

However, '\' cannot be used inside the {...} expression portions of an f-string. How can I make it work? The result should be:

Winners are:
Adam
Bob
Cyril

---

_{See Why isn't it possible to use backslashes inside the braces of f-strings? How can I work around the problem? for some additional discussion of why the limitation exists.}

Answer 1

# Using Python 3.12.5
names = ['Adam', 'Bob', 'Cyril']
# Convert list [...] to str '[...]', apply replace method to remove '[', ']' , convert ', ' to '\n' and remove single quotes

name = str(names).replace('[', '').replace(']', '').replace(', ', '\n').replace("'","") 

text = f"Winners are:\n{name}" 

#  \ is not present inside{}

print(text)

# if one step is to be reduced
text = f"Winners are:\n{str(names).replace('[', '').replace(']', '').replace(', ', '\n').replace("'","")}"
print(text)

#here, join method is not used.

Answer 2

Python 3.12+

You can use backslashes within f-strings and the existing code from the question works as expected. See https://docs.python.org/3.12/whatsnew/3.12.html#pep-701-syntactic-formalization-of-f-strings.

Python < 3.12

You can't. Backslashes cannot appear inside the curly braces {}; doing so results in a SyntaxError:

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

This is specified in the PEP for f-strings:

Backslashes may not appear inside the expression portions of f-strings, [...]

One option is assigning '\n' to a name and then .join on that inside the f-string; that is, without using a literal:

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

Results in:

Winners are:
Adam
Bob
Cyril

Another option, as specified by @wim, is to use chr(10) to get \n returned and then join there. f"Winners are:\n{chr(10).join(names)}"

Yet another, of course, is to '\n'.join beforehand and then add the name accordingly:

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

which results in the same output.

Note:

This is one of the small differences between f-strings and str.format. In the latter, you can always use punctuation granted that a corresponding wacky dict is unpacked that contains those keys:

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

_{(Please don't do this.)}

In the former, punctuation isn't allowed because you can't have identifiers that use them.

---

Aside: I would definitely opt for print or format, as the other answers suggest as an alternative. The options I've given only apply if you must for some reason use f-strings.

Just because something is new, doesn't mean you should try and do everything with it ;-)

Answer 3

On Python 3.12+, you can:

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

You can also reuse the same quote in the expression part of an f-string:

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

See PEP 701 for details.

Answer 4

And remember not to use this strange way that also works:

names = ['Adam', 'Bob', 'Cyril']
text = f"""{'''
'''.join(names)}"""
print(text)

Answer 5

If (and only if!) readability is the top priority, and speed is truly not a factor, f-strings are very useful to make a simple function self documenting even if there are simpler ways to program it. Readability is maximized with f-strings when: (1) the statements that change the argument's state are clearly obvious, and (2) when the arguments are printed, the print statement is carefully formatted, and visually presented to make the arguments stand out:

'''
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)

output:

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

Answer 6

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

The above statement will raise SyntaxError, But to avoid the error, you can simply assign the string containing \n to a variable and use it in f-string.

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

Answer 7

You don't need f-strings or other formatters to print a list of strings with a separator. Just use the sep keyword argument to print():

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

Output:

Winners are:
Adam
Bob
Cyril

That said, using str.join()/str.format() here would arguably be simpler and more readable than any f-string workaround:

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

Answer 8

You can't use backslashes in f-strings as others have said, but you could step around this using os.linesep (although note this won't be \n on all platforms, and is not recommended unless reading/writing binary files; see Rick's comments):

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

Or perhaps in a less readable way, but guaranteed to be \n, with chr():

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

Answer 9

The other answers give ideas for how to put the newline character into a f-string field. However, I would argue that for the example the OP gave (which may or may not be indicative of OP's actual use case), none of these ideas should actually be used.

The entire point of using f-strings is increasing code readability. There is nothing you can do with f-strings that you cannot do with format. Consider carefully whether there is anything more readable about this (if you could do it):

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

...or this:

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

...or this:

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

vs. this:

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

The last way is at least as readable, if not more so.

In short: don't use a hammer when you need a screwdriver just because you have a shiny new one. Code is read much more often than it is written.

For other use cases, yes, it's possible the chr(10) idea or newline idea may be appropriate. But not for the one given.