Master Python String Formatting: Complete Guide

What is String Formatting?

String formatting is also commonly referred to as formatted string construction. It is the process of creating a string that includes variable data by embedding values within a predefined string structure or pattern. It enables the dynamic composition of strings without the need to concatenate values manually.

If you want to print someone’s name and age. You could do it like this:

name = "Alice"
age = 30
print("Name: " + name + ", Age: " + str(age))

name = "Alice"
age = 30
print("Name: " + name + ", Age: " + str(age))

But honestly, that looks a bit clunky.

Now look at this version:

print(f"Name: {name}, Age: {age}")

print(f"Name: {name}, Age: {age}")

Much cleaner, right?

It’s not just for printing names and ages either. You can use it when you need to:

• Add numbers with decimal places
• Format dates neatly
• Align text in columns
• Pad values with zeros or spaces
• Or even make your output look like a table

Python gives us a few ways to do this:

• F-strings — these are my go-to. If you’re using Python 3.6 or later, they’re fast and super readable.
• .format() method — still useful, especially when you need a bit more control.
• % formatting — old-school, but you’ll still run into it in older codebases.
• And template strings — great when you’re working with user input and want to keep things safe.

At the end of the day, string formatting is all about making your output look clean and professional — without turning your code into a mess of quotes and plus signs.

Now let’s explore F-strings

F-strings — My Go-To Choice for String Formatting

If you’re working with Python 3.6 or later, f-strings (short for formatted string literals) are likely to become your favorite way to format strings. Personally, they’re my go-to choice — and for good reasons: they’re fast, concise, and highly readable.

Let’s understand why.

What Are f-strings?

An f-string is a string prefixed with the letter f or F, which allows you to embed Python expressions directly inside the string using curly braces {}.

Instead of building strings manually or using .format(), f-strings let you include variables, function calls, or calculations inline — which makes the code much easier to read and maintain.

Why I Prefer f-strings

Here’s what makes f-strings my default choice in most projects:

1. Simplicity and Readability

You can clearly see where the variables are used — right inside the string.

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

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

Output:

My name is Alice and I am 30 years old.

My name is Alice and I am 30 years old.

There’s no guesswork, no juggling of positions, and no need to reference arguments by index or key. It’s exactly what you see.

2. Faster Performance

Internally, f-strings are compiled at runtime, which means they’re generally faster than .format() or % formatting. When you’re formatting strings inside loops or performance-sensitive code, this matters.

3. Supports Expressions

You’re not limited to variables. You can run any valid Python expression inside the {}.

x = 5
y = 3
print(f"The sum of {x} and {y} is {x + y}.")

x = 5
y = 3
print(f"The sum of {x} and {y} is {x + y}.")

Output:

The sum of 5 and 3 is 8.

The sum of 5 and 3 is 8.

This avoids creating temporary variables just to show a value.

4. Great for Formatting Numbers

You can apply number formatting, alignment, padding, and more — all directly inside the f-string.

price = 1234.567
print(f"Total: ${price:,.2f}")

price = 1234.567
print(f"Total: ${price:,.2f}")

Output:

Total: $1,234.57

Total: $1,234.57

Here:

• :, adds a thousands separator
• .2f rounds to two decimal places

It’s compact and self-documenting.

5. Cleaner Than Alternatives

Compare the same output using different methods:

Using .format()

"Total: ${:,.2f}".format(price)

"Total: ${:,.2f}".format(price)

Using f-string

f"Total: ${price:,.2f}"

f"Total: ${price:,.2f}"

The f-string version is shorter, more direct, and easier to follow.

When Should You Use f-strings?

F-strings are perfect for:

• Logging and printing output
• Debugging variable values
• Reports, dashboards, or result summaries
• Anytime you want clean, readable, dynamic strings

As long as you’re using Python 3.6 or higher, they are usually the best choice for string formatting.

Limitations to Be Aware Of

While f-strings are powerful, they have a few limits:

• They don’t work in Python 2.x or versions older than 3.6.
• They evaluate expressions immediately — which is great for power, but you should be cautious when dealing with untrusted input (for example, in web applications).
• You can’t reuse a placeholder by name — you’d have to type the same variable again if needed multiple times.

Summary

F-strings are fast, readable, and expressive.
If you’re using Python 3.6 or later, they simplify your string formatting and make your code more elegant.

That’s why — for me and many others — f-strings are the go-to tool when building strings dynamically.

Now, Let’s explore the .format() method — how it works, when to use it, and why it can still be very useful, especially when you need structured and flexible string construction.

.format() Method — A Detailed Explanation

What Is the .format() Method in Python?

The .format() method is a built-in string method in Python that allows you to insert values into a string using placeholders written as curly braces {}.

Introduced in Python 2.7 and 3.0, it was originally designed to replace the older % formatting method and remains a widely used approach, especially in situations where:

• You need better control over formatting
• You want to use named variables
• If You’re working with dictionaries or dynamic content and
• You want the same placeholder reused multiple times

Basic Syntax

"template string with {} placeholders".format(values)

"template string with {} placeholders".format(values)

Each {} gets replaced with a value passed into the .format() method.

1. Positional Formatting (by order)

msg = "Hello, {}, you have {} new messages."
result = msg.format("Alice", 3)
print(result)

msg = "Hello, {}, you have {} new messages."
result = msg.format("Alice", 3)
print(result)

Output:

Hello, Alice, you have 3 new messages.

Hello, Alice, you have 3 new messages.

• The first {} gets "Alice"
• The second {} gets 3

You can also refer to the position explicitly:

msg = "First: {0}, Second: {1}, Again First: {0}"
print(msg.format("X", "Y"))

msg = "First: {0}, Second: {1}, Again First: {0}"
print(msg.format("X", "Y"))

Output:

First: X, Second: Y, Again First: X

First: X, Second: Y, Again First: X

Here, {0} and {1} refer to argument positions.

2. Named Placeholders (Keyword Arguments)

This is one of .format()’s strongest features:

msg = "Name: {name}, Score: {score}"
print(msg.format(name="Bob", score=95))

msg = "Name: {name}, Score: {score}"
print(msg.format(name="Bob", score=95))

Output:

Name: Bob, Score: 95

Name: Bob, Score: 95

• This allows you to clearly label which values go where.
• Very helpful when dealing with lots of values or dynamically generated data.

3. Formatting Values (Numbers, Padding, Alignment)

Example: Floating-point precision

price = 1234.56789
msg = "Price: {:.2f}".format(price)
print(msg)

price = 1234.56789
msg = "Price: {:.2f}".format(price)
print(msg)

Output:

Price: 1234.57

Price: 1234.57

• :.2f formats the number with 2 decimal places

Example: Padding and Alignment

print("{:<10} | {:>5}".format("Item", 25))

print("{:<10} | {:>5}".format("Item", 25))

Output:

Item       |    25

Item       |    25

• <10 means left-align in a 10-character space
• >5 means right-align in a 5-character space

4. Using Dictionaries with .format()

If your data is stored in a dictionary, you can unpack it into the string:

info = {"name": "Emma", "marks": 91}
msg = "Student: {name}, Marks: {marks}"
print(msg.format(**info))

info = {"name": "Emma", "marks": 91}
msg = "Student: {name}, Marks: {marks}"
print(msg.format(**info))

Output:

Student: Emma, Marks: 91

Student: Emma, Marks: 91

The ** operator unpacks the dictionary into keyword arguments.

5. Reusing and Reordering Variables

You can repeat the same variable multiple times, or reorder them:

template = "Subject: {sub}, Marks: {marks}, {sub} is your favorite."
print(template.format(sub="Math", marks=95))

template = "Subject: {sub}, Marks: {marks}, {sub} is your favorite."
print(template.format(sub="Math", marks=95))

Output:

Subject: Math, Marks: 95, Math is your favorite.

Subject: Math, Marks: 95, Math is your favorite.

This is not possible with f-strings unless you store the value in a separate variable.

When Is .format() More Useful Than f-strings?

What is % formatting in Python?

Percent formatting is an older string formatting method that uses the % operator to insert values into a string. You place format specifiers (like %s, %.2f, etc.) inside the string, and then use % followed by a tuple containing the values you want to insert.

Although it’s older, this method is still supported in modern Python.

Example Code:

language = "Python"
version = 3.11
message = "We are learning %s version %.2f" % (language, version)
print(message)

language = "Python"
version = 3.11
message = "We are learning %s version %.2f" % (language, version)
print(message)

Step-by-Step Breakdown:

1. Format String:

"We are learning %s version %.2f"

"We are learning %s version %.2f"

This is the template string. It contains two placeholders:

• %s: for a string
• %.2f: for a floating-point number, rounded to 2 decimal places

2. Variables:

language = "Python"
version = 3.11

language = "Python"
version = 3.11

• language is a string
• version is a float

3. Substitution using %:

% (language, version)

% (language, version)

• The values are placed in a tuple, in the same order as the placeholders in the string.
• Python replaces %s with "Python"
• It replaces %.2f with the number 3.11, rounded to two decimal places

4. Final Output:

We are learning Python version 3.11

We are learning Python version 3.11

Understanding the Format Specifiers

Another Example:

name = "Alice"
marks = 88.6789
result = "Student: %s | Marks: %.1f" % (name, marks)
print(result)

name = "Alice"
marks = 88.6789
result = "Student: %s | Marks: %.1f" % (name, marks)
print(result)

Output:

Student: Alice | Marks: 88.7

Student: Alice | Marks: 88.7

• %s → inserts the string Alice
• %.1f → inserts the float 88.6789 rounded to 1 decimal place

Summary

• Percent formatting is simple and still works in Python.
• It’s less flexible than str.format() and f-strings, especially with multiple values or complex formatting.
• Still useful for quick tasks or when working with older code.

What Are Template Strings?

Template strings are a way of creating strings that include variables. They come from Python’s built-in string module. Instead of using {} like f-strings or .format(), you use a dollar sign followed by a variable name like this:

from string import Template

t = Template("Hello, $name!")
print(t.substitute(name="Alice"))

from string import Template

t = Template("Hello, $name!")
print(t.substitute(name="Alice"))

Output:

Hello, Alice!

Hello, Alice!

Why Use Template Strings?

1. Safer When Handling User Input

When you allow users to enter data (like filling out a form or typing in a chat box), you don’t always know what they’ll type. If you use f-strings or .format() directly with that input, and you’re not careful, it might cause problems — like running unwanted code.

Template Strings avoid this risk by treating all user input as plain text. They don’t try to run it, calculate it, or treat it as a command.

Example:

from string import Template

user_input = "__import__('os').system('rm -rf /')"  # harmful input
template = Template("User typed: $text")
print(template.substitute(text=user_input))

from string import Template

user_input = "__import__('os').system('rm -rf /')"  # harmful input
template = Template("User typed: $text")
print(template.substitute(text=user_input))

Output:

User typed: __import__('os').system('rm -rf /')

User typed: __import__('os').system('rm -rf /')

It just prints the text — it doesn’t run any commands.

How Template Strings Work

1. You write a string and mark variables with a dollar sign, like $name.
2. You pass the values using substitute().

Example:

from string import Template

message = Template("Welcome, $user! You have $messages new messages.")
print(message.substitute(user="Tom", messages="3"))

from string import Template

message = Template("Welcome, $user! You have $messages new messages.")
print(message.substitute(user="Tom", messages="3"))

Output:

Welcome, Tom! You have 3 new messages.

Welcome, Tom! You have 3 new messages.

What If You Forget a Variable?

If you forget to give one of the variables, substitute() will raise an error. To avoid that, use safe_substitute() — it will leave the missing variable as-is.

t = Template("Hello, $name! Your score is $score")
print(t.safe_substitute(name="John"))

t = Template("Hello, $name! Your score is $score")
print(t.safe_substitute(name="John"))

Output:

Hello, John! Your score is $score

Hello, John! Your score is $score

Escaping the Dollar Sign

If you want to show a dollar sign (for example, $100), use two dollar signs $$.

t = Template("Price: $$${amount}")
print(t.substitute(amount="25"))

t = Template("Price: $$${amount}")
print(t.substitute(amount="25"))

Output:

Price: $25

Price: $25

When Should You Use Template Strings?

• When working with user input
• When building email templates, SMS messages, or reports
• If you want to avoid errors caused by unknown or unsafe input you can use template strings
• When you need simple and readable formatting

Summary

Template Strings:

• Are defined using the Template class from the string module
• Use $variable instead of {} or %s
• Don’t evaluate any code, which makes them safe
• Are great when you don’t want unexpected behavior from user input

Conclusion

Python’s string formatting capabilities have evolved significantly over the years. While all four methods are valid, f-strings represent the modern, Pythonic way to format strings. They offer the best combination of readability, performance, and functionality.

Key takeaways:

• Use f-strings for new Python 3.6+ projects
• Use .format() when you need template reusability or backward compatibility
• You can use % formatting sparingly, mainly for legacy code maintenance
• Master format specifiers to create professional-looking output
• Consider security implications when formatting user input

Practice these techniques in your own projects, and you’ll soon find yourself creating beautifully formatted strings with ease!

About The Author

Emmimal Alexander

Emmimal Alexander is an AI & Machine Learning Expert, passionate educator, and the author of “Neural Networks and Deep Learning with Python.” As the founder of EmiTechLogic, she’s on a mission to make complex tech topics accessible, engaging, and empowering for learners at every level.

With deep expertise in Python, HTML, JavaScript, and CSS, Emmimal brings a strong coding foundation to her tutorials and educational resources. Her work focuses on blending theoretical understanding with real-world application—so readers not only learn how things work, but also why they matter.

Through EmiTechLogic, she creates hands-on guides, detailed breakdowns, and project-based learning content that bridges the gap between academic concepts and practical implementation. Whether you’re exploring AI for the first time or fine-tuning your neural networks, you’re in the right place.

See author's posts