Python f-Strings

f-Strings (formatierte Zeichenkettenliterale) wurden in Python 3.6 eingeführt und sind heute die empfohlene Methode, um Werte in Zeichenketten einzubetten. Sie sind schneller als die %-Formatierung und str.format() und deutlich lesbarer, da der Variablenname direkt an der Stelle in der Zeichenkette steht, an der er erscheinen soll.

Dieses Kapitel behandelt:

• Grundlegende f-String-Syntax und das Einbetten von Variablen
• Auswerten von Ausdrücken, Methodenaufrufen und Funktionsaufrufen inline
• Formatbezeichner: Ausrichtung, Breite, Präzision und Zahlensysteme
• Datumsformatierung sowie Vorzeichen- und Null-Auffüll-Bezeichner
• Den =-Debug-Bezeichner (Python 3.8+)
• Mehrzeilige f-Strings und wiederverwendbare Vorlagen in Funktionen
• Häufige Fallstricke und wie man sie vermeidet

Verwandte Kapitel: Format Strings · Python String Formatting · Python Strings · Python Dates · Python Regex

Grundlegende Syntax

Ein f-String ist ein Zeichenkettenliteral, das direkt vor dem öffnenden Anführungszeichen mit dem Buchstaben f (oder F) beginnt. Jeder Python-Ausdruck, den man in geschweifte Klammern {} setzt, wird zur Laufzeit ausgewertet, sein Wert wird in eine Zeichenkette umgewandelt und in das Ergebnis eingefügt.

name = "Alice"
age = 30
print(f"My name is {name} and I am {age} years old.")

My name is Alice and I am 30 years old.

Das f-Präfix funktioniert mit einfachen Anführungszeichen, doppelten Anführungszeichen und dreifachen Anführungszeichen:

language = "Python"
print(f'I love {language}!')          # single quotes
print(f"""I love {language}!""")      # triple quotes

I love Python!
I love Python!

Ausdrücke einbetten

Der {}-Platzhalter akzeptiert jeden gültigen Python-Ausdruck — nicht nur Variablennamen. Man kann Arithmetik und Vergleiche durchführen, Methoden aufrufen, Funktionen aufrufen und auf Dictionary-Schlüssel zugreifen.

Arithmetik und Vergleiche

x = 10
y = 3
print(f"{x} divided by {y} is {x / y:.2f}")
print(f"The square of {x} is {x ** 2}")
print(f"Is {x} greater than {y}? {x > y}")

10 divided by 3 is 3.33
The square of 10 is 100
Is 10 greater than 3? True

Methodenaufrufe

name = "alice smith"
print(f"Hello, {name.title()}!")
print(f"Uppercase: {name.upper()}")

Hello, Alice Smith!
Uppercase: ALICE SMITH

Funktionsaufrufe und Built-ins

items = ["apples", "bananas", "cherries"]
print(f"You have {len(items)} items in the list.")

You have 3 items in the list.

Dictionary-Zugriff

Verwende einfache Anführungszeichen innerhalb der geschweiften Klammern, um auf Dictionary-Schlüssel zuzugreifen (der äußere string verwendet doppelte Anführungszeichen, sodass kein Konflikt entsteht):

person = {"name": "Bob", "age": 25}
print(f"Name: {person['name']}, Age: {person['age']}")

Name: Bob, Age: 25

Bedingte Ausdrücke

score = 72
print(f"Score: {score} => {'Pass' if score >= 60 else 'Fail'}")

Score: 72 => Pass

Formatbezeichner

Nach dem Ausdruck fügt man einen Doppelpunkt : gefolgt von einem Formatbezeichner ein, um zu steuern, wie der Wert ausgegeben wird. Die vollständige Mini-Sprachen-Syntax lautet:

{expression:[fill][align][sign][width][grouping][.precision][type]}

Man muss nicht alle Teile verwenden — man kombiniert nur die benötigten Elemente.

Ausrichtung und Breite

Verwende < (linksbündig), > (rechtsbündig) oder ^ (zentriert) zusammen mit einer Zahl, um die Feldbreite festzulegen:

name = "Alice"
print(f"|{name:<10}|")   # left-align in a field of width 10
print(f"|{name:>10}|")   # right-align
print(f"|{name:^10}|")   # center

|Alice     |
|     Alice|
|  Alice   |

Gib ein Füllzeichen vor dem Ausrichtungssymbol an, um mit etwas anderem als Leerzeichen aufzufüllen:

print(f"|{'hello':*^15}|")  # fill with * and center

|*****hello*****|

Dezimalpräzision

pi = 3.14159265
print(f"Pi is approximately {pi:.2f}")   # 2 decimal places
print(f"Pi is approximately {pi:.4f}")   # 4 decimal places

Pi is approximately 3.14
Pi is approximately 3.1416

Zahlenformatierung

price = 1234567.89
print(f"{price:,.2f}")   # comma as thousands separator
print(f"{price:e}")      # scientific notation

1,234,567.89
1.234568e+06

Einen Wert direkt als Prozentzahl anzeigen — Python multipliziert automatisch mit 100:

ratio = 0.853
print(f"{ratio:.1%}")

85.3%

Vorzeichen-Bezeichner

Verwende +, um das Vorzeichen immer anzuzeigen, oder ein Leerzeichen, um bei positiven Zahlen einen Platz zu reservieren (damit Spalten mit negativen Zahlen ausgerichtet sind):

x = 42
y = -7
print(f"{x:+d}")    # +42
print(f"{y:+d}")    # -7
print(f"{x: d}")    # space before positive
print(f"{y: d}")    # -7

+42
-7
 42
-7

Null-Auffüllung

Eine Ganzzahl mit führenden Nullen auf eine feste Breite auffüllen, indem man 0 vor die Breitenangabe setzt:

print(f"{42:010d}")   # zero-pad to 10 digits

0000000042

Vorzeichen und Null-Auffüllung kombinieren — das Vorzeichen belegt die erste Stelle:

x = 42
print(f"{x:+010d}")   # +000000042

+000000042

Ganzzahl-Zahlensysteme

x = 255
print(f"{x:d}")    # decimal   -> 255
print(f"{x:x}")    # hex lower -> ff
print(f"{x:X}")    # hex upper -> FF
print(f"{x:o}")    # octal     -> 377
print(f"{x:b}")    # binary    -> 11111111

255
ff
FF
377
11111111

Datumsformatierung

Wenn man ein datetime- oder date-Objekt in einen f-String setzt, kann man nach dem Doppelpunkt strftime-Formatcodes angeben, um die Ausgabe direkt zu steuern — kein Aufruf von .strftime() nötig:

from datetime import date
today = date(2024, 6, 19)
print(f"Today is {today:%B %d, %Y}")
print(f"ISO format: {today:%Y-%m-%d}")

Today is June 19, 2024
ISO format: 2024-06-19

Die vollständige Liste der strftime-Formatcodes findet sich im Kapitel Python Dates.

Der =-Debug-Bezeichner (Python 3.8+)

Das Hinzufügen von = nach dem Ausdrucksnamen gibt sowohl den Ausdruckstext als auch seinen Wert aus. Das erspart die doppelte Eingabe des Variablennamens und ist beim schnellen Debuggen unschätzbar wertvoll:

val = 42
result = val * 2
print(f"{val=}, {result=}")

val=42, result=84

String-Werte erhalten eine repr()-Behandlung, sodass man die Anführungszeichen sehen kann:

name = "Alice"
print(f"{name=}")

name='Alice'

Man kann = mit einem Formatbezeichner kombinieren — der Bezeichner kommt nach =:

pi = 3.14159265
print(f"{pi=:.3f}")

pi=3.142

Mehrzeilige f-Strings

Für längere Texte kann man einen f-String über mehrere Zeilen spannen. Zwei Ansätze funktionieren gut.

Implizite Zeichenkettenverkettung (kein Backslash innerhalb von Klammern nötig):

name = "Alice"
age = 30
city = "London"
profile = (
    f"Name : {name}\n"
    f"Age  : {age}\n"
    f"City : {city}"
)
print(profile)

Name : Alice
Age  : 30
City : London

Dreifach-zitierter f-String — die Zeilenumbrüche sind wörtlich, daher ist kein \n nötig:

name = "Alice"
age = 30
report = f"""
Name : {name}
Age  : {age}
""".strip()
print(report)

Name : Alice
Age  : 30

Wiederverwendbare Vorlagen

f-Strings werden sofort ausgewertet, daher kann man sie nicht als Vorlagenvariable speichern und später befüllen. Stattdessen verwendet man eine Funktion:

def greet(name, role):
    return f"Hello, {name}! Your role is {role}."

print(greet("Alice", "admin"))
print(greet("Bob", "editor"))

Hello, Alice! Your role is admin.
Hello, Bob! Your role is editor.

Wenn man tatsächlich eine verzögert ausgewertete Vorlage benötigt, verwendet man str.format() — siehe Format Strings.

Literale geschweifte Klammern in der Ausgabe

Um ein literales {- oder }-Zeichen in der Ausgabe einzuschließen, verdoppelt man es:

value = 42
print(f"The answer is {{value}} = {value}")

The answer is {value} = 42

Häufige Fallstricke

Backslashes im Ausdruck (Python < 3.12)

Vor Python 3.12 sind Backslashes im {}-Ausdruck eines f-Strings nicht erlaubt. Die Lösung besteht darin, den Wert zuerst in einer Variablen zu berechnen:

items = ["a", "b", "c"]

# This raises SyntaxError on Python < 3.12:
# print(f"{'\n'.join(items)}")

# Workaround — pre-compute:
joined = "\n".join(items)
print(f"Items:\n{joined}")

Items:
a
b
c

Python 3.12 hat diese Einschränkung aufgehoben, sodass Backslashes in f-String-Ausdrücken nun gültig sind.

Denselben Anführungszeichentyp im Ausdruck verwenden

Wenn der äußere f-String doppelte Anführungszeichen verwendet, benutzt man einfache Anführungszeichen für Dictionary-Schlüssel innerhalb von {}. Wenn derselbe Anführungszeichentyp benötigt wird, wechselt man die äußeren Anführungszeichen oder verwendet eine Variable:

person = {"name": "Bob"}

# Works — single quotes inside double-quoted f-string
print(f"Name: {person['name']}")

# Also works — pre-assign the key
key = "name"
print(f"Name: {person[key]}")

Name: Bob
Name: Bob

f-Strings sind nicht lazy

Ein f-String wertet jeden Ausdruck in dem Moment aus, in dem die Zeile ausgeführt wird. Wenn man einen f-String einer Variablen zuweist, erfasst er die aktuellen Werte — spätere Änderungen der Variablen haben keinen Einfluss auf den bereits ausgewerteten string:

x = 5
msg = f"x is {x}"
x = 99
print(msg)   # still shows 5, not 99

x is 5

Verwende eine Funktion (wie oben gezeigt), wenn man eine Vorlage benötigt, die später ausgewertet wird.

Kurzreferenz

Übungen