Python f-String Tutorial – String Formatting in Python Explained with Code Examples

String formatting is a bread-and-butter task for any programmer, but it hasn‘t always been straightforward in Python. Over the years, Python has accrued multiple ways to format strings, each with their own quirks and limitations. Thankfully, Python 3.6 introduced a new string formatting approach called "f-strings" that cleans up many of the shortcomings of the older techniques.

In this comprehensive tutorial, we‘ll cover everything you need to know about f-strings to use them effectively in your own Python code. We‘ll dive deep into the motivation behind f-strings, their performance benefits, and real-world usage patterns. I‘ll share practical insights I‘ve learned from using f-strings extensively as a professional Python developer.

Whether you‘re a beginner just learning string formatting or an experienced Pythonista looking to modernize your codebase, this guide will level up your f-string skills. Let‘s get started!

The Road to f-Strings

To understand why f-strings are so beneficial, let‘s review the history of string formatting in Python. There have been three main approaches over time:

1. %-formatting (Python 2.0+)
2. str.format() (Python 2.6+)
3. f-strings a.k.a formatted string literals (Python 3.6+)

%-Formatting

%-formatting is the OG of Python string interpolation. It uses the % operator to substitute values into a string template. Here‘s an example:

name = "Alice"
age = 25
print("My name is %s and I‘m %d years old" % (name, age))

While % formatting got the job done, it came with a host of annoyances:

• You have to manually specify the type of each value with cryptic format specifiers like %s for string, %d for integer, %f for float, etc. This is verbose and error-prone.
• The values have to be passed as a tuple, which can be confusing for folks coming from C‘s printf syntax where the arguments are not grouped.
• Most critically, the template string is removed from the actual values, making the code harder to read.

str.format()

To address some shortcomings of %-formatting, Python 2.6 introduced a new string formatting approach using the str.format() method:

print("My name is {} and I‘m {} years old".format(name, age))

str.format() is definitely an improvement over %-formatting in several ways:

• The placeholders are just {} with no type specifiers, so you don‘t have to worry about matching types
• The values are passed as normal arguments, not a tuple
• You can refer to arguments by position or keyword, enabling reuse:

print("Hi, I‘m {0}. My friend is {1}. {0} again!".format("Alice", "Bob"))

However, str.format() still suffers from a key flaw – it separates the template string from the values. This makes the code less glanceable and requires you to match up {} with arguments manually. It‘s too easy to forget an argument or pass them in the wrong order, especially with long strings.

f-Strings

After years of pained string formatting, Python 3.6 finally introduced f-strings, and they‘re glorious. F-strings look like this:

name = "Alice"
age = 25
print(f"My name is {name} and I‘m {age} years old")

There are three key things to note about f-strings:

1. The string is prefixed with the letter f, which tells Python to parse it as an f-string.
2. Variables are inserted directly into the string using {}, without any manual positional arguments.
3. Any valid Python expression can go inside the {}. We‘ll explore this more later.

F-strings solve the major problems with the older approaches:

• No more cryptic type specifiers or unpacking tuples
• The template string and values are localised, improving readability
• Inserting values is as easy as putting them in {}, enabling all sorts of powerful interpolation

Now that we understand the history, let‘s dive into the nitty-gritty of f-strings and see what makes them so useful.

Evaluating Expressions in f-Strings

The coolest feature of f-strings is that any valid Python goes inside the {}. This allows you to do some really nifty things. Let‘s look at a few examples.

Simple Arithmetic

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

When the f-string is evaluated at runtime, Python will calculate x+y and insert the result, giving:

The sum of 10 and 20 is 30  

You can use any mathematical operators inside the {}:

r = 2
print(f"A circle with radius {r} has area {3.14 * r**2:.2f}")
# A circle with radius 2 has area 12.56

Calling Functions

You can call any function inside an f-string. The function will be evaluated and its return value will be inserted into the string:

def greet(name):
    return f"Hello {name}!"

print(f"{greet(‘World‘)} Welcome to PyCon!")   
# Hello World! Welcome to PyCon!

This is super handy for common string operations like case changes:

name = "alice"
print(f"Name: {name.upper()}")  
# Name: ALICE

Or formatting numbers:

price = 123.45
print(f"Price: {price:,.2f}")
# Price: 123.45

You can even pass the f-string output to another function:

x = 42
html = f"<div>{x}</div>"
print(f"{html.strip()}")  
# <div>42</div>

Conditional Logic

F-strings support inline if/else statements, making them a mini-template engine:

user = "Alice"
print(f"Welcome {‘back ‘ if user == ‘Alice‘ else ‘‘}!")
# Welcome back!

This is great for avoiding repetitive concatenation:

count = 0
print(f"You have ({count}) item{‘s‘ if count != 1 else ‘‘}")
# You have (0) items

Literal Strings

If you need to include literal braces {{}} in your string, double them up:

print(f"{{This}} is a literal brace")
# {This} is a literal brace  

Verbatim Strings (f-rawstrings)

To avoid excessive escaping, combine the f prefix with r for raw, verbatim strings:

path = r"C:\Users\Alice\file.txt"
print(fr"Path is {path}")

Multiline Strings

F-strings can span multiple lines just like regular strings:

name = "Alice"
print(f"""
    Hi {name},
    Welcome to Wonderland!
    """)  

Formatting Data Structures

With clever use of comprehensions, you can elegantly format lists, dicts, etc:

data = {"name": "Alice", "age": 33, "city": "Amsterdam"}  
print(f"{‘, ‘.join(f‘{k}: {v}‘ for k,v in data.items())}")
# name: Alice, age: 33, city: Amsterdam

As you can see, f-strings pack a ton of formatting power into a concise syntax. When combined with other Python features like named tuples or pathlib, they enable remarkably expressive one-liners:

from pathlib import Path

p = Path("source.txt")
print(f"{p.read_text().strip().title()}")

Performance Benefits

In addition to their concise syntax, f-strings are also speedy. Let‘s compare them to the older string formatting methods:

name = "Alice"      
for i in range(10000):
    s = "Hello, %s" % name

name = "Alice"      
for i in range(10000):
    s = "Hello, {}".format(name)

  
name = "Alice"      
for i in range(10000):
    s = f"Hello, {name}"

The f-string version is significantly faster than both %-formatting and str.format(). The performance delta is due to several factors:

• F-strings are evaluated at runtime without any extra method calls
• Unused placeholders are ignored, whereas str.format() has to parse the entire template string regardless
• F-strings don‘t have to unpack and process arguments like *args and **kwargs

According to Python core developer Larry Hastings:

f-strings are faster than %-formatting and str.format() because f-strings are evaluated at runtime as a single expression. Basically, the compiler does the entire formatting in a single step.

In one Python benchmark, f-strings were found to be 56% faster than %-formatting for template strings with two placeholders.

While your mileage may vary, it‘s safe to say f-strings generally outperform the older string formatting techniques. If you‘re doing heavy string formatting, especially in loops, switching to f-strings can provide a nice speed boost.

Best Practices

Now that you‘re sold on the benefits of f-strings, here are some tips for using them effectively:

• Use f-strings for most general-purpose string formatting, especially for anything involving variables.

• For templated strings that are reused repeatedly, f-strings may be slower since they are re-parsed each time. Consider str.format() or %-formatting there.

• Don‘t go overboard with expressions in f-strings. A little inline arithmetic is fine, but complex logic or expensive operations should be pulled out to keep the f-string readable. Use temporary variables if needed.

• Take care with dicts in f-strings. If you need to print a dict, pull it out first:

d = {"name": "Alice", "email": "[email protected]"} 
print(f"{d}")  # My dict: {‘name‘: ‘Alice‘, ‘email‘: ‘[email protected]‘}

• Remember that f-strings are unicode strings. To format bytes, use %-formatting or bytes.decode():

b"Hello %s" % name.encode("utf-8")
# or
f"{name}".encode("utf-8")  

• If you need Python < 3.6 compatibility, use a 3rd party library like future-fstrings to backport f-string support with the same syntax.

Here‘s a handy decision flowchart for choosing between string formatting methods:

graph TD
    A[String contains variables?] -->|No| B[Use plain string]
    A[String contains variables?] -->|Yes| C[Repeated format?] 
    C -->|Yes| D{Performance critical?}
    D -->|Yes| E[%-formatting or str.format()]
    D -->|No| F[str.format()]
    C -->|No| G[f-string]

(Mermaid rendering available at https://mermaid-js.github.io/mermaid-live-editor)

FAQ

Before we wrap up, let‘s address some common questions about f-strings:

Q: Do f-strings work with all Python versions?

A: F-strings were introduced in Python 3.6. For older versions, you can try a backport like future-fstrings to get similar functionality. But in general, it‘s best to use Python >= 3.6 if you want to take advantage of f-strings.

Q: Are f-strings safe from injection attacks?

A: Not inherently. F-strings simply evaluate whatever expressions they contain, so they can be hazardous if you interpolate untrusted input. Be sure to sanitize any external data before including it in an f-string. When in doubt, use a template engine with auto-escaping.

Q: Can I define my own format specifiers with f-strings?

A: Yes! You can define custom format specifiers by writing a format() method on your class. The string after the colon in an f-string placeholder will be passed to this method, allowing you to control the output formatting. Here‘s an example:

class User:
    def __init__(self, first_name, last_name):
        self.first_name = first_name
        self.last_name = last_name

    def __format__(self, format_spec):
        if format_spec == "formal":
            return f"{self.last_name}, {self.first_name}"
        elif format_spec == "informal": 
            return f"{self.first_name} {self.last_name[0]}"
        else:
            return self.first_name

u = User("Alice", "Wonderland")        
print(f"{u:formal}")   # Wonderland, Alice
print(f"{u:informal}") # Alice W
print(f"{u}")          # Alice        

By implementing format() you can define any custom formatting behaviors you need and keep your f-strings nice and DRY.

Conclusion

In this deep dive on Python f-strings, we‘ve covered their history, syntax, advanced features, performance benefits, best practices, and common use cases. We‘ve seen how f-strings provide a powerful and expressive way to do string interpolation in modern Python.

Here are the key takeaways for using f-strings effectively:

• Use f-strings for most general-purpose string formatting involving variables.

• Any Python expression can go inside the curly braces {}, enabling advanced formatting.

• F-strings are faster than %-formatting and str.format() in most cases.

• Avoid overusing expressions or complex logic directly in f-strings. Keep them readable.

• F-strings require Python >= 3.6. Use %-formatting or str.format() if you need to support older versions.

• Custom format specifiers are possible by implementing a format() method.

If you‘re still using the older string formatting techniques, I highly recommend giving f-strings a try. Once you get used to their streamlined syntax, you‘ll wonder how you ever put up with %s and {}.

F-strings are one of my favorite additions to Python in recent years. They show how a thoughtfully-designed language feature can provide major readability and performance benefits with minimal downsides. By adopting f-strings in your own Python code, you‘ll be able to format strings with ease and style.

I hope this guide has been a helpful resource for mastering Python f-strings. Now get out there and format all the strings!