python f string: Practical Usage and Code Examples

Python f strings, introduced in Python 3.6, let you embed expressions directly inside string literals by prefixing the string with f or F. This eliminates the need for .format() or %-style substitution in most cases. The syntax is simple: any expression inside {} is evaluated at runtime and converted to a string using the default formatting rules.

name = "Ada"
age = 36
print(f"{name} is {age} years old")

The expression can be a variable, a function call, an attribute access, or any valid Python expression. The result is formatted according to the __format__ protocol, which means you can apply the same format specifiers used with str.format().

The Basic Syntax of an f-String

An f-string is a string literal prefixed with f or F. The opening quote can be single, double, or triple, and the string can contain replacement fields delimited by curly braces. Everything inside the braces is evaluated as a Python expression, and the resulting value is formatted and inserted into the string.

import math
radius = 5
area = f"Area: {math.pi * radius ** 2}"
print(area)  # Area: 78.53981633974483

The expression is evaluated in the current scope, so local variables, global variables, and even imports are accessible. You can also use conditional expressions, list comprehensions, and lambda functions, though readability should guide how complex you make the expression.

One important detail is that the expression inside the braces is evaluated eagerly, not lazily. If the expression has side effects, they occur at the point the f-string is constructed. This matters when you pass an f-string as an argument or store it for later use.

Formatting Values with Specifiers

F-strings support the same format specifiers as str.format(). After the expression, you can add a colon and a format specifier to control alignment, width, precision, and type-specific formatting.

price = 49.995
print(f"{price:.2f}")   # 50.00
print(f"{price:>10.2f}")  # '     50.00'
print(f"{123456789:,d}")  # 123,456,789

For strings, you can set a minimum width and alignment: < for left, > for right, ^ for center. For numbers, you can specify decimal places, thousands separators, and base prefixes. The full specification is defined in the Python documentation under the format specification mini-language.

You can also format datetime objects using the strftime-style codes.

from datetime import datetime
now = datetime.now()
print(f"{now:%Y-%m-%d %H:%M:%S}")

Because the specifier is part of the expression, it cannot contain a backslash, which leads to a common pitfall discussed later.

Using Expressions and Debugging with `=`

Python 3.8 added a debugging shortcut: putting an equals sign after the expression inside the braces prints both the expression text and its value. This is useful for quick debugging without writing separate print statements for variable names.

user_id = 42
print(f"{user_id=}")  # user_id=42
print(f"{user_id = }")  # user_id = 42 (spaces preserved)

The = form works with any expression, not just variables. For example, f"{2 + 3 = }" outputs 2 + 3 = 5. This is a concise way to inspect intermediate values during development.

You can combine = with format specifiers: f"{price = :.2f}" prints price = 50.00. This is especially handy when you need both the expression and a formatted result.

Nested f-Strings and Dynamic Formatting

Because f-strings are evaluated at runtime, you can nest f-strings inside expressions, though it is rarely necessary and can hurt readability. A more practical use is to build format specifiers dynamically using variables.

width = 10
value = "test"
print(f"{value:>{width}}")  # right-align to width 10

Here, width is a variable used inside the format specifier. This works because the specifier itself is a string expression that is evaluated at runtime. You can also create a format specifier from a dictionary or a computed value.

Nesting f-strings directly, like f"{f"{x}"}", is legal but often unnecessary. It can be useful when you need to apply different formatting based on a condition, but a cleaner approach is to compute the formatted value separately and then embed it.

Performance: Why f-Strings Are Faster

F-strings are generally faster than %-formatting and str.format() because they are parsed at compile time and converted into efficient bytecode. The expression is evaluated directly, and the resulting string is built with a specialized FORMAT_VALUE opcode, avoiding the overhead of parsing a format string at runtime.

This performance advantage is most noticeable in tight loops that format many strings. However, the difference is usually small compared to I/O or network operations. The real benefit is that f-strings are more readable and less error-prone, which reduces maintenance cost.

If you are building a large number of strings in a performance-critical path, f-strings are a reasonable default. There is no need to precompile a format template because the f-string itself is already compiled. The only overhead is the expression evaluation, which is the same as writing the expression in normal code.

Common Pitfalls and Compatibility Limits

F-strings have a few limitations that can surprise developers coming from other languages.

Backslashes inside expressions are not allowed. You cannot write f"{x\n}" to include a newline in the expression; you must assign the value first. This is because the f-string parser treats backslashes as part of the string literal, not the expression. For example, this raises a SyntaxError:

# SyntaxError: f-string expression part cannot include a backslash
# f"{name\n}"

Instead, use a variable: newline = "\n"; f"{name}{newline}".

Same quote type inside the expression is also problematic. If the f-string is delimited by single quotes, you cannot use single quotes inside the expression without escaping, which is also disallowed. The common workaround is to use double quotes for the f-string and single quotes inside, or vice versa.

Nested quotes can be managed by using different quote types, but this can become confusing. For complex expressions, consider computing the value first.

Compatibility: f-strings require Python 3.6 or later. The = debugging specifier requires Python 3.8. If you need to support older versions, you must use .format() or %-formatting. This is rarely a concern today, but it matters for codebases that target legacy environments.

Empty expressions are not allowed: f"{}" raises a SyntaxError. You must always put an expression inside the braces.

Choosing Between f-Strings and Other Formatting Methods

Despite the advantages of f-strings, there are cases where other formatting methods are more appropriate.

%-formatting is useful when the format string is stored in a configuration file or database, because it can be parsed at runtime. F-strings are compiled, so they cannot be dynamically constructed from user input.
str.format() is useful when you need to reuse the same format template with different arguments, especially when the template is defined in a separate data structure. For example, a logging system might define a template like "{user} logged in at {time}" and apply it to different records.
Template strings from the string module are safer for user-supplied format strings because they do not evaluate arbitrary expressions. Use them when the format string comes from an untrusted source.

In most application code, f-strings are the clearest and most efficient choice. They keep the expression next to the text, which improves readability and reduces the chance of argument mismatches. The only reason to avoid them is when you need runtime-defined format strings or compatibility with Python versions before 3.6.

For dynamic formatting, you can combine f-strings with format() by building the specifier dynamically, as shown earlier. This gives you the readability of f-strings while keeping the flexibility of runtime-defined formatting.