Formatting Mastery: A Practical Deep Dive into Python f-strings and the Format Spec Mini-Language

Why string formatting deserves your attention

Almost every Python program eventually has to turn data into text: a log line, a table row, a price, a report, a filename. Most developers learn the basic f"{value}" syntax on day one and stop there. But the part after the colon — the format specification mini-language — is where f-strings go from "prints a variable" to "produces perfectly aligned, locale-friendly, presentation-ready output" without a single manual rjust() or round() call.

This guide is a practical tour of that mini-language. Everything here works with plain f-strings (Python 3.6+), and the same spec syntax powers str.format() and the built-in format(). Every snippet below has been run and its output verified.

The two halves of a replacement field

Inside an f-string, each {...} has up to three parts: {expression!conversion:format_spec}. The expression is evaluated, an optional conversion is applied, and the format spec controls the final rendering.

name = "Ada"
lang = "Python"
print(f"{name} loves {lang}")
# Ada loves Python

# The expression can be any Python expression:
items = ["a", "b", "c"]
print(f"There are {len(items)} items: {', '.join(items)}")
# There are 3 items: a, b, c

The self-documenting = specifier

Added in Python 3.8, appending = inside the braces prints both the expression text and its value. It is the fastest debugging trick in the language — no more print("x =", x).

x = 42
y = 8
print(f"{x + y = }")
# x + y = 50

# It respects surrounding whitespace and works with format specs:
import math
print(f"{math.pi = :.3f}")
# math.pi = 3.142

Conversions: !r, !s, and !a

Before formatting, you can force a conversion. !r calls repr(), !s calls str() (the default), and !a calls ascii(). Reach for !r whenever you want quotes around strings or the unambiguous representation of an object.

name = "Ada"
print(f"{name!r}")
# 'Ada'

Alignment, fill, and width

The core of the mini-language is [[fill]align][width]. Use < for left, > for right, ^ for center, and put any fill character before the alignment symbol.

for word in ["ok", "warning", "critical"]:
    print(f"|{word:<10}|{word:>10}|{word:^10}|")
# |ok        |        ok|    ok    |
# |warning   |   warning| warning  |
# |critical  |  critical| critical |

# Fill with any character (great for headers and separators):
print(f"{42:*^12}")
# *****42*****

This is what makes f-strings ideal for quick console tables — pick a column width once and every row lines up.

Numbers: precision, grouping, percentages, and bases

Numeric formatting is where the mini-language really earns its keep. The general shape for numbers is [sign][#][0][width][grouping][.precision][type].

pi = 3.14159265
print(f"{pi:.2f}")           # 3.14   (fixed-point, 2 decimals)
print(f"{1234567.891:,.2f}") # 1,234,567.89  (comma thousands)
print(f"{0.2564:.1%}")       # 25.6%  (percent)
print(f"{1234567:_}")        # 1_234_567  (underscore grouping)

# Different bases with the # prefix for the base marker:
print(f"{255:#x} {255:#o} {255:b}")
# 0xff 0o377 11111111

# Zero-padding and explicit signs:
print(f"{42:08.2f}")   # 00042.00
print(f"{-42:06}")     # -00042   (sign-aware zero padding)
print(f"{5:+} {-5:+}") # +5 -5

Note how {-42:06} keeps the minus sign at the front and pads after it. That "sign-aware zero padding" is exactly what you want for aligned numeric columns, and it is far cleaner than string concatenation.

Nested and dynamic format specs

The width and precision themselves can be expressions wrapped in braces. This lets you compute formatting at runtime — perfect when column widths depend on data.

pi = 3.14159265
width = 12
prec = 3
print(f"{pi:{width}.{prec}f}")
# '       3.142'

Formatting dates and times

datetime, date, and time objects interpret the format spec as an strftime pattern. No need to call strftime() explicitly.

from datetime import date

d = date(2026, 9, 4)
print(f"{d:%Y-%m-%d}")
# 2026-09-04
print(f"{d:%A, %B %d, %Y}")
# Friday, September 04, 2026

Precise money with Decimal

For currency, avoid binary floats and use decimal.Decimal. The format spec works on it just like a float, but without floating-point surprises.

from decimal import Decimal
print(f"{Decimal('1.10'):.2f}")
# 1.10

Make your own types formattable with __format__

Any class can plug into the mini-language by defining __format__(self, spec). Whatever text follows the colon is handed to your method as a string, so you decide what the spec means.

class Money:
    def __init__(self, cents):
        self.cents = cents
    def __format__(self, spec):
        dollars = self.cents / 100
        if spec == "":
            spec = ".2f"
        return f"${dollars:{spec}}"

print(f"{Money(123456)}")       # $1234.56
print(f"{Money(123456):,.2f}")  # $1,234.56

This is the same protocol the standard library uses, so your objects behave consistently everywhere f-strings, format(), and str.format() are used.

The same spec, three ways

The mini-language is shared. When you can't use an f-string — say, a template loaded from config — str.format() and format() accept identical specs.

print("{:>8}".format("hi"))    # '      hi'
print(format(3.14159, ".2f"))  # '3.14'

What PEP 701 unlocked in Python 3.12

Historically f-strings had awkward limits: you couldn't reuse the same quote character inside the expression, backslashes were banned, and comments in multi-line expressions were off-limits. PEP 701 reimplemented f-strings on top of the PEG parser and formalized their grammar. Starting in Python 3.12, expressions inside f-strings can be any valid Python expression.

# Valid in Python 3.12+ (would be a SyntaxError on 3.11 and earlier):
data = {"name": "Ada"}
print(f"{data["name"]}")          # reuse the same quotes
print(f"{"\n".join(["x", "y"])}") # backslashes inside the expression

PEP 701 introduced no semantic changes — it is fully backward compatible — so existing f-strings keep working exactly as before. It simply removes the papercuts. If you still support Python 3.11 or older, keep using a different quote style or a temporary variable for these cases.

Common pitfalls

A few traps are worth remembering. To print a literal brace, double it: f"{{literal braces}}" renders as {literal braces}. Never build SQL queries or shell commands with f-strings — use parameterized queries and subprocess argument lists instead, because interpolating untrusted input is an injection risk. And remember the : starts the format spec, so if your expression contains a colon (like a slice or a dict display) you may need parentheses or a temporary variable to disambiguate.

Wrap-up and next steps

The format specification mini-language turns f-strings into a compact, powerful formatting engine: alignment and fill for tables, grouping and precision for numbers, strftime patterns for dates, and __format__ for your own types — all in one consistent syntax that also works with str.format() and format(). Next, try replacing a few manual round() and ljust() calls in your codebase with proper format specs, define __format__ on a domain object you use often, and if you're on Python 3.12+, enjoy writing f-string expressions without fighting the quote rules. Once the mini-language is muscle memory, clean output stops being a chore.