String formatting is an important part of Python because programs often need to display dynamic information inside text. Names, numbers, prices, percentages, and calculated values can all be combined with fixed text to create clear and readable output. Python provides several ways to format strings, including the format() method, f-strings, and the older % formatting method. In this article, we will understand how string formatting works, explore different formatting options, and see practical examples of where these techniques are useful.

Table of Contents

---

What Is String Formatting in Python?

String formatting is the process of inserting variables, values, or expressions into a string in a structured way. It allows us to create dynamic text without manually converting and joining every value together.

For example, suppose we have a student's name and age. We can insert both values directly into a message using an f-string.

name = "Rahul"
age = 21

# Insert the variable values into the formatted string
message = f"My name is {name} and I am {age} years old."

print(message)

Output:

My name is Rahul and I am 21 years old.

Here, name and age are variables, while the text around them remains fixed. Python evaluates the values inside the curly braces and inserts them into the string.

Why Is String Formatting Important?

Programs frequently need to display information that changes while the program is running. String formatting provides a clean way to combine this changing information with fixed text.
For example, formatting can be used when displaying user details, prices, calculated results, reports, and other structured information.

String formatting is commonly used for:

1. Displaying user information
2. Creating readable messages
3. Displaying prices and currency values
4. Formatting decimal numbers
5. Displaying percentages
6. Creating aligned console output
7. Generating reports and summaries

Different Ways to Format Strings

Python provides multiple ways to insert values into strings. Some approaches are older, while f-strings and the format() method are commonly used in modern Python programs.

The main approaches are:

Method	Example	Common Usage
format() method	"Hello {}".format(name)	Flexible string formatting
f-Strings	f"Hello {name}"	Modern Python formatting
% formatting	"Hello %s" % name	Older Python code

For new Python programs, f-strings are generally preferred because they are concise and readable. However, understanding the format() method is also important because it provides a flexible placeholder-based formatting system and is commonly found in existing code.

Using the format() Method

The format() method replaces placeholders in a string with values supplied to the method. Placeholders are represented by curly braces.

Syntax:

"text {}".format(value)

Example:

name = "Rahul"

# Replace the placeholder with the value of name
message = "Hello, {}!".format(name)

print(message)

Output:

Hello, Rahul!

The empty curly braces act as a placeholder. The value stored in name is inserted into that position when format() is executed.

Using Multiple Values with format()

The format() method can accept multiple values at the same time. By default, Python places these values into the placeholders from left to right.

name = "Rahul"
age = 21
city = "Delhi"

# Insert the values into the placeholders from left to right
message = "My name is {}, I am {} years old, and I live in {}.".format(
    name, age, city
)

print(message)

Output:

My name is Rahul, I am 21 years old, and I live in Delhi.

The first placeholder receives name, the second receives age, and the third receives city.

Using Positional Arguments

Positional arguments allow us to control which value is inserted into each placeholder. The number inside the curly braces represents the position of the value passed to format().

Python starts counting positions from zero, so the first value has index 0, the second has index 1, and so on.

name = "Rahul"
language = "Python"

# Use indexes to change the order of the values
message = "{1} is being learned by {0}.".format(name, language)

print(message)

Output:

Python is being learned by Rahul.

Here, {0} refers to name and {1} refers to language. This allows the values to appear in a different order from the order in which they were passed.

Using Named Arguments

Named arguments allow placeholders to refer to values by name rather than by position. This can make formatted strings easier to understand, especially when several values are involved.

name = "Rahul"
age = 21

# Match each placeholder with a named argument
message = "My name is {name} and I am {age} years old.".format(
    name=name,
    age=age
)

print(message)

Output:

My name is Rahul and I am 21 years old.

Here, the name placeholder receives the value assigned to the name argument, while age receives the value assigned to the age argument.

Using Format Specifiers with format()

The format() method can also control how a value is displayed by using a format specifier. A colon is placed inside the placeholder, followed by the formatting option.

Example:

price = 125.6789

# Display the price with two decimal places

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

Output:

Price: 125.68 

Here, .2f tells Python to display the floating-point number with two digits after the decimal point.

Using f-Strings

f-Strings provide a concise way to insert variables and expressions directly into a string. They were introduced in Python 3.6 and are now one of the most commonly used approaches for string formatting.

Syntax:

f"text {variable}"

Example:

name = "Rahul"
age = 21

# Insert variables directly into the formatted string
message = f"My name is {name} and I am {age} years old."

print(message)

Output:

My name is Rahul and I am 21 years old.

The f before the opening quotation mark tells Python that the string is an f-string. Python evaluates the expressions inside the curly braces and inserts their results into the string.

Using Expressions in f-Strings

One of the useful features of f-strings is that they can contain Python expressions directly inside curly braces. This is useful when a value needs to be calculated before it is displayed.

price = 500
quantity = 3

# Calculate the total directly inside the f-string
print(f"Total price: {price * quantity}")

Output:

Total price: 1500

Python calculates price * quantity first and then inserts the result into the string.

Difference Between format() and f-Strings

Both format() and f-strings can be used to insert values into strings. However, their syntax is different, and f-strings are generally easier to read when variables are already available in the current code.

Feature	format()	f-Strings
Basic syntax	"Hello {}".format(name)	f"Hello {name}"
Introduced	Python 2.6	Python 3.6
Readability	Good	Usually simpler
Expressions	Passed through arguments	Can be written directly
Modern usage	Still useful	Very common

For modern Python code, f-strings are usually the preferred choice for straightforward formatting. The format() method is still important to understand because it is part of Python's string formatting system.

Using the % Operator

The % operator is an older string-formatting technique that uses special format characters as placeholders. It is still supported by Python and may appear in older programs and projects.

Syntax:

"format string %s" % value

Example:

name = "Rahul"
age = 21

# %s formats the string and %d formats the integer
message = "My name is %s and I am %d years old." % (name, age)

print(message)

Output:

My name is Rahul and I am 21 years old.

Here, %s is used for the string value, and %d is used for the integer value.

Common % Format Specifiers

The % formatting system provides different format specifiers for different types of values. These specifiers tell Python how the value should be represented inside the string.

Specifier	Purpose	Example
%s	String	"Hello %s" % "Python"
%d	Integer	"Age: %d" % 20
%f	Floating-point number	"Price: %f" % 25.5
%.2f	Two decimal places	"Price: %.2f" % 25.5

For example, the %.2f specifier can be used when a floating-point number should be displayed with exactly two digits after the decimal point.

price = 49.5678

# Display the floating-point value with two decimal places
print("Price: %.2f" % price)

Output:

Price: 49.57

The .2f specifier specifies that the floating-point number should be displayed with two digits after the decimal point.

Understanding Format Specifiers

Format specifiers control how a value should appear in the final string. They can be used to control decimal places, alignment, width, padding, separators, and number representation.

A format specifier is written after a colon inside the curly braces. A format specification can contain different parts depending on how the value needs to be displayed. Common parts include fill, alignment, width, precision, and type.

Part	Purpose	Example
Fill	Character used to fill extra space	*
Alignment	Controls the position of the value	<, >, ^
Width	Sets the minimum field width	10
Precision	Controls decimal places	.2
Type	Specifies the value representation	f, d, b, x, %

These parts can be combined to control different aspects of the formatted value.

f"{value:specifier}"

For example, .2f tells Python to display a floating-point number with two digits after the decimal point.

price = 125.6789

# Display the price with two decimal places
print(f"Price: {price:.2f}")

Output:

Price: 125.68

The value is rounded for display to two decimal places. The original value stored in price is not changed.

1. Formatting Decimal Numbers

Decimal formatting is useful when displaying prices, measurements, averages, and calculated values. The number before f specifies how many digits should appear after the decimal point.

number = 45.67891

# Display the number with different levels of precision
print(f"{number:.2f}")
print(f"{number:.3f}")

Output:

45.68
45.679

The first value is displayed with two decimal places, while the second is displayed with three decimal places.

2. Formatting Percentages

The percentage format specifier is useful when a decimal value needs to be displayed as a percentage. Python multiplies the value by 100 and adds the percent sign.

score = 0.875

# Convert the decimal value into a percentage
print(f"Score: {score:.1%}")

Output:

Score: 87.5%

Here, 0.875 is displayed as 87.5%.

3. Formatting Numbers with Commas

Large numbers can become difficult to read when there are no separators between thousands. The comma format specifier adds thousands separators to make these values easier to understand.

population = 1250000

# Add thousands separators to the displayed number
print(f"Population: {population:,}")

Output:

Population: 1,250,000

The comma changes only the displayed representation. The original value remains an integer.

4. Formatting Currency Values

String formatting can be used to display currency values in a readable form. It can combine a currency symbol with thousands separators and a fixed number of decimal places.

price = 1499.5

# Add the currency symbol, commas, and two decimal places
print(f"Price: ₹{price:,.2f}")

Output:

Price: ₹1,499.50

The comma adds the thousands separator, while2f displays exactly two decimal places. Formatting does not perform currency conversion; it only controls how the number appears.

Controlling Width and Alignment

Width specifies the minimum amount of space that should be reserved for a formatted value. This is useful when creating aligned output, reports, or simple tables in the console.

The main alignment options are:

Specifier	Meaning
<	Left alignment
>	Right alignment
^	Center alignment

Example:

name = "Rahul"

# Align the same text in three different ways
print(f"{name:<10}")
print(f"{name:>10}")
print(f"{name:^10}")

Output:

Rahul    
     Rahul
  Rahul   

The number 10 specifies the minimum width, while the alignment symbol determines where the value is placed within that space.

Adding Padding Characters

Python can use a custom character to fill the unused space created by a width specification. The fill character is placed before the alignment symbol.

name = "Rahul"

# Fill the remaining width with asterisks
print(f"{name:*^10}")

Output:

**Rahul***

Here, * is the fill character, ^ specifies center alignment, and 10 specifies the minimum width.

Zero Padding

Zero padding is useful when a number needs to contain a fixed number of digits. It is commonly used for IDs, counters, rankings, and other formatted numeric values.

number = 42

# Add leading zeros until the value has five digits
print(f"{number:05}")

Output:

00042

The width is five characters, so Python adds three zeros before 42.

Formatting Integers in Different Number Systems

Python can display integers using different number systems through format specifiers. This is useful when working with binary, octal, and hexadecimal representations.

Specifier	Number System
b	Binary
o	Octal
x	Hexadecimal

Example:

number = 25

# Display the integer in three different number systems
print(f"Binary: {number:b}")
print(f"Octal: {number:o}")
print(f"Hexadecimal: {number:x}")

Output:

Binary: 11001
Octal: 31
Hexadecimal: 19

The integer itself does not change. Only its representation inside the formatted string is different.

Using Multiple Formatting Options

Multiple formatting options can be combined inside a single format specification. This allows us to control several aspects of a value at the same time.

For example, commas and decimal precision can be used together when displaying a large floating-point number.

amount = 1234567.8912

# Add commas and display two decimal places
print(f"Amount: {amount:,.2f}")

Output:

Amount: 1,234,567.89

Here, the comma adds thousands separators and .2f limits the displayed value to two decimal places.

Practical Examples

String formatting becomes more useful when applied to real programming situations. The following examples show how formatting can be used to create readable output in common applications.

1. Student Result

A student result can contain several values such as the student's name, marks, and percentage. String formatting allows these values to be displayed in a clean and consistent way.

name = "Rahul"
marks = 87
percentage = 87.456

# Format the percentage to two decimal places
print(f"Student: {name}")
print(f"Marks: {marks}")
print(f"Percentage: {percentage:.2f}%")

Output:

Student: Rahul
Marks: 87
Percentage: 87.46%

The .2f formatting makes the percentage consistent by displaying exactly two digits after the decimal point.

2. Product Information

Shopping applications often need to display product names, prices, quantities, and totals. Formatting can make the numerical information easier to read.

product = "Laptop"
price = 74999.5
quantity = 2

# Calculate the total price
total = price * quantity

# Format the prices with commas and two decimal places
print(f"Product: {product}")
print(f"Price: ₹{price:,.2f}")
print(f"Quantity: {quantity}")
print(f"Total: ₹{total:,.2f}")

Output:

Product: Laptop
Price: ₹74,999.50
Quantity: 2
Total: ₹149,999.00

The price and total use the comma and decimal formatting options to produce a readable currency representation.

3. Creating a Simple Table

Width and alignment formatting can be combined to create simple text-based tables. This is useful when information needs to be displayed in columns in the console.

name = "Rahul"
marks = 87

# Reserve fixed-width fields for the table columns
print(f"{'Name':<10} {'Marks':>5}")
print(f"{name:<10} {marks:>5}")

Output:

Name       Marks
Rahul         87

The width and alignment specifications keep the columns organized and make the output easier to read.

Escaping Curly Braces

Curly braces have a special meaning in f-strings because they indicate an expression that Python should evaluate. If actual curly braces need to be displayed, they can be written using double curly braces.

name = "Rahul"

# Double braces produce literal curly braces
print(f"{{name}} = {name}")

Output:

{name}  = Rahul

The double braces tell Python to display the braces as literal characters, while the single braces around name evaluate the variable.

Important Edge Cases

String formatting is straightforward in most situations, but a few special cases are important to understand. Knowing these behaviors helps prevent unexpected results when formatting real-world data.

• Width specifies the minimum space and does not truncate longer values.
• Formatting does not change the original value.
• Numeric format specifiers should be used with compatible numeric values.
• The percentage specifier multiplies the value by 100 before displaying it.
• Curly braces have a special meaning in f-strings and format() strings.
• An undefined variable used in an f-string raises a NameError.

For example, using an undefined variable inside an f-string produces an error.

name = "Rahul"

# age has not been defined before it is used
print(f"{name} is {age} years old.")

Output:

NameError: name 'age' is not defined

The error occurs because Python cannot find a variable named age when it evaluates the f-string.

Common Mistakes

Most string formatting mistakes happen because of incorrect placeholder syntax or unsuitable format specifications. These errors are easy to avoid once the basic structure of formatting is understood.

1. Forgetting the f Before an f-String: If you forget to add f before a string, Python treats expressions inside curly braces as ordinary text instead of evaluating them.
2. Using Incorrect Curly Braces: F-strings and the format() method use curly braces to identify placeholders. Missing or incorrectly placed braces can produce unexpected output or errors.
3. Using an Incompatible Numeric Format Specifier: Format specifiers such as .2f are intended for numeric values. Using them with an incompatible data type can raise a ValueError or TypeError, depending on the formatting method.
4. Forgetting That Positional Indexes Start at Zero: When using numbered placeholders with format(), the first argument has index 0, the second has index 1, and so on. Using the wrong index may display an unintended value or cause an error.
5. Expecting Width Specifications to Truncate Values: A width specification such as :10 sets a minimum field width; it does not limit the output to ten characters. Longer values can extend beyond the specified width.
6. Confusing Formatted Output with the Original Value: Formatting changes how a value is displayed, not necessarily the value itself. For example, formatting a number to two decimal places does not automatically change the original variable.
7. Multiplying a Percentage by 100 Twice: When using the percentage format specifier (%), Python multiplies the numeric value by 100 for display. Multiplying the value by 100 beforehand can produce an unexpectedly large percentage.

For example, forgetting the f prefix means that Python treats the braces as normal text.

name = "Rahul"

# Without the f prefix, {name} is not evaluated
print("Hello {name}")

Output:

Hello {name}

The correct approach is:

name = "Rahul"

# The f prefix enables expression evaluation inside braces
print(f"Hello {name}")

Output:

Hello Rahul

Important Rules to Remember

Understanding a few basic rules makes string formatting much easier to use. These rules cover the most common formatting operations used in Python programs.

1. Use Curly Braces for Placeholders: Use curly braces {} to insert values into strings with the format() method and f-strings.
2. Prefer f-Strings for Readable Code: Use f-strings when you want to insert variables or expressions directly into a string. They make modern Python code concise and easy to read.
3. Use format() When Needed: The format() method is useful when you want to fill placeholders with values supplied separately.
4. Use % Formatting for Older Code: The % operator is an older string formatting approach that you may encounter when working with existing Python programs.
5. Use a Colon Before Format Specifiers: Place a colon inside a placeholder before specifying formatting options, such as decimal precision, width, or alignment.
6. Use .2f for Two Decimal Places: The .2f format specifier displays a floating-point value with two digits after the decimal point.
7. Use a Comma for Thousands Separators: The , format specifier adds commas to large numbers, making values such as 1000000 easier to read as 1,000,000.
8. Use % to Format Percentages: The percentage format specifier converts a decimal value into a percentage for display. For example, 0.75 becomes 75.0%.
9. Choose the Right Alignment: Use < for left alignment, > for right alignment, and ^ for center alignment within a specified field width.
10. Remember That Width Is a Minimum: A width specification sets the minimum space reserved for a value. It does not truncate text or numbers that are longer than that width.
11. Formatting Does Not Automatically Change the Original Value: String formatting controls how a value appears in the output. It does not automatically modify the original variable.

Quick Reference Table

The following table provides a quick overview of commonly used string formatting features in Python. It can be used as a reference when choosing the appropriate formatting option.

Format	Purpose	Example
{}	Insert a value	f"{name}"
{:.2f}	Display two decimal places	f"{price:.2f}"
{:.1%}	Display percentage with one decimal	f"{score:.1%}"
{:,}	Add thousands separators	f"{number:,}"
{:02d}	Zero-pad an integer	f"{number:02d}"
{:10}	Set minimum width	f"{name:10}"
{:<10}	Left alignment	f"{name:<10}"
{:>10}	Right alignment	f"{name:>10}"
{:^10}	Center alignment	f"{name:^10}"
{:*^10}	Center with custom padding	f"{name:*^10}"
{:05}	Zero padding	f"{number:05}"
{:b}	Binary representation	f"{number:b}"
{:o}	Octal representation	f"{number:o}"
{:x}	Hexadecimal representation	f"{number:x}"

Conclusion

String formatting in Python provides a clean and flexible way to combine fixed text with dynamic values. It is useful for displaying information, calculations, prices, percentages, and structured console output.
The format() method provides a flexible placeholder-based approach, while f-strings provide a concise and readable syntax for modern Python programs. The older % operator is still useful when working with existing code.
By understanding format specifiers such as decimal precision, alignment, width, padding, separators, and number representation, we can create clear and professional output in Python programs.

Frequently Asked Questions

1. What is string formatting in Python?

String formatting is the process of inserting values or expressions into a string in a structured way. It allows programs to create dynamic and readable text without manually combining every value.

2. Which is better, format() or f-strings?

For modern Python code, f-strings are generally preferred because they are concise and easy to read. The format() method is still useful and important for understanding existing Python code and flexible formatting scenarios.

3. What does .2f mean in string formatting?

.2f tells Python to display a floating-point number with two digits after the decimal point. For example, 25.678 becomes 25.68 when formatted using .2f.

4. What does the comma format specifier do?

The comma format specifier adds thousands separators to numbers. For example, 1000000 can be displayed as 1,000,000.

5. What does the % format specifier do?

The % format specifier displays a decimal value as a percentage. For example, 0.75 formatted using % is displayed as 75%.