Unlocking the Full Power of Python f-Strings: 5 Pro Tips for Expert-Level Formatting

Introduction

Python f-strings introduced in Python 3.6 provide a concise, readable way to format strings. With variables and expressions embedded right inside f-strings, they avoid messy string concatenation and formatting calls.

However, f-strings pack a ton of powerful formatting functionality that goes far beyond basic string interpolation.

This guide will demonstrate 5 pro techniques to master the full capabilities of f-strings and level up your Python string formatting skills.

1. Format Numbers and Dates with Python f-Strings

Basic f-strings allow directly embedding variables:

name = "John"
print(f"Hello {name}!") # Hello John!

We can also specify simple formats for numbers and dates:

price = 24.5
date = datetime(2023, 2, 1)

print(f"Price: {price:.2f}") # Price: 24.50 
print(f"Date: {date:%Y-%m-%d}") # Date: 2023-02-01

The syntax {value:format} after the variable name applies numeric or date formatting:

• {price:.2f} rounds price to 2 decimals
• {date:%Y-%m-%d} formats date as YYYY-MM-DD

This saves explicitly converting values before interpolating them.

2. Align and Pad Strings with Python f-Strings

You can align text left, right or center within the f-string using the :<, :>, and :^ specifiers:

s1 = "Apple"
s2 = "Banana"
s3 = "Lemon"

print(f"{s1:<10}") # Apple     
print(f"{s2:>10}") #      Banana
print(f"{s3:^10}") #    Lemon

This is useful for formatting text into columns.

Adding a number after the alignment specifier pads strings to an exact width. This can format a list into tidy columns:

items = ['Apples', 'Oranges', 'Grapes']
prices = [1.5, 2.1, 3.7] 

for item, price in zip(items, prices):
  print(f"{item:15} ${price:6.2f}") 
   
# Apples         $  1.50  
# Oranges        $  2.10
# Grapes         $  3.70

The {item:15} and {price:6.2f} specify 15 and 6 character widths respectively, aligning the columns.

3. Control Floating Point Precision with Python f-Strings

You can also finely control floating point precision and formatting using f-strings:

pi = 3.1415926

print(f"{pi:.0f}") # 3
print(f"{pi:.2f}") # 3.14  
print(f"{pi:.4f}") # 3.1416

This rounds pi to the given number of decimals.

Some more formatting options for floats are:

• {value:e} – Exponent notation. Example: 3.1415926e+00
• {value:%} – Multiply by 100 and add percent sign. Example: 314.15926%
• {value:.2g} – Smart rounding with just 2 significant digits. Example: 3.1

Scientific and engineering data can be presented concisely by controlling float formats.

4. Inline Expressions and Operations with Python f-Strings

Python f-strings allow inline expressions using the syntax {expr}.

For example:

import datetime

today = datetime.date.today()
days_since_start = (today - datetime.date(2023, 1, 1)).days

print(f"Days since Jan 1: {days_since_start}")

This embeds the expression calculating days_since_start directly inside the braces.

We can also perform operations on the expressions:

price = 24.5
tax_rate = 0.07

print(f"Price incl. tax: {price * (1 + tax_rate):.2f}")

This neatly calculates the price after taxes without any temporary variables.

5. Specify Argument Names with Python f-strings

When passing values to an f-string, you can optionally specify the names for clarity:

student = get_student(123)

print(f"{student=}") # student='John Doe'

print(f"{first_name=}{last_name=}") # first_name='John' last_name='Doe'

This is useful when interpolating complex objects to indicate where attributes are coming from.

Named arguments also allow reusing values multiple times without repeating variables:

sales_qty = 110
sales_price = 2.5
sales_cost = 1.5
profit = (sales_price - sales_cost) * sales_qty

print(f"{sales_qty=} {sales_price=} {profit=:.2f}") 
# sales_qty=110 sales_price=2.5 profit=165.00

Overall, f-strings provide extremely concise and readable string formatting while handling many common formatting needs. Mastering their full features takes Python string manipulation to an expert level.

When to Use F-Strings vs str.format() and %-formatting

F-strings provide simpler string interpolation and formatting compared to older % and str.format() styles in Python.

However, the other formatting styles have some additional capabilities not available in f-strings:

• % formatting allows variable padding and alignment within a formatter:
  • '%-15s = %10.2f%%' % (name, price)
• str.format() supports advanced formatting like datetime, currency, rounding modes:
  • 'Date: {date:%A, %B %d %Y}'.format(date=today)
• Only str.format() can format using keyword arguments:
  • '{first} {last}'.format(first='John', last='Doe')

So f-strings are ideal for basic to intermediate string needs, while % and str.format() offer advanced specialty formatting.

Conclusion

Python F-strings provide an intuitive way to inject variables and expressions directly inside strings. Features like inline math, named arguments, print f-style formatting specifiers give f-strings all the power needed for most string formatting use cases in Python.

The key techniques to master are:

• Formatting numbers, dates and floats
• Aligning and padding strings
• Controlling float precision
• Using inline expressions and operations
• Specifying explicit variable names

By leveraging these capabilities, you can eliminate messy string concatenation and creation of temporary variables in your code.

Level up your Python string processing skills by adopting advanced f-strings. Their readability, compactness and power will help produce concise and polished string outputs.

Frequently Asked Questions

Here are some common questions about mastering Python f-strings:

Do f-strings improve performance compared to %-formatting and str.format()?

Yes, f-strings are faster than older formatting styles as they avoid the cost of creating temporary formatter strings.

Can I specify variable precision for floats in f-strings?

Yes, you can do {value:.Nf} where N is the number of decimal places, similar to printf.

Do f-strings work in older Python versions?

No, f-strings were introduced in Python 3.6. In older versions you must use %-formatting or str.format().

Can I format string padding and alignment in f-strings?

Padding is possible via {value:N} where N is the fixed width. Align left/right/center also works using :<, :>, :^.

What are some pitfalls to avoid with python f-strings?

Avoid embedding unattended user input in f-strings as it can lead to code injection. Also don’t overuse expressions in f-strings which harms readability.