f-strings vs. % formatting

The % operator: Python's original string formatting

Borrowed almost directly from C's printf, and in every version of Python there has ever been.

% formatting works by writing a template string with placeholders, then applying the % operator between that string and the values that fill the placeholders:

name = "Maya"
score = 91

print("Hello, %s. Your score is %d." % (name, score))
# Hello, Maya. Your score is 91.

Each placeholder starts with % and ends with a conversion code that says what type of value belongs there: %s for a string, %d for an integer, %f for a floating point number, and a handful of others. The values on the right side of % are supplied as a tuple, in the same order the placeholders appear.

The conversion codes you'll actually run into.

Code	Converts	Example
%s	Any value, as a string	"%s" % 42 → '42'
%d	Integer	"%d" % 7 → '7'
%f	Floating point, 6 decimals by default	"%f" % 3.1 → '3.100000'
%.2f	Floating point, 2 decimals	"%.2f" % 3.14159 → '3.14'
%x	Integer, as lowercase hexadecimal	"%x" % 255 → 'ff'
%%	A literal percent sign	"%d%%" % 50 → '50%'

One value doesn't need a tuple

With exactly one value, the parentheses are optional:

print("Hello, %s." % name)
# Hello, Maya. -- a bare value works fine with a single placeholder

Named placeholders with a dictionary

% formatting also accepts a dictionary instead of a tuple, naming each placeholder instead of relying on position:

data = {"name": "Maya", "score": 91}
print("Hello, %(name)s. Your score is %(score)d." % data)
# Hello, Maya. Your score is 91.

f-strings: formatted string literals

Added in Python 3.6 (2016), and the way most Python written today actually builds strings.

An f-string is a string literal with an f immediately before the opening quote. Inside the string, anything inside curly braces { } is not text, it is a real Python expression, evaluated on the spot and dropped into the string:

name = "Maya"
score = 91

print(f"Hello, {name}. Your score is {score}.")
# Hello, Maya. Your score is 91.

There is no conversion code to remember and no separate tuple of values to keep lined up with placeholders; the variable's own name goes directly inside the braces, right where it will appear.

Any expression is allowed, not just a variable name

Because what's inside { } is ordinary Python, it can be arithmetic, a method call, indexing, anything that produces a value:

price = 19.999
quantity = 3

print(f"Total: {price * quantity}")
# Total: 59.997

print(f"Name in caps: {name.upper()}")
# Name in caps: MAYA

Format specifiers: the part after the colon

f-strings still support the same kind of formatting control % formatting has, written after a colon inside the braces:

print(f"Total: ${price * quantity:.2f}")
# Total: $59.997 becomes $60.00, rounded and padded to two decimals

print(f"{255:x}")
# ff -- hexadecimal, same idea as %x

print(f"{7:04d}")
# 0007 -- padded to 4 digits with leading zeros

The debugging shortcut: =

Since Python 3.8, adding = right before the closing brace prints both the expression's source text and its value, which is a fast way to check what a variable actually holds while debugging:

print(f"{score=}")
# score=91

The same output, both ways

Every row below produces an identical string. The right-hand column is almost always shorter and reads closer to the sentence it actually prints.

% formatting and the equivalent f-string, for the same result.

Goal	% formatting	f-string
Insert a name	"Hi, %s" % name	f"Hi, {name}"
Insert two values	"%s is %d" % (name, age)	f"{name} is {age}"
2 decimal places	"%.2f" % price	f"{price:.2f}"
Hexadecimal	"%x" % 255	f"{255:x}"
Use an expression	"%d" % (x + y)	f"{x + y}"
Call a method	"%s" % name.upper()	f"{name.upper()}"

Why f-strings won

Three real advantages, not just newer-is-better.

• Readability. The variable sits exactly where its value will appear in the output. With % formatting, your eyes have to jump from the placeholder in the string back to the matching position in the tuple at the end, counting commas to figure out which value goes where.
• Any expression, not just a value. % formatting can only substitute a value already computed and placed in the tuple. An f-string can hold the computation itself, {price * quantity}, with nowhere else in the line to keep synchronized.
• Speed. An f-string is evaluated once, when Python compiles the code, into efficient bytecode. % formatting re-parses the template string's placeholders every single time that line runs. For code that formats strings in a tight loop, this difference is measurable.

Gotchas on both sides

% formatting: a single tuple value is ambiguous

If the one value you're substituting is itself a tuple, % gets confused about whether that tuple is "the one value" or "several values":

point = (3, 4)
print("Point: %s" % point)
# TypeError: not all arguments converted during string formatting

print("Point: %s" % (point,))
# Point: (3, 4) -- wrapping it in a one-item tuple fixes it

f-strings: the variable has to already exist

Because the code inside { } runs immediately, referencing a name that was never assigned raises the same NameError a normal line of code would:

print(f"{undefined_variable}")
# NameError: name 'undefined_variable' is not defined

This is usually a feature, not a bug, since it surfaces a typo immediately instead of silently printing the wrong thing, but it is a real difference from % formatting against a dictionary, which raises KeyError instead, naming the missing key directly.

f-strings: quoting inside the braces

In Python versions before 3.12, an f-string could not reuse the exact same quote character both outside the f-string and inside its braces:

data = {"name": "Maya"}

# Before Python 3.12, this line is a SyntaxError:
# print(f"{data["name"]}")

print(f"{data['name']}")
# Maya -- switch to single quotes inside, double quotes outside

Python 3.12 removed this restriction, but plenty of installed Python interpreters are still older than that, so mixing quote styles, double quotes outside and single quotes inside, remains the safe habit.

Quick check