A Beginner’s Guide to String Formatting in Python for Clean Code

String Formatting in Python refers to the method of embedding variables, expressions, or values into strings, making the output dynamic and more readable. Instead of manually concatenating values with operators, Python offers several tools to integrate variables into strings seamlessly, which helps in building cleaner, more efficient, and easily maintainable code.

In this blog, you’ll explore string formatting in Python techniques. These include f-strings, the % operator, .format(), Template Class, and center().

The Five String Formatting Methods in Python

String Formatting in Python can be achieved in multiple ways, and understanding the differences between each method helps you decide which to use in a particular situation. From the traditional % operator to the more modern f-strings, Python offers a range of formatting options, each with its strengths and weaknesses.

String Formatting in Python is more than just inserting values into strings; it's about selecting the right method for clean, efficient, and secure code. Here are three specialized courses that can help you:

• Masters in Data Science Degree
• Executive Diploma in Data Science & AI with IIIT-B
• Executive Diploma in Machine Learning and AI with IIIT-B

Let's discuss the five major methods of String Formatting in Python, understanding when to use them and their limitations.

A. Formatting with the % Operator (Old Style)

The % operator for string formatting, often called the "old style" or "printf-style," was introduced in earlier Python versions. This method is similar to C's printf function, where placeholders in the string are replaced by values provided in a tuple.

Here’s a basic example:

name = "Alice"
age = 30
print("Name: %s, Age: %d" % (name, age))

Output:

Name: Alice, Age: 30

This method allows you to insert variables of different types into a string using format codes like %s for strings and %d for integers. Despite its historical importance, the % operator is now considered less readable and prone to errors when working with complex expressions.

Use Cases:
The % operator is best suited for small, simple scripts or maintaining legacy Python code. It is still useful when working with older systems or projects that rely on this syntax. However, as your projects grow, you may find it harder to maintain due to its limitations in readability and flexibility.

Limitations:
Though it works, String Formatting in Python using the % operator is not ideal for complex data types or dynamic expressions. It lacks the readability and flexibility of more modern methods like f-strings or .format(). For example, you cannot easily specify the position of arguments or format complex objects without introducing additional logic.

Also Read: Understand All Types of Operators in Python with Examples

B. Using str.format() Method

The .format() method was introduced in Python 2.6 and 3.0 to address the limitations of the % operator. It provides more flexibility and control over string formatting. With .format(), you can position and format variables in the string dynamically.

Here’s an example of how the .format() method works:

name = "Alice"
age = 30
print("Name: {}, Age: {}".format(name, age))

Output:

Name: Alice, Age: 30

The .format() method offers the ability to reorder arguments and include named placeholders, which makes it a more flexible solution for dynamic string construction.

Features:

• Supports both positional and keyword arguments.
• Allows for complex formatting like aligning text, padding numbers, or formatting decimal places.

Use Cases:
The .format() method is ideal for situations where you need more control over how your strings are formatted. For example, you might use .format() when generating user reports, logging data, or handling multiple variables within a single string.

Limitations:
Though more flexible than the % operator, .format() is slightly more verbose than f-strings. Additionally, it may still feel cumbersome when dealing with simple, static strings. Also, it requires explicit references to placeholder positions or variable names, which can make the code slightly more difficult to read.

Also Read: Type Conversion in Python Explained with Examples

C. Formatted String Literals (F-Strings)

Introduced in Python 3.6, f-strings (formatted string literals) provide the most concise and efficient way to embed expressions inside string literals. They are highly readable and offer better performance compared to .format() and % formatting.

Here’s how f-strings work:

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

Output:

Name: Alice, Age: 30

With f-strings, the variables are directly embedded inside the string using {}. This makes the code cleaner and more efficient, as Python evaluates the expressions inside the curly braces and directly formats the output.

Advantages:

• Cleaner syntax: The string formatting is simpler and more intuitive.
• Better performance: Since f-strings are evaluated at runtime, they offer superior performance over both the % operator and .format().
• Supports inline expressions and debugging: You can embed complex expressions and even perform calculations inside the curly braces.

Use Cases:
F-strings are recommended for any modern Python codebase. Whether you’re building web applications, performing data analysis, or writing automation scripts, f-strings should be your go-to choice due to their readability and speed.

Limitations:
F-strings are only available in Python 3.6 and above. If you’re working with older Python versions, you’ll need to rely on % or .format().

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

D. String Template Class

The Template class from the string module provides a simple, secure way to perform string substitutions. It’s particularly useful when working with untrusted input or building user-facing applications.

Here’s an example:

from string import Template
t = Template("Name: $name, Age: $age")
print(t.substitute(name="Alice", age=30))

Output:

Name: Alice, Age: 30

The Template class uses $ placeholders, which makes it different from the other methods. You can then call the substitute() method to replace these placeholders with actual values.

Advantages:

• Security: Unlike other methods, the Template class helps prevent code execution vulnerabilities, making it ideal for handling user inputs safely.
• Simplicity: It’s simpler than other methods if all you need is basic substitution without complex formatting.

Limitations:
The Template class is less flexible than f-strings and .format(). It doesn’t support positional arguments or complex expressions, which limits its utility in advanced scenarios.

Also Read: Python Split() Function: Syntax, Parameters, Examples

E. Using center() String Method

The center() method in Python is used to center-align strings to a specific width, padding them with a specified character. While this method isn't a typical "formatting" tool like the others, it's useful when working with text that needs to be aligned in a certain way.

Example:

text = "Python"
print(text.center(20, '-'))

Output:

------Python------

This method adds padding around the string to ensure that it is centered within the specified width (20 in this case).

Use Cases:
The center() method is most commonly used for formatting output in console applications or reports. For instance, when generating headers for tables, reports, or logs, centering the text ensures a clean, organized output.

Limitations:
The center() method cannot be used to embed variables or perform complex formatting tasks. It’s primarily for text alignment, which limits its flexibility in more dynamic applications.

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

Having reviewed the various String Formatting in Python methods, let’s now compare them side by side to help you choose the most suitable one for your projects.

Comparative Analysis of Formatting Methods

upGrad’s Exclusive Data Science Webinar for you –

ODE Thought Leadership Presentation

Understanding how different String Formatting in Python methods stack up against each other is key to mastering Python and writing efficient, clean code. Whether you’re working on a small script or large-scale applications, choosing the right formatting method can impact both performance and readability. 

Let’s break down the String Formatting in Python techniques on various crucial metrics: readability, performance, security, and flexibility.

1. Readability

When it comes to readability, you want your code to be as clear and intuitive as possible. A clean codebase makes debugging easier and increases collaboration.

•  F-strings

F-strings win the readability race. They allow you to embed variables and expressions directly within the string using {}. It’s simple, clear, and intuitive. For example:

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

Output:

Name: Alice, Age: 30

• With f-strings, the code speaks for itself. It’s easy to understand, and there’s no need to dig deeper to understand the formatting logic.
• str.format()

str.format() is also a clear option, but it’s more verbose than f-strings. While it gives more flexibility for complex formatting, it’s a bit longer. Still, it's widely used and enhances readability over the % operator.

name = "Alice"
age = 30
print("Name: {}, Age: {}".format(name, age))

Output:

Name: Alice, Age: 30

• % Operator

The % operator is harder to read. It's an older style and works, but it’s not as clean as the newer methods. Using %s, %d, etc., for formatting makes the code feel less intuitive, especially for those unfamiliar with C-style formatting.

name = "Alice"
age = 30
print("Name: %s, Age: %d" % (name, age))

Output:

Name: Alice, Age: 30

• Template Class

The Template Class uses $ to indicate variable placeholders. While simpler for user input scenarios, it doesn’t read as easily as the other options for general string formatting tasks.

from string import Template
t = Template("Name: $name, Age: $age")
print(t.substitute(name="Alice", age=30))

Output:

Name: Alice, Age: 30

Also Read: Python Program for Reverse String

2. Performance

In performance, you’re looking at how quickly your formatting method can execute, particularly when dealing with large datasets or complex applications.

• F-strings

F-strings are the clear winner here. They are evaluated at runtime, which makes them the fastest option. Their direct evaluation ensures minimal overhead. If performance is critical (like in data-heavy scripts or games), f-strings should be your go-to.

• str.format()

str.format() is slower than f-strings but still quite efficient. While the overhead is not huge in most cases, when working with large datasets or in performance-critical applications, you may notice a slight lag compared to f-strings.

• % Operator

The % operator performs worse than both f-strings and .format(). It’s slower, especially when handling large amounts of data or complex objects. This is due to its less optimized string parsing and substitution logic.

• Template Class

Template Class has the worst performance. It involves method calls like substitute() and adds overhead compared to f-strings or .format(). If performance is crucial, avoid using this method.

Also Read: Python Program to Convert List to String

3. Security

Security in String Formatting in Python is vital when handling untrusted input or dealing with sensitive information. Using methods that allow code execution or unsafe evaluation can be risky.

• Template Class

The Template Class is the safest method for string substitution. It avoids the possibility of arbitrary code execution, making it the best option when dealing with user inputs or untrusted sources. The $ placeholders only allow safe, simple substitutions without evaluating any expressions.

• F-strings and str.format()

Both f-strings and str.format() are more flexible, allowing you to execute expressions inside the curly braces. While this is great for complex formatting, it opens the door for security issues if user input is not sanitized properly.
For instance, if a user submits a string with dangerous content like "{__import__('os').system('rm -rf /')}", it could lead to unwanted code execution. Always sanitize inputs when using these methods.

• % Operator

The % operator shares a similar security risk with f-strings and .format(), though it’s not as flexible. It doesn’t allow arbitrary expressions but still requires care when working with user inputs.

Also Read: Top 25 Artificial Intelligence Projects in Python For Beginners

4. Flexibility

How adaptable is a formatting method when you need to handle dynamic, complex data? Let’s see how the methods stack up.

• F-strings

F-strings offer the best flexibility. You can embed expressions directly inside the curly braces, which means you can calculate values, call functions, or even perform operations on the fly. It gives you full control over the output, making it the best choice for dynamic data.

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

Output:

The sum of 10 and 5 is 15

• str.format()

str.format() is highly flexible as well. You can reorder arguments, use keyword arguments, and apply specific formatting options like padding, alignment, and precision. While it’s not as sleek as f-strings, it offers enough flexibility for most use cases.

• % Operator

The % operator offers limited flexibility. It only works with specific format codes and cannot handle expressions or operations inside the placeholder. This makes it less adaptable than f-strings or .format().

• Template Class

The Template Class is the least flexible. It only allows basic substitutions using placeholders like $variable, and it doesn’t support more advanced formatting options such as padding or data manipulation. This makes it less useful for complex string formatting tasks.

Also Read: Top 50 Python Project Ideas with Source Code in 2025

Having understood string formatting, enhance your Python expertise with upGrad’s expert-led programs and real-world applications.

Strengthen Your Python Skills with upGrad!

Understanding string formatting in Python is essential for writing clean, efficient, and readable code. Using f-strings, str.format(), or the Template Class, you can easily handle dynamic data, avoid errors, and produce user-friendly outputs. For best results, use f-strings for simplicity, str.format() for flexibility, and the Template Class for secure string handling in user-facing applications.

If you're looking to fill knowledge gaps or need expert guidance, upGrad's courses offer structured learning and mentorship, helping you boost your skills and advance your career in Python development.

In addition to the above-mentioned specialized courses, here are some foundational free courses to help you get started.

• Case Study Using Tableau, Python, and SQL
• Learn Python Libraries: NumPy, Matplotlib & Pandas
• Data Structures & Algorithms
• NodeJS for Beginners
• Object-Oriented Analysis and Design for Beginners

Feeling uncertain about your next step? Receive personalized career counseling to discover the ideal opportunities for you. Visit upGrad’s offline centers for expert mentorship, hands-on workshops, and networking sessions to connect you with industry leaders!

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

Reference:
https://realpython.com/python-f-strings/