String Formatting (f-Strings)

Introduction

So far you have built text by concatenating strings with +, which becomes clunky once you are mixing several variables and different data types. Python solves this with f-strings — short for "formatted string literals" — a clean, readable way to embed values directly inside text.

This lesson takes a deep dive into f-strings: embedding expressions, calling functions inside them, formatting numbers precisely, and aligning text. You will also briefly see the two older formatting styles so you can recognize them in existing code.

What is an f-String?

An f-string is a regular string literal prefixed with the letter f. Inside the string, anything wrapped in curly braces {} is treated as Python code and evaluated, then automatically converted to text and inserted into the string.

name = "Amol"
age = 22

print(f"My name is {name} and I am {age} years old.")

My name is Amol and I am 22 years old.

Embedding Expressions

The curly braces in an f-string are not limited to plain variables — you can place any valid Python expression inside them, including arithmetic, comparisons, and conditional expressions.

price = 250
quantity = 3

print(f"Total: {price * quantity}")
print(f"Is expensive: {price > 200}")

score = 82
print(f"Result: {'Pass' if score >= 40 else 'Fail'}")

Total: 750
Is expensive: True
Result: Pass

Calling Methods and Functions Inside {}

Because the braces accept any expression, you can call string methods or your own functions directly inside an f-string, without needing a separate variable.

name = "  python  "
print(f"Cleaned name: {name.strip().title()}")

def square(n):
    return n * n

number = 6
print(f"{number} squared is {square(number)}")

Cleaned name: Python
6 squared is 36

Format Specifiers for Numbers

A format specifier goes after a colon inside the braces and controls exactly how a value is displayed. The most common one is .Nf, which rounds a floating-point number to N decimal places.

pi = 3.14159265
price = 49.9

print(f"Pi rounded: {pi:.2f}")
print(f"Price: {price:.2f}")
print(f"Whole number: {pi:.0f}")

Pi rounded: 3.14
Price: 49.90
Whole number: 3

Thousands Separators

Adding a comma inside the format specifier automatically inserts thousands separators, which is useful for displaying large numbers like currency amounts or population figures.

population = 1400000000
salary = 1234567.891

print(f"Population: {population:,}")
print(f"Salary: {salary:,.2f}")

Population: 1,400,000,000
Salary: 1,234,567.89

Alignment and Padding

You can control the width of a formatted value and how it is aligned within that width — left, right, or centered — which is especially useful for lining up columns of text.

items = [("Apple", 3), ("Banana", 12), ("Fig", 150)]

for name, qty in items:
    print(f"{name:<10}{qty:>5}")

Apple         3
Banana       12
Fig         150

print(f"{'PYTHON':^20}")
print(f"{'PYTHON':*^20}")

       PYTHON        
*******PYTHON*******

The Older .format() Method

Before f-strings were introduced in Python 3.6, the str.format() method was the standard way to build formatted text. It uses {} placeholders in the string and passes values as arguments to .format().

name = "Amol"
age = 22

print("My name is {} and I am {} years old.".format(name, age))
print("My name is {0} and I am {1} years old. Hi {0}!".format(name, age))

My name is Amol and I am 22 years old.
My name is Amol and I am 22 years old. Hi Amol!

You will still encounter .format() in older codebases and some libraries, so it is worth being able to read it, even though you are unlikely to choose it for new code.

The Even Older % Formatting

Before .format() existed, Python borrowed a formatting style from the C language using the % operator with placeholders like %s for strings and %d for integers.

name = "Amol"
age = 22

print("My name is %s and I am %d years old." % (name, age))

My name is Amol and I am 22 years old.

Why f-Strings Are the Modern Choice

f-strings became the recommended way to format text in Python because they are shorter, faster, and easier to read than the alternatives — the variable appears directly where its value will be inserted, instead of in a separate list of arguments.

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

f-strings give you a concise, readable, and powerful way to build dynamic text by embedding expressions and controlling exactly how values are displayed. You also now recognize the older .format() and % styles when you encounter them in existing code.

With strings, string methods, and formatting covered, you are ready to move on to Python's most commonly used data structure for storing collections of items: the list.