Interpolating and Formatting Strings in Python

String interpolation involves generating strings by inserting other strings or objects into specific places in a base string or template. For example, here’s how you can do some string interpolation using an f-string:

In this quick example, you first have a Python variable containing a string object, "Bob" . Then, you create a new string using an f-string. In this string, you insert the content of your name variable using a replacement field. When you run this last line of code, Python builds a final string, 'Hello, Bob!' . The insertion of name into the f-string is an interpolation.

Note: To dive deeper into string interpolation, check out the String Interpolation in Python: Exploring Available Tools tutorial.

When you do string interpolation, you may need to format the interpolated values to produce a well-formatted final string. To do this, you can use different string interpolation tools that support string formatting. In Python, you have these three tools:

The first two tools support the string formatting mini-language, a feature that allows you to fine-tune your strings. The third tool is a bit old and has fewer formatting options. However, you can use it to do some minimal formatting.

Note: The built-in format() function is yet another tool that supports the format specification mini-language. This function is typically used for date and number formatting, but you won’t cover it in this tutorial.

In the following sections, you’ll start by learning a bit about the string formatting mini-language. Then, you’ll dive into using this language, f-strings, and the .format() method to format your strings. Finally, you’ll learn about the formatting capabilities of the modulo operator.

Using F-Strings to Format Strings

Python 3.6 added a string interpolation and formatting tool called formatted string literals , or f-strings for short. As you’ve already learned, f-strings let you embed Python objects and expressions inside your strings. To create an f-string, you must prefix the string with an f or F and insert replacement fields in the string literal. Each replacement field must contain a variable, object, or expression:

In the first example, you define an f-string that embeds the number 42 directly into the resulting string. In the second example, you insert two variables and an expression into the string.

Formatted string literals are a Python parser feature that converts f-strings into a series of string constants and expressions. These are then joined up to build the final string.

>>> f"Debit: ${debit:.2f}, Credit: ${credit:.2f}, Balance: ${credit - debit:.2f}"
'Debit: $300.00, Credit: $450.00, Balance: $150.00'
In this example, note that each replacement field contains a string that starts with a colon. That’s a format specifier. The .2f part tells Python that you want to format the value as a floating-point number (f) with two decimal places (.2).
Note: To learn more about the formatting mini-language and its syntax, check out the Python’s Format Mini-Language for Tidy Strings tutorial. If you’re interested in formatting floating-point numbers specifically, then you can also read How to Format Floats Within F-Strings in Python.
The string formatting mini-language is a powerful tool with several cool features, including the following:
Strings alignment
Conversion between input objects’ types
Numeric values formatting
Dynamic formatting
In the following sections, you’ll explore how to use f-strings, the .format() method, and the string formatting mini-language to format the values that you insert into your strings through interpolation.

 1def build_student_report(student):
 2    report_header = f"Progress Report. Student: {student['name']}"
 4    total = sum(subject["grade"] for subject in student["subjects"])
 5    average = total / len(student["subjects"])
 6    average_report = f"Average: {average:.2f} / 100\n"
 8    subject_report = "Course Details:\n"
 9    for subject in student["subjects"]:
10        subject_report += (
11            f"{subject['name']:<15} "
12            f"Grade: {subject['grade']:3d} "
13            f"Comment: {subject['comment']}\n"
14        )
16    return f"""
17{report_header}
18{average_report}
19{subject_report}
20Thank you for reviewing the progress report.
21    """
In this function, you’re doing several things. Here’s a line-by-line breakdown:
Line 2 defines a heading for the report.
Line 4 sums all the grades.
Line 5 computes the average of the grades.
Line 6 defines the average grade subreport. In this part of the report, you use the .2f format specifier to express the average grade as a floating-point number with two decimal places.
Line 8 defines the first line of the subject subreport.
Line 9 starts a loop over the subjects.
Line 10 adds more information to the subject subreport.
Line 11 formats the subject’s name. To do this, you use the <15 format specifier, which tells Python to align the name to the left within 15 characters.
Line 12 formats the grade. In this case, the 3d format specifier tells Python to display the grade using up to three characters. A leading space is used if the grade doesn’t have three digits.
Line 13 adds the comment part.
Lines 16 to 21 build the final report and return it to the caller.
Now that you’ve gone through the complete code, it’s time to try out your function. Go ahead and run the following code:
    Python
    
>>> from grades_report_v1 import build_student_report
>>> print(build_student_report(student))
Progress Report. Student: John Doe
Average: 85.75 / 100
Course Details:
Mathematics     Grade:  88 Comment: Excellent improvement.
Science         Grade:  92 Comment: Outstanding performance.
History         Grade:  78 Comment: Needs to participate more.
Art             Grade:  85 Comment: Very creative.
Thank you for reviewing the progress report.
Your report looks pretty nice! It provides general information about the student at the top and grade details for every subject.
 
 
 
 Remove ads

Using str.format() to Format Strings

SUBJECT_TEMPLATE = "{name:<15} Grade: {grade:3} Comment: {comment}"
REPORT_TEMPLATE = """
Progress Report. Student: {name}
Average: {average:.2f} / 100
Course Details:
{subjects_report}
Thank you for reviewing the progress report.
def build_student_report(student):
    data = {
        "name": student["name"],
        "average": sum(subject["grade"] for subject in student["subjects"])
        / len(student["subjects"]),
        "subjects_report": "\n".join(
            SUBJECT_TEMPLATE.format(**subject)
            for subject in student["subjects"]
    return REPORT_TEMPLATE.format(**data)
In the first lines of code, you create string templates to display the information about each subject and also the final report. In build_student_report(), you create a dictionary with the required data to build the student report. Next, you interpolate the data into the report template using .format() with the dictionary as an argument.
Note that to fill the string templates, you use the ** operator to unpack the data from the input dictionary.
 
 
 




    
 Remove ads

Formatting Strings With the Modulo Operator ( % )

>>> # Named replacement fields
>>> jane =  {"first_name": "Jane", "last_name": "Doe"}
>>> "Full name: %(first_name)s %(last_name)s" % jane
'Full name: Jane Doe'
>>> # Minimal width of 15 chars
>>> "%-15f" % 3.1416  # Aligned to the left
'3.141600       '
>>> "%15f" % 3.1416  # Aligned to the right
'       3.141600'
>>> # Dynamic width
>>> width = 15
>>> "%-*f" % (width, 3.1416)
'3.141600       '
>>> "%*f" % (width, 3.1416)
'       3.141600'
>>> # Precision
>>> "%.2f" % 3.141592653589793
'3.14'
>>> "%.4f" % 3.141592653589793
'3.1416'
>>> "%.8f" % 3.141592653589793
'3.14159265'
In the first example, you use named replacement fields in parentheses and a dictionary to provide the values you want to interpolate. In the second example, you provide a minimum width for your string in characters.
The third example is a dynamic variation of the second. Note how the * symbol allows you to insert the desired width dynamically.
Finally, you use the precision option to display a floating-point number using different precisions. You use two, four, and eight digits after the decimal separator, respectively.
Unfortunately, the modulo operator doesn’t support the string formatting mini-language, so if you use this tool to interpolate and format your strings, then your formatting options are more limited than when you use f-strings or format().
 
 
 
 Remove ads

Deciding Which String Formatting Tool to Use

Conclusion