String Upgrade

F-Strings & Optimized I/O

Injecting variables into strings used to be messy. Then came Python 3.6+ and the F-String: a feature so good it changed how we write Python forever.

String formatting is the act of injecting data (variables, database usage, user names) into a static text template. Python has tried to solve this problem three times.

1991 % Operator: The C-style legacy. Error-prone and limited.
2008 .format(): The "New" Style. Powerful but verbose.
2016 F-Strings: (Formatted String Literals). Fast, readable, and expressions supported inside { }.

What You'll Learn

Modern Syntax: Using f"Hello {name}".
Advanced Specifiers: Controlling decimals, padding, and alignment with :.
Debugging Magic: The hidden power of f"{var=}".
Performance: Why f-strings are faster than .format().
Legacy Patterns: Recognizing old code using %s.

The Winner: F-Strings

F-Strings (Formatted String Literals) are string literals prefixed with f or F. They allow you to execute Python expressions directly inside curly braces.

Basic Injection
PYTHON
name = "Alice"
age = 30
balance = 1250.50

# The F-String Way
# Readable. Evaluation happens at runtime.
message = f"User {name} is {age} years old."
print(message)

# Expressions inside braces!
# You can do math, function calls, or method access
print(f"Next year, {name} will be {age + 1}.")
print(f"Name uppercase: {name.upper()}")

Format Specifiers: Perfectionism

Just injecting values isn't enough. You often need to control decimal places, add leading zeros, or align text. You do this by adding a colon : followed by a Format Specifier.

Common Specifiers Cheat Sheet

Specifier	Example	Description
`:.2f`	`f"{pi:.2f}"` â†’ `3.14`	Float precision (2 decimal places)
`:03d`	`f"{id:03d}"` â†’ `005`	Pad with zeros to length 3
`:,`	`f"{val:,}"` â†’ `1,000,000`	Thousands separator
`:^10`	`f"{x:^10}"` â†’ `" Hi "`	Center align (padding 10)

Financial Formatting Example
PYTHON
price = 49.9
tax = 0.08
total = price * (1 + tax)

# Without formatting
print(f"Total: {total}") 
# Output: Total: 53.892000000000001 (Ugly float math)

# With Format Specifiers
# .2f = 2 decimal places fixed formatting
print(f"Total: ${total:.2f}") 
# Output: Total: $53.89

The Debugging Superpower: `=`

Introduced in Python 3.8, this is the single most useful trick for debugging without a debugger. If you add = inside the braces, Python prints the variable name AND its value.

PYTHON

user = "admin"
retries = 3

# âŒ Old Debugging
print(f"user: {user}, retries: {retries}")

# âœ… The "Walrus-style" Debugging (Self-documenting)
print(f"{user=}, {retries=}")
# Output: "user='admin', retries=3"

Performance Shootout

Why are F-Strings faster? Legacy % formatting and .format() are parsed at runtime. F-Strings are treated by the compiler as a series of constant strings and operations, optimizing them directly into efficient bytecode.

PYTHON
import timeit

name = "Python"
age = 30

# 1. Percent Styling (Slowest legacy)
# "Hello %s" % name

# 2. .format() (Slow object method)
# "Hello {}".format(name)

# 3. f-string (Fast opcode)
# f"Hello {name}"

# Benchmark results usually show f-strings are ~2x faster than .format()!

When NOT to use F-Strings?

F-Strings are evaluated eagerly (immediately). This makes them unsuitable for:

Logging: logging.info(f"User {user}") is bad because it interpolates even if logging is disabled. Use logging.info("User %s", user) instead.
i18n (Internationalization): Translation tools generally need a static string key like "Hello {name}" to look up translations. F-Strings bake the value in too early.

Next Steps

You can now slice strings and format them beautifully. But what if you need to find complex patterns, like email addresses or phone numbers, inside a wall of text? Enter the world of Regular Expressions.

Next: Intro to Regex â†’