Python String Formatting Tutorial (With Examples)

String formatting is a fundamental concept in Python programming that allows you to create dynamic strings by embedding variables, values, and expressions within them. It’s an essential skill for anyone working with strings in Python, whether you’re building user interfaces, generating reports, or even just printing output. In this tutorial, we’ll cover various string formatting techniques, including the old-style % formatting and the newer str.format() method, as well as the more recent f-strings.

Table of Contents

1. Introduction to String Formatting
2. Old-Style String Formatting (%)
3. The str.format() Method
4. F-Strings: Formatted String Literals
5. Combining Formatting Techniques
6. Conclusion

1. Introduction to String Formatting

String formatting is the process of creating strings that include placeholders for variable values. These placeholders are later replaced with actual values before the string is displayed or used. This process allows you to dynamically generate strings based on the context of your program.

String formatting is particularly useful in scenarios such as:

• Creating user-friendly messages or prompts.
• Formatting data for output, such as dates, numbers, and currency.
• Generating formatted reports or documents.

Python provides several ways to achieve string formatting, each with its own syntax and features.

2. Old-Style String Formatting (%)

The old-style string formatting, commonly known as the % operator, is inherited from the C programming language. It involves using the % symbol to substitute placeholders in a string with actual values. The placeholders are represented by special format codes. Let’s look at an example:

name = "Alice"
age = 30

# Using old-style string formatting
message = "Hello, my name is %s and I am %d years old." % (name, age)
print(message)

In the above example, %s and %d are placeholders for a string and an integer, respectively. The values (name, age) are provided at the end of the string and are used to replace the placeholders.

Here are some common format codes used with the old-style string formatting:

• %s: String (or any object with a string representation)
• %d: Signed integer decimal
• %f: Floating-point decimal
• %x: Hexadecimal (integer) lowercase
• %X: Hexadecimal (integer) uppercase

While the old-style formatting is still supported, it’s considered less readable and versatile than the newer alternatives. Therefore, it’s recommended to use other formatting methods, such as str.format() and f-strings, which we’ll cover next.

3. The str.format() Method

Introduced in Python 2.6, the str.format() method provides a more flexible and readable way to format strings. It involves creating a string template with placeholders enclosed in curly braces {}. Values to be substituted are passed as arguments to the format() method.

Here’s how you can use the str.format() method:

name = "Bob"
score = 95.5

# Using str.format() method
message = "Student: {} | Score: {:.2f}".format(name, score)
print(message)

In the above example, {} and {:.2f} are placeholders. The first placeholder is replaced with the name variable, and the second placeholder is replaced with the score variable, formatted as a floating-point number with two decimal places.

You can also use positional and keyword arguments with str.format() for more control over the substitution:

# Using positional arguments
message = "Hello, {0}. You are {1} years old.".format("Alice", 25)
print(message)

# Using keyword arguments
message = "Hello, {name}. You are {age} years old.".format(name="Bob", age=30)
print(message)

4. F-Strings: Formatted String Literals

F-Strings, introduced in Python 3.6, provide an even more concise and readable way to format strings. They allow you to embed expressions directly into string literals, making the code more intuitive and closer to the final output. F-Strings are created by prefixing a string literal with the letter f or F.

Here’s how you can use f-strings:

name = "Eve"
gpa = 3.8

# Using f-strings
message = f"Student: {name} | GPA: {gpa:.2f}"
print(message)

In the above example, the variables name and gpa are directly embedded within the string using curly braces {}. The expression gpa:.2f formats the gpa variable as a floating-point number with two decimal places.

F-Strings are not only concise but also evaluated at runtime, allowing you to include expressions and even function calls directly within the string:

x = 10
y = 20

# Using f-strings with expressions
result = f"The sum of {x} and {y} is {x + y}."
print(result)

5. Combining Formatting Techniques

You can mix and match different formatting techniques to achieve your desired output. For instance, you can use f-strings with the str.format() method to create complex formatted strings:

name = "Charlie"
age = 28

# Combining f-strings and str.format()
message = f"Person: {name} | Age: {age} | Next Year: {age + 1}"
print(message)

You can also use formatting techniques for more advanced scenarios, such as formatting dates and times:

from datetime import datetime

current_date = datetime.now()

# Using str.format() to format dates
formatted_date = "Current date: {:%Y-%m-%d %H:%M:%S}".format(current_date)
print(formatted_date)

6. Conclusion

String formatting is a crucial skill in Python, allowing you to create dynamic and user-friendly strings for various purposes. In this tutorial, we covered three main formatting techniques: old-style string formatting using %, the str.format() method, and f-strings. Each technique has its strengths and use cases, and understanding them gives you the flexibility to choose the most suitable method for your needs.

Remember that clear and readable code is essential, so choose the formatting technique that best aligns with the context of your program and makes your code more maintainable. With these string formatting techniques in your toolkit, you’re well-equipped to handle various string manipulation tasks in Python.

By combining placeholders, expressions, and variables, you can create sophisticated and customized strings that convey information effectively. As you continue to develop your Python skills, mastering string formatting will significantly enhance your ability to create professional and polished applications.