Understanding Python f-string – AskPython

Debug prints all repeat the same chore, because the variable name gets typed once as a label and once as the value. The f-string shorthand prints both from a single expression, so the label can never drift out of sync with the data.

I ran every example below on Python 3.11, and one of my own lines failed before the article even started. That failure earned a section of its own, since the missing colon behind it catches everyone exactly once.

Values inside strings without the plumbing

Prefix a string with f and anything inside braces gets evaluated when the line runs. Names, arithmetic, and calls all work there, and the result lands in the text with no positional arguments to line up.

name = 'Aarav'
score = 92
print(f'{name} scored {score}')

The tutorial defines them the same way, with expressions in braces inside an f-prefixed string and an optional specifier controlling the appearance.

What your Python needs for every example

Three version lines decide which sections apply to you. Everything here ran on 3.11, and the one newer feature is marked instead of silently included.

• Python 3.6 or later for basic interpolation and format specs
• Python 3.8 or later for the equals-sign debug shorthand
• Python 3.12 or later for reusing the same quote inside braces, which stays out of the examples below

Formatting with f-strings

Five moves cover nearly all daily use, arranged from the one you will type most to the one that saves whole debugging sessions. Each block below is the actual interpreter output.

Put variables straight into the text

Names sit where they belong and the placeholders vanish. Compared with format, there is no second list of arguments whose order can silently rotate.

print(f'{"nested".upper()}')
print(f'Multiplication: { 10 * 10 }')

NESTED
Multiplication: 100

Spaces inside the braces are ignored. Room around an expression changes nothing, and method calls with arithmetic evaluate in place exactly as written.

Round and align with a format spec

A colon after the expression opens the format spec, which controls decimals, width, and alignment. I rounded pi and lined up a small table with it.

import math
print(f'The value of pi is approximately {math.pi:.3f}.')
table = {'Aarav': 4127, 'Diya': 4098}
for n, ph in table.items():
    print(f'{n:8} {ph:>6}')

The value of pi is approximately 3.142.
Aarav      4127
Diya       4098

The spec after the colon follows the same mini-language as format, so knowledge transfers both ways. Width first, precision after the dot, and the letter picks the presentation.

Debug with the equals sign

An equals sign before the closing brace prints the expression text, then the value. This is the shorthand Stack Overflow readers keep asking about, and it removes the label-value duplication from every debug line.

x = 10
print(f'{x=}')
print(f'{x * 3 + 1=}')
print(f'{math.pi=:.2f}')

x=10
x * 3 + 1=31
math.pi=3.14

The debug sign composes with the format spec, though the colon stays mandatory between them. My first attempt dropped it and the interpreter refused the line, which is documented in the failure section with the exact message.

Convert with the exclamation mark

An exclamation mark picks the conversion: s for str, r for repr, a for ascii. The repr form shows quotes around strings, which exposes the empty-versus-blank confusion during debugging.

print(f'{str(42)!r} {chr(8364)}')
val = 7
print(f'{val:04d} {val:#x}')

Feed dicts, dates, and function calls

Anything an expression can reach works inside the braces. I pulled dictionary values, formatted a date, called a plain function and a lambda, and prefixed a raw string in one run.

d = {'name': 'Aarav', 'city': 'Pune'}
print(f"{d['name']} lives in {d['city']}")
import datetime as dt
print(f"{dt.date(2026, 9, 14):%B %d, %Y}")
def mult(a, b):
    return a * b
print(f'{mult(10, 20)}')
print(f'{(lambda a, b: a * b)(6, 7)}')

Aarav lives in Pune
September 14, 2026
200
42

Dictionary access needs the opposite quote from the outer string on current Python. Double quotes outside with single quotes inside runs, while the same quote twice fails until 3.12.

s = 'path\\nname'
print(fr'{s} done')

Where f-strings complain

Both failures below are mine, run on the same interpreter as the successes. Each message points at a precise position, and the fix sits beside it.

I wrote this exact line first and kept the error, because dropping the colon between the debug sign and the spec breaks parsing.

import math
print(f'{math.pi=.2f}')

SyntaxError: f-string: expecting '}'

Reusing the outer quote inside the braces fails on 3.11 for the same family of reasons. The interpreter stops at the inner bracket with no useful guess.

d = {"city": "Pune"}
print(f'{d['city']}')

SyntaxError: f-string: unmatched '['

Both errors and their fixes in one place for quick reference.

What you have now

You can interpolate any expression, shape it with a spec, and debug with the equals sign, plus you know the two quote traps by their messages. The old percent and format styles still run, so the remaining question is when to prefer the new one.

Readability decides most cases, since the value sits where it appears instead of in a trailing argument list. I timed all three on 200,000 iterations and the numbers below are the actual runs, so the readable choice costs nothing either.

Frequently asked questions

Four follow-ups come up once the basics click. Each answer assumes the sections above.