f-strings — embedding expressions — Coding notes

WHY do f-strings exist?

Before f-strings, building a string from variables was clumsy:

name = "Ada"
age = 36
# Old way 1: concatenation — must manually convert ints to str
msg = "Hi " + name + ", you are " + str(age)
# Old way 2: .format() — placeholders separated from values
msg = "Hi {}, you are {}".format(name, age)

Both are error-prone: you forget str(), you mismatch the order of {} and arguments, and you read the values far away from where they're used.

WHAT is an f-string?

f"text {expression} more text"

The f prefix turns on the magic.
Everything outside braces is literal text.
Everything inside braces is code that runs.

HOW does evaluation work? (derive from first principles)

Think of the interpreter scanning the string once, left to right:

Copy literal characters straight to the output.
On hitting {, read until the matching }. That chunk is parsed and executed as a Python expression in the current scope.
The result is converted to text (default: like str(...)) and appended.
Continue until the string ends.

So the braces hold any expression — variables, arithmetic, function calls, method calls, indexing — not just plain variable names.

Figure — f-strings — embedding expressions

Worked examples

Worked example 2 — Arithmetic inside braces

a, b = 7, 5
print(f"{a} + {b} = {a + b}")   # 7 + 5 = 12

Why this step? {a + b} is a full expression; Python computes 12 first, then converts to text. The literal + between the first two braces is just a character.

Worked example 3 — Method calls and indexing

word = "python"
print(f"Shout: {word.upper()}")     # Shout: PYTHON
print(f"First letter: {word[0]}")   # First letter: p

Why this step? Any expression is allowed, so .upper() and [0] run normally inside the braces.

Worked example 4 — Format spec (the part after

:)

pi = 3.14159265
print(f"pi ≈ {pi:.2f}")        # pi ≈ 3.14
price = 1234567
print(f"{price:,}")            # 1,234,567
print(f"{42:05d}")             # 00042

Why this step? After a colon you give a format specification: .2f = 2 decimals float, , = thousands separator, 05d = pad integer to width 5 with zeros. This is format(value, spec) under the hood.

Worked example 5 — The self-documenting

= (Python 3.8+)

x = 9
print(f"{x=}")          # x=9
print(f"{x*2 = }")      # x*2 = 18

Why this step? {expr=} prints both the source text of the expression and its value — superb for debugging.

Common mistakes

Common mistake Forgetting the

f prefix

name = "Ada"
print("Hello, {name}")   # Hello, {name}   ← braces printed literally!

Why the mistake feels right: the braces look like they should be filled in. Why it's wrong: without f, it's an ordinary string and braces are just characters. Fix: add f → f"Hello, {name}".

Common mistake Putting a statement (not an expression) in braces

# f"{x = 5}"   ← SyntaxError: assignment is not an expression

Why it feels right: = is everywhere in Python. Why it's wrong: braces need an expression (something with a value). x = 5 is a statement. Fix: do the assignment outside; only put the value-producing part inside. (Note {x=} with no value is the special debug form, which is different.)

Common mistake Needing a literal brace

print(f"Set notation: {{1, 2, 3}}")   # Set notation: {1, 2, 3}

Why it feels right: you typed one brace and got an error or empty result. Why: a single brace starts an expression. Fix: double the braces {{ and }} to print a literal { and }.

Common mistake Same quote inside and outside (pre-3.12)

d = {"k": 1}
# f"value is {d["k"]}"   ← breaks on older Python
f"value is {d['k']}"     # use the OTHER quote inside

Why it feels right: quotes nest fine in normal code. Why: older parsers close the string at the inner ". Fix: use the alternate quote inside the braces.

Recall Feynman: explain to a 12-year-old

Imagine a fill-in-the-blank story: "My dog is ___ years old." A normal Python string is the story with the blank left empty — it just prints ___. An f-string is the story where you write a little instruction inside the blank, like {2 + 3}, and the computer secretly solves it and writes 5 in the gap before showing you the sentence. The f is the magic stamp that says "hey, fill in the blanks!"

Recall checkpoint

What prefix turns a string into an f-string?

The letter f (or F) placed immediately before the opening quote, e.g. f"...".

Inside an f-string, what can go between { }?

Any Python expression (variable, arithmetic, function/method call, indexing) — anything that evaluates to a value.

How do you embed 7 + 5 and show its result in an f-string?

f"{7 + 5}" → 12 (the expression is evaluated, then converted to text).

How do you print a literal { and } inside an f-string?

Double them: {{ prints { and }} prints }.

What does the part after a colon mean, as in f"{pi:.2f}"?

It's a format specification; .2f formats the value as a float with 2 decimal places.

What does f"{x=}" do (Python 3.8+)?

Prints both the expression text and its value, e.g. x=9 — handy for debugging.

What's the conceptual substitution rule of an f-string?

Each {expr} is replaced by format(expr, spec) (defaulting to str(expr)), and all literal/converted pieces are joined in order.

Why does print("Hi {name}") print {name} literally?

Without the f prefix it's an ordinary string, so braces are just characters, not expression markers.

What does f"{42:05d}" produce and why?

00042 — 05d pads the integer to width 5 with leading zeros.

Connections

Strings — literals and quotes — f-strings are a kind of string literal.
str() and type conversion — braces implicitly call str()/format().
str.format() method — the older sibling using {} placeholders.
Format specification mini-language — what lives after the :.
Variables and scope — expressions in braces use the current scope.
print() function — most common consumer of f-strings.

Concept Map

Hinglish (regional understanding)

Intuition Hinglish mein samjho

Dekho, f-string ka matlab simple hai: jab string ke aage f lagate ho, to us string ke andar curly braces { } ke beech jo bhi likhoge wo Python expression ki tarah chal jaata hai. Matlab f"Hello {name}" likhne par Python name ki value uthaake wahin chipka dega. Pehle log "Hi " + name + str(age) aise jod-jod ke likhte the — bahut galti hoti thi, str() lagana bhool jaate the. f-string ne yeh sab simple kar diya: value waheen likho jahan dikhani hai.

Braces ke andar sirf variable hi nahi, koi bhi expression aa sakta hai — {a + b}, {word.upper()}, {price[0]} sab chalega. Python pehle us expression ko solve karta hai, phir uska text bana ke string mein daal deta hai. Yaad rakho: f for FILL — f Python ko bolta hai ki blanks bhar do.

Colon : ke baad jo aata hai wo formatting hai — jaise {pi:.2f} matlab do decimal tak dikhao, {price:,} matlab thousands mein comma lagao, {42:05d} matlab paanch digit tak zero se bhar do. Isko aise samjho: colon ke baad value ko "costume" pehnate ho.

Do common galtiyan: (1) f lagana bhool gaye to {name} waise ka waisa print ho jaayega — magic off rahega. (2) Agar literal { chahiye to double karo {{. Bas itna dhyaan rakho aur f-strings tumhare code ko clean aur readable bana denge.

f-strings — embedding expressions

WHY do f-strings exist?

WHAT is an f-string?

HOW does evaluation work? (derive from first principles)

Worked examples

Common mistakes

Recall checkpoint

Connections

Concept Map

Hinglish (regional understanding)

Go deeper — visual, from zero

Test yourself — Introduction to Programming (Python)

Connections