String Formatting in Python: 5 Comprehensive Techniques and Best Practices

String formatting in Python is best done using f-strings, which offer a cleaner and more readable way to insert variables into strings. Unlike older methods like % formatting or .format(), f-strings are more concise and improve code maintainability.

One of the best solutions is the python f-string, which simplifies the process and improves readability. In this guide, you’ll look at five comprehensive techniques for string formatting in Python, helping you write more efficient and cleaner code for your projects.

Let’s dive into the details!

What Is String Formatting in Python?

String formatting in Python is the process of inserting values into strings to dynamically create output. 

Whether you're working with user inputs, data processing, or generating dynamic outputs, knowing how to format strings efficiently can significantly improve your code.

Python offers several methods for string formatting, each suited to different use cases:

1. Old-style formatting (using the % operator)
2. str.format() method
3. Python f-string (introduced in Python 3.6)
4. Template strings (from the string module)
5. Concatenation (basic method of joining strings)

Each method offers flexibility, but the newer techniques like python f-string have made formatting more readable and concise. 

Also Read: A Guide on Python String Concatenation [with Examples]

Let's walk through the different approaches:

How Does the Modulo Operator (%) Work in String Formatting?

The modulo operator (%) is the oldest method of string formatting in Python. This technique is similar to C-style string formatting and was widely used in earlier versions of Python before newer and more readable options like python f-strings became available. 

Although it's considered outdated now, understanding how it works is still useful, especially when working with legacy code or older Python versions.

The % operator uses conversion specifiers to format data types into strings. Here’s how the basic syntax works: 

"String with % formatting: %specifier" % (value)

In the above syntax:

• The string contains a specifier (like %s or %d).
• The % operator is used to format the value and insert it into the string.

Common Conversion Specifiers

These specifiers are used to indicate the type of data being formatted:

• %s: For strings
• %d: For integers
• %f: For floating-point numbers

Example: 

# Using %s for strings
name = "Ajay"
print("Hello, %s!" % name)  

Output: 

Hello, Ajay!

Named Replacement Fields

With the % operator, you can also use dictionaries to perform named replacement. 

You can pass a dictionary to the % operator, where the keys in the dictionary correspond to the placeholders in the string.

Example of a Named Replacement Field: 

# Using named fields with dictionaries
data = {'name': Ajay, 'age': 30}
print("Hello, %(name)s! You are %(age)d years old." % data)  

Output: 

Hello, Ajay! You are 30 years old.

Advantages and Limitations

Advantages:

• Familiarity: If you're coming from a C programming background, the % operator may seem familiar.
• Quick for Simple Formatting: It’s simple and concise for formatting small strings and numbers.

Limitations:

• Limited Readability: When working with more complex strings, it can become difficult to understand, especially with multiple placeholders.
• Lack of Flexibility: Compared to python f-strings, it offers less flexibility and is prone to errors when working with many variables.
• Outdated: Python f-string provides a cleaner and more efficient way to format strings in Python 3.6+.

Enroll in upGrad's Python for machine learning courses and learn advanced techniques like f-strings, data manipulation, and AI-driven fraud detection.

Next, let's explore how to use the .format() method for string formatting and see how it improves readability compared to the % operator.

How to Use the .format() Method for String Formatting?

The .format() method is a powerful way to handle string formatting in Python. Introduced in Python 2.7 and 3.0, it offers a cleaner and more flexible approach compared to the % operator. 

The .format() method allows you to insert values into a string using placeholders, improving readability and maintainability.

Syntax: 

"Some string {}".format(value)

You can use curly braces {} as placeholders in the string, and the format() method will replace them with the provided arguments.

Positional and Keyword Arguments

One of the main benefits of the .format() method is its support for both positional and keyword arguments, making it more flexible.

Positional Arguments:

Positional arguments are used when you want to reference variables in the order they appear in the format() method. 

name = "Ajay"
age = 30
print("Hello, {}! You are {} years old.".format(name, age))

Output: 

Hello, A! You are 30 years old.

Explanation

• The first placeholder is replaced by name and the second by age.
• Positional arguments allow you to control the order of insertion.

Kickstart your Python journey with this free beginner-friendly Programming with Python course! Learn the fundamentals of programming and start building your coding skills today!

Keyword Arguments:

Keyword arguments are useful when you want to specify the names of variables explicitly in the string formatting.

Example: 

print("Hello, {name}! You are {age} years old.".format(name="Ajay", age=30))

Output:

Hello, Ajay! You are 30 years old.

With keyword arguments, you directly specify the names of the variables, which makes the code more readable.

Mini-Language Features in .format()

The .format() method enables advanced formatting, such as number formatting, alignment, and decimal precision.

Example: 

# Formatting numbers
pi = 3.1415926535
print("The value of pi is: {:.2f}".format(pi))  # Limiting to 2 decimal places
# Aligning text
text = "Python"
print("{:<10} is fun!".format(text))  # Left-align text within a 10-character space
# Padding with zeros
num = 7
print("{:05}".format(num))  # Pad with zeros to make the number 5 digits

Output:

The value of pi is: 3.14
Python     is fun!
00007

Explanation: 

• .2f: Limits the floating-point number to 2 decimal places.
• <10: Left-aligns the text and pads it to a width of 10 characters.
• {:05}: Pads the integer with leading zeros to make it 5 digits wide.

Practical Use Cases

The .format() method is especially helpful in scenarios where you need to build dynamic strings for logging, user messages, or reports.

Example: 

transaction = {"amount": 250, "currency": "INR", "status": "successful"}
print("Transaction of {amount} {currency} was {status}.".format(**transaction))

Output: 

Transaction of 250 INR was successful.

Also Read: Types of Data Structures in Python: List, Tuple, Sets & Dictionary

Now, let's explore python f-strings, the most efficient and modern method for string formatting in Python.

How Do Python F-Strings Work in String Formatting?

Python's f-strings provide a more readable and concise way to format strings compared to traditional methods. Introduced in Python 3.6, f-strings allow embedding expressions inside string literals. They are prefixed with the letter 'f' and enable you to insert variables and expressions directly within a string.

Embedding Expressions in F-Strings

You can directly embed variables or expressions inside a string using curly braces {} within the f-string. This makes string formatting in Python more dynamic and expressive. 

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

Output: 

My name is Ajay and I am 30 years old.

The expressions {name} and {age} are evaluated and replaced with their values directly in the string.

The f-string makes it clear and simple, unlike older methods like concatenation or str.format().

Formatting Numbers with F-Strings

F-strings allow you to format numbers by specifying how they should appear, including controlling decimal places or adding commas for thousands. 

value = 12345.6789
formatted_number = f"{value:,.2f}"
print(formatted_number)

Output:

12,345.68

Explanation: 

• The :,.2f specifies that the number should include commas and display two decimal places.
• F-strings make it easy to format numbers to fit specific needs like rounding or adjusting the display style.

Aligning and Padding Text with F-Strings

Aligning text is another handy feature in f-strings. You can pad text for alignment, which is useful when formatting tables or columns. 

text = "Hello"
aligned_text = f"{text:<10}World"  # Left-align text
print(aligned_text)

Output: 

Hello      World

Explanation: 

• The <10 inside the f-string ensures that the word "Hello" takes up 10 spaces, padding it with spaces on the right.
• You can use > for right alignment and ^ for centering text.

Calling Functions Inside F-Strings

You can even call functions inside f-strings. This makes it possible to embed function outputs directly within your formatted string. 

def get_greeting(name):
    return f"Hello, {name}"
formatted_string = f"{get_greeting('Neha')}, welcome!"
print(formatted_string)

Output: 

Hello, Neha, welcome!

Explanation: 

• The get_greeting('Neha') function is called and its output is directly inserted into the string.
• This demonstrates how versatile f-strings can be when dealing with dynamic content.

Using Dictionaries and Objects in F-Strings

F-strings work seamlessly with dictionaries and objects, making it easy to retrieve and display their data. 

person = {'name': 'Rahul', 'age': 28}
formatted_string = f"{person['name']} is {person['age']} years old."
print(formatted_string)

Output: 

Rahul is 28 years old.

Explanation: 

• You can access dictionary values directly within the f-string using the key names.
• Similarly, you can use object attributes in f-strings, which makes them a powerful tool for formatting complex data.

Multi-line Formatting with F-Strings

You can also use f-strings for multi-line formatting. This allows you to neatly format longer strings across multiple lines.

name = "David"
age = 35
formatted_string = f"""
Hello {name},
You are {age} years old.
"""
print(formatted_string)

Output: 

Hello David,
You are 35 years old.

Explanation: 

• The triple quotes """ allow for multi-line formatting.
• This feature is useful when you want to maintain readability with longer strings that span multiple lines.

Also Read: 16+ Essential Python String Methods You Should Know (With Examples)

With these techniques, Python f-strings make string formatting easier and more powerful. Next, let's look at an alternative method for string formatting using the string.Template.

How Do String Templates Using string.Template Work?

Python's string.Template offers a simpler approach to string formatting. While f-strings provide more flexibility, string.Template is a great option for applications that need a more basic and readable template system. It's especially useful when you want to perform substitutions safely, without the complexity of embedding expressions.

Defining a Template String

To use string.Template, you first define a template string with placeholders marked by a dollar sign $. 

from string import Template
template = Template("Hello, $name!")
formatted_string = template.substitute(name="Parth")
print(formatted_string)

Output: 

Hello, Parth!

Explanation: 

• The $name placeholder in the template string is replaced by the value "Parth".
• string.Template offers a clear and straightforward way to format strings, especially useful for simple text substitutions.

Creating a Template Object

You create a Template object by passing a string with placeholders to the Template class. 

template = Template("Your age is $age.")

This object now holds the template string, ready to be formatted with values.

Substituting Values with substitute()

To replace placeholders with actual values, use the substitute() method, which takes keyword arguments to perform the replacements. 

template = Template("The temperature is $temp degrees.")
formatted_string = template.substitute(temp=72)
print(formatted_string)

Output: 

The temperature is 72 degrees.

Explanation: 

• The substitute() method replaces $temp with the value 72.
• This method is simple, making string.Template a good choice for templates without complex expressions.

Using safe_substitute() for Error-Free Substitutions

The safe_substitute() method behaves similarly to substitute(), but it won't raise an error if a placeholder is missing. Instead, it leaves the placeholder as is. 

template = Template("Hello, $name. You are $age years old.")
formatted_string = template.safe_substitute(name="Sneha")
print(formatted_string)

Output: 

Hello, Sneha. You are $age years old.

Explanation: 

• Notice that the $age placeholder wasn't replaced because we didn't provide a value for it.
• This feature prevents your program from crashing when there are missing values.

Working with Placeholders

In string.Template, placeholders can be more complex, including fields like $person.name for dictionary-like substitution. However, the primary use is for simple variable replacements. 

template = Template("Name: $name, Age: $age")
formatted_string = template.substitute(name="Grace", age=25)
print(formatted_string)

Output:

Name: Grace, Age: 25

Explanation: 

• This shows how string.Template works with more than one placeholder.
• The placeholders are filled in with corresponding values passed to substitute().

Advantages and Limitations of string.Template

While string.Template offers a simpler syntax and is easy to use, it has limitations:

• Advantages:
  • Simple and readable syntax.
  • Safe substitutions with safe_substitute().
• Limitations:
  • Less flexible than f-strings for complex formatting.
  • Cannot directly embed expressions or functions.

Also Read: Python Program to Convert List to String

Now let's look at how concatenation and interpolation work in Python.

upGrad’s Exclusive Data Science Webinar for you –

ODE Thought Leadership Presentation

How Do Concatenation and Interpolation Work in Python?

Concatenation and interpolation are fundamental methods for combining strings in Python. While they both serve the purpose of merging text, they offer different syntaxes and use cases.

Concatenating Strings Using the + Operator

The + operator allows you to concatenate two or more strings by simply adding them together. This is one of the simplest ways to combine strings in Python. 

first_name = "Jai"
last_name = "Dan"
full_name = first_name + " " + last_name
print(full_name)

Output:

Jai Dan

Explanation: 

• The + operator joins the first_name, a space, and the last_name together.
• It's straightforward but can become cumbersome when dealing with many strings or variables.

Combining Strings with Variables

Concatenation can also be used with variables, making it more dynamic for creating sentences or messages. 

city = "New Delhi"
country = "India"
location = "I live in " + city + ", " + country + "."
print(location)

Output: 

I live in New Delhi, India.

Explanation: 

• Here, the variables city and country are combined into a full sentence using concatenation.
• The method is simple but can become hard to read with more complex expressions.

Using String Interpolation with the % Operator

String interpolation using the % operator allows you to insert values into a string in a more structured way, somewhat like f-strings but with older syntax. 

name = "Ajay"
age = 25
greeting = "Hello, %s! You are %d years old." % (name, age)
print(greeting)

Output:

Hello, Ajay! You are 25 years old.

Explanation: 

• The %s is a placeholder for a string, and %d is used for integers.
• This older approach is less flexible than f-strings but still widely used in many Python projects.

Concatenating Strings in Loops

Concatenation can be particularly useful in loops when constructing larger strings from smaller parts. 

words = ["Python", "is", "great"]
sentence = ""
for word in words:
    sentence += word + " "
print(sentence.strip())

Output: 

Python is great

Explanation: 

• The loop adds each word to the sentence variable, creating a full sentence by the end.
• While this works, it’s not always efficient for large strings due to the overhead of creating new strings on each iteration.

Handling Complex Data Types in Concatenation

When concatenating non-string data types like integers or lists, Python will convert them into strings. 

age = 30
hobbies = ["reading", "cycling"]
info = "Age: " + str(age) + ", Hobbies: " + ", ".join(hobbies)
print(info)

Output: 

Age: 30, Hobbies: reading, cycling

Explanation: 

• str(age) converts the integer into a string, and ", ".join(hobbies) joins the list into a string with commas.
• This method can be very useful for creating more complex string outputs.

Performance Implications of Concatenation

While concatenating strings with the + operator is simple, it can be inefficient for large datasets or in loops. Each concatenation creates a new string, leading to higher memory usage.

• For better performance in loops or with large strings, consider using a list and ''.join() instead.
• This minimizes memory overhead and is faster in scenarios involving many concatenations.

Also Read: Operators in Python: A Beginner’s Guide to Arithmetic, Relational, Logical & More

Now that we've covered concatenation and interpolation, let's move on to comparing different string formatting methods to understand their pros and cons.

Comparing Different String Formatting Methods

The best choice for string formatting depends on your specific use case, including factors like readability, performance, and flexibility. 

Let’s look at the comparison below of the five popular string formatting methods. 

The more you practice using different string formatting methods like f-strings, str.format(), and string.Template, the more comfortable and confident you'll become in writing clean, efficient, and maintainable Python code for various applications.

How upGrad Can Help You Master Python?

To truly excel in Python string formatting, mastering the right programming foundations is essential. 

Learning advanced Python techniques will strengthen your coding skills, while courses on application development will deepen your understanding of how to use string formatting in complex projects, equipping you to write clean, efficient, and scalable code.

Here's a selection of courses to help you level up:

• Learn Basic Python Programming  
• Post Graduate Certificate in Data Science & AI (Executive) 
• Post Graduate Certificate in Machine Learning and Deep Learning (Executive) 
• Fundamentals of Deep Learning and Neural Networks  

You can also get personalized career counseling with upGrad to guide your career path, or visit your nearest upGrad center and start hands-on training today! 

Unlock the power of data with our popular Data Science courses, designed to make you proficient in analytics, machine learning, and big data!

Explore our Popular Data Science Courses

Elevate your career by learning essential Data Science skills such as statistical modeling, big data processing, predictive analytics, and SQL!

Top Data Science Skills to Learn

Stay informed and inspired  with our popular Data Science articles, offering expert insights, trends, and practical tips for aspiring data professionals!

Read our popular Data Science Articles