Format strings in Python 3: A quick guide

Tim Berners-Lee, the inventor of the World Wide Web, said, “Data is a precious thing and will last longer than the systems themselves.” In modern software systems, data is often represented as strings. They represent textual information in different contexts, such as user inputs, database records, URLs, files, paths, and etc.

Key takeaways:

• Formatting strings makes your code cleaner and easier to read, helping you present data in a clear and user-friendly way.

• Python offers different string formatting techniques: the older % operator, the str.format() method, and modern f-strings. Each has its strengths and use cases.

• Introduced in Python 3.6, f-strings simplify string formatting by allowing direct embedding of variables and expressions, improving readability and reducing verbosity.

Why is string formatting important?#

As a programmer, you often need to structure strings into a specific format to make them more readable and meaningful for users or systems. A few benefits of formatting strings are as follows:

• It allows variable(s) and expression(s) to be embedded directly within the string.

• It improves code readability by allowing developers to easily format data like numbers, dates, and text without complex concatenation.

• It simplifies tasks such as debugging, creating user-friendly outputs, or displaying dynamic application content.

If you’re new to Python and want to learn more about it, check out this comprehensive Python course.

String formatting in Python 2.x#

Before Python 3, there were two main legacy methods for formatting strings:

1. The % operator

2. The str.format() method

Method 1: The % operator#

The % operator was the primary method for the old-style string formatting. This approach, reminiscent of C-style formatting, used placeholder symbols within a string:

The "Language: %s, Version: %.2f" string (at line 4) contains two placeholders: %s (for a string) and %.2f (for a decimal number up to 2 decimal places). The % operator replaces the placeholders with the values as:

• %s is replaced by the value of name.

• %.2f is replaced by the value of version.

It is familiar to those with experience in C or similar languages but is less readable, especially for complex formatting needs.

Method 2: The str.format() method#

Python 2.6 introduced the str.format() method. See the code below.

The "Language: {}, Version: {}".format(name, version) string (at line 4) contains two placeholders: {}. The format() method replaces them with the values as follows:

• The first {} is replaced by the value of name.

• The second {} is replaced by the value of version.

It provides more control and flexibility over string formatting than the % operator. Look at the code below.

• Positional arguments: You can specify the position of the arguments in the placeholders {}. Line 4 formats the strings as follows:

  • {0}: It refers to the first argument passed to the format() function.

  • {1}: It refers to the second argument passed to the format() function.

• Reordering or reusing arguments: You can reorder or reuse the arguments multiple times in the format string. Line 5 formats the strings as follows:

  • Version: {1}: It first inserts the second argument passed to the format() function.

  • Language: {0}: In second place, it inserts the first argument passed to the format() function.

  • Language again: {0}: It again inserts the first argument {0} in the end.

• Padding: You can add padding to align values. Line 6 formats the string as follows:

  • {:>10}: It right-aligned the first argument within a field that is 10 characters wide. Any extra space will be filled with spaces on the left.

  • {:<5}: It left-aligned the second argument within a field that is 5 characters wide. Any extra space will be filled with spaces on the right.

With the str.format() method, strings are more readable and flexible than the % operator but are more verbose and less intuitive than Python 3’s f-strings.

Method 3: Formatting with Python 3’s f-strings#

Python 3 improves string formatting by introducing f-strings, specifically in Python 3.6.

With Python f-strings, the syntax is simpler, as the variables and expressions are directly placed within the string without needing separate arguments or a method call. Look at the code below.

• Less verbose: With Python f-strings, you can directly place the variable inside the placeholder. At line 4, the f-string f"Language: {name}, Version: {version}" does the formatting as follows:

  • {name} is replaced by the value of name.

  • {version} is replaced by the value of version.

• No need for explicit indexing: With f-strings, you can refer to the variables wherever needed. There’s no need to keep track of indexes or formatting rules. Line 5 formats the string as follows:

  • Version: {version}: At first, it inserts the version.

  • Language: {name}: In the second place, it inserts the name.

  • Language again: {name}: It again inserts the name at the end.

• Padding: You can add padding to align values. Line 6 formats the string as follows:

  • {name:>10}: It right-aligned name within a field that is 10 characters wide. Any extra space will be filled with spaces on the left.

  • {version:<5}: It left-aligned version within a field that is 5 characters wide. Any extra space will be filled with spaces on the right.

Evaluating expressions with Python f-strings#

With f-strings, we can add any valid Python expression inside {}, e.g., arithmetic operations, conditional statements, and function calls. Look at the code below.

• Arithmetic operation: At line 7, the f-string replaces {x} and {y} with the values of previously declared variables: x and y (at lines 4–5). Whereas, {x + y} is an expression that evaluates the sum of x and y variables.

• Conditional statement: At line 8, the f-string dynamically computes the comparison between x and y variables inside a string.

• Function call: At line 9, the f-string computes the sum of x and y by calling the previously declared sum(x, y) function (at lines 1–2).

Formatting numbers with f-strings#

f-strings support various number formatting options, e.g., specifying decimal places, adding commas to large numbers, formatting percentages, and type conversion. Look at the code below.

• Rounded to decimal places: At line 2, the format specifier, {number:.3f}, formats the number as a floating point number to three decimal places.

• Number with commas: At line 3, the format specifier, {number:,}, tells Python to insert commas as thousand separators to make number more readable.

• Percentage formatting: At line 6, the format specifier, {percentage:.2%}, formats the decimal percentage as a percentage, rounded to 2 decimal places.

• Type conversion: You can convert expressions (values or variables) to different data types. Line 8 formats 10 in three different number systems as follows:

  • {10:b}: It formats 10 as a binary number (base 2).

  • {10:x}: It formats 10 as a hexadecimal number (base 16).

  • {10:o}: It formats 10 as an octal number (base 8).

Debugging with f-strings#

In Python 3.8+, f-strings introduce a debugging feature where = can be added after the expression to print both the expression and its result.

Here, line 2 uses an f-string to print the value of x along with some custom text. Whereas, line 3 uses the debugging feature to automatically print the variable name and its value because Python interprets this as “print both the expression and its result.”

Handling dictionaries and objects with f-strings#

You can easily access dictionary values or object attributes inside an f-string. Look at the code below.

• Dictionary access: At line 2, the dictionary language is accessed using its keys as follows:

  • {language['name']} retrieves the value associated with the key 'name'.

  • {language['version']} retrieves the value associated with the key 'version'.

• Object access: The Language class is defined in lines 4–7, and its object is created in line 9. At line 10, the object langObj is accessed using its attributes as follows:

  • {langObj.name} retrieves the value associated with the attribute 'name'.

  • {langObj.version} retrieves the value associated with the attribute 'version'.

Conclusion#

The table below summarizes the information above to help you make an informed choice depending on your requirements and the Python version.

You can make your code more efficient, readable, and maintainable by mastering different formatting techniques. Whichever method you choose will depend on your specific use case, but f-strings are highly recommended for modern Python applications.

In case, you want to deep dive in Python, check out the following path that will guide you from writing your first line of Python code to landing your first job as a Python developer.