f-Strings bis zum Anschlag

In Teil 2 der Python-Serie haben wir f-Strings als bequeme Möglichkeit kennengelernt, Werte in Strings einzubauen:

name = "Karl"
hp = 75

print(f"{name} hat noch {hp} Lebenspunkte.")

Das ist allerdings nur die einfachste Form. f-Strings können Zahlen runden, Spalten ausrichten, Vorzeichen erzwingen, Datumswerte formatieren und beim Debugging gleichzeitig einen Ausdruck und dessen Ergebnis anzeigen.

Der größte Teil dieser Möglichkeiten steckt hinter dem Doppelpunkt innerhalb eines Replacement Fields:

f"{wert:formatangabe}"

Dort beginnt die Format Specification Mini-Language – kurz Format-Mini-Sprache.

Die Grundform eines f-Strings

Ein f-String beginnt mit einem f direkt vor dem öffnenden Anführungszeichen:

name = "Karl"

text = f"Willkommen, {name}!"

Alles zwischen den geschweiften Klammern wird als Python-Ausdruck ausgewertet:

hp = 75
max_hp = 100

print(f"Fehlende HP: {max_hp - hp}")

Die Ausgabe lautet:

Fehlende HP: 25

Du bist nicht auf einfache Variablennamen beschränkt. Innerhalb der Klammern kannst Du beispielsweise:

• Berechnungen ausführen,
• Methoden aufrufen,
• auf Listen und Dictionaries zugreifen,
• Funktionen aufrufen,
• Bedingungen als Ausdruck verwenden.

spieler = {
    "name": "Karl",
    "hp": 75,
}

print(f"Name: {spieler['name'].upper()}")
print(f"Doppelte HP: {spieler['hp'] * 2}")
print(f"Status: {'lebendig' if spieler['hp'] > 0 else 'besiegt'}")

Die Ausgabe lautet:

Name: KARL
Doppelte HP: 150
Status: lebendig

Trotzdem sollte ein f-String lesbar bleiben. Umfangreiche Berechnungen oder mehrere verschachtelte Bedingungen gehören meistens besser in eine eigene Variable oder Funktion.

Die Format-Mini-Sprache

Nach dem Ausdruck kannst Du mit einem Doppelpunkt eine Formatangabe ergänzen:

f"{wert:formatangabe}"

Einige einfache Beispiele:

>>> f"{3.14159:.2f}"
'3.14'

>>> f"{42:5}"
'   42'

>>> f"{'links':<10}|"
'links     |'

Die Formatangabe .2f bedeutet:

• f: Darstellung als Festkommazahl
• .2: zwei Stellen nach dem Dezimalpunkt

Die Angabe 5 reserviert mindestens fünf Zeichen für den Wert. Zahlen werden dabei standardmäßig rechtsbündig ausgerichtet.

Die vollständige Format-Mini-Sprache besitzt vereinfacht diese Reihenfolge:

[[Füllzeichen]Ausrichtung][Vorzeichen][#][0][Breite][Gruppierung][.Präzision][Typ]

Nicht jeder Teil ist bei jedem Datentyp sinnvoll. Außerdem können eigene Klassen selbst bestimmen, welche Formatangaben sie unterstützen.

Du musst Dir diese Reihenfolge nicht auswendig merken. In der Praxis werden meistens nur einige wenige Bestandteile miteinander kombiniert.

Ausrichtung und Breite

Mit einer Zahl legst Du die Mindestbreite des Feldes fest:

>>> f"{42:5}"
'   42'

>>> f"{'Karl':10}"
'Karl      '

Zahlen sind standardmäßig rechtsbündig, Strings linksbündig.

Mit einem Alignment-Zeichen steuerst Du die Ausrichtung ausdrücklich:

Beispiele:

>>> f"{'links':<10}|"
'links     |'

>>> f"{'rechts':>10}|"
'    rechts|'

>>> f"{'mitte':^10}|"
'  mitte   |'

Die |-Zeichen gehören nicht zur Formatierung. Sie machen lediglich sichtbar, wo das reservierte Feld endet.

Eigenes Füllzeichen verwenden

Direkt vor dem Alignment-Zeichen kannst Du ein Füllzeichen angeben:

>>> f"{'Dungeon':-^20}"
'------Dungeon-------'

>>> f"{'Warnung':!<20}"
'Warnung!!!!!!!!!!!!!'

>>> f"{42:.>8}"
'......42'

Die allgemeine Form lautet:

Füllzeichen + Ausrichtung + Breite

Bei

f"{'Dungeon':-^20}"

bedeutet das:

• -: freie Stellen mit Bindestrichen füllen
• ^: Text zentrieren
• 20: insgesamt mindestens 20 Zeichen verwenden

Das Füllzeichen darf nur ein einzelnes Zeichen lang sein.

Tabellen ausrichten

Mit einer festen Breite kannst Du einfache Tabellen erzeugen:

spieler = [
    ("Karl", 100, 50),
    ("Goblin", 30, 4),
    ("Drache", 999, 12500),
]

print(f"{'Name':<10} {'HP':>5} {'Gold':>8}")
print("-" * 25)

for name, hp, gold in spieler:
    print(f"{name:<10} {hp:>5} {gold:>8}")

Die Ausgabe lautet:

Name          HP     Gold
-------------------------
Karl         100       50
Goblin        30        4
Drache       999    12500

Jede Spalte reserviert eine feste Anzahl von Zeichen:

{name:<10}
{hp:>5}
{gold:>8}

Dadurch stehen die Werte sauber untereinander.

Bei Emojis, manchen asiatischen Schriftzeichen oder kombinierten Unicode-Zeichen kann die sichtbare Breite im Terminal von der Anzahl der Python-Zeichen abweichen. Für normale lateinische Texte funktioniert diese Methode jedoch gut.

Zahlen mit Nullen auffüllen

Zahlen lassen sich mit führenden Nullen auf eine feste Breite bringen:

>>> f"{7:03}"
'007'

>>> f"{42:05}"
'00042'

Die letzte Zahl gibt die gesamte Mindestbreite an:

0 + Breite

Das ist beispielsweise für fortlaufende IDs praktisch:

for nummer in range(1, 4):
    print(f"Raum-{nummer:03}")

Die Ausgabe lautet:

Raum-001
Raum-002
Raum-003

Die ausführlichere Schreibweise mit Füllzeichen und Alignment funktioniert ebenfalls:

>>> f"{7:0>3}"
'007'

Bei positiven Ganzzahlen liefern 03 und 0>3 dasselbe sichtbare Ergebnis. Bei Vorzeichen verhält sich die spezielle numerische Nullauffüllung jedoch sinnvoller:

>>> f"{-42:05}"
'-0042'

Das Minuszeichen bleibt links stehen und die Nullen werden zwischen Vorzeichen und Zahl eingefügt.

Nachkommastellen festlegen

Für float-Werte wird häufig der Typ f verwendet:

>>> f"{3.14159:.2f}"
'3.14'

>>> f"{3.14159:.4f}"
'3.1416'

Die Zahl nach dem Punkt bestimmt die Anzahl der Nachkommastellen.

Python rundet den dargestellten Wert entsprechend:

>>> f"{1.999:.2f}"
'2.00'

Die Variable selbst wird dadurch nicht verändert:

wert = 3.14159

print(f"{wert:.2f}")
print(wert)

Die Ausgabe lautet:

3.14
3.14159

Die Formatierung betrifft nur den erzeugten String.

Breite und Präzision kombinieren

Mehrere Angaben lassen sich miteinander verbinden:

>>> f"{3.14159:8.2f}"
'    3.14'

>>> f"{3.14159:08.2f}"
'00003.14'

08.2f bedeutet:

• mindestens acht Zeichen breit,
• mit Nullen auffüllen,
• zwei Nachkommastellen,
• Darstellung als Festkommazahl.

Das ist besonders bei tabellarischen Zahlenwerten hilfreich:

werte = [3.5, 12.75, 123.456]

for wert in werte:
    print(f"{wert:8.2f}")

Ausgabe:

    3.50
   12.75
  123.46

Prozentwerte formatieren

Der Formattyp % multipliziert einen Wert mit 100 und hängt ein Prozentzeichen an:

>>> f"{0.1337:%}"
'13.370000%'

>>> f"{0.1337:.1%}"
'13.4%'

>>> f"{0.5:.0%}"
'50%'

Die Präzision bestimmt auch hier die Anzahl der Nachkommastellen.

Ein Wert von 0.25 entspricht bei dieser Formatierung also 25 %, nicht 0.25 %.

fortschritt = 0.725

print(f"Fortschritt: {fortschritt:.1%}")

Ausgabe:

Fortschritt: 72.5%

Tausendertrenner

Mit einem Komma gruppierst Du große Zahlen in Dreierblöcken:

>>> f"{1234567:,}"
'1,234,567'

Auch Nachkommastellen lassen sich damit kombinieren:

>>> f"{1234567.891:,.2f}"
'1,234,567.89'

Alternativ kannst Du einen Unterstrich verwenden:

>>> f"{1234567:_}"
'1_234_567'

Das Komma erzeugt keinen automatisch an die deutsche Schreibweise angepassten Tausenderpunkt. Die Ausgabe verwendet ein Komma als Gruppierungszeichen und einen Punkt als Dezimaltrennzeichen.

Für eine echte sprach- oder regionsabhängige Darstellung sind Locale-spezifische Formatierung oder eine dafür vorgesehene Library notwendig.

Vorzeichen steuern

Mit + erzwingst Du ein sichtbares Vorzeichen für positive und negative Werte:

>>> f"{42:+}"
'+42'

>>> f"{-42:+}"
'-42'

Das eignet sich beispielsweise für Veränderungen des Player States:

heilung = 20
schaden = -15

print(f"HP: {heilung:+}")
print(f"HP: {schaden:+}")

Ausgabe:

HP: +20
HP: -15

Ein Leerzeichen als Sign-Option reserviert bei positiven Zahlen den Platz des fehlenden Pluszeichens:

>>> f"{42: }"
' 42'

>>> f"{-42: }"
'-42'

Dadurch lassen sich positive und negative Werte untereinander ausrichten.

Andere Zahlensysteme

Ganzzahlen können als Binär-, Oktal- oder Hexadezimalzahl ausgegeben werden:

>>> f"{255:b}"
'11111111'

>>> f"{255:o}"
'377'

>>> f"{255:x}"
'ff'

>>> f"{255:X}"
'FF'

Mit # ergänzt Python das übliche Präfix:

>>> f"{255:#b}"
'0b11111111'

>>> f"{255:#o}"
'0o377'

>>> f"{255:#x}"
'0xff'

>>> f"{255:#X}"
'0XFF'

Auch hier lassen sich mehrere Formatangaben kombinieren:

>>> f"{255:#010b}"
'0b11111111'

Die Ausgabe ist mindestens zehn Zeichen breit und enthält das Präfix 0b.

Wissenschaftliche Schreibweise

Für sehr große oder sehr kleine Zahlen stehen e und E zur Verfügung:

>>> f"{1234567:e}"
'1.234567e+06'

>>> f"{1234567:.2e}"
'1.23e+06'

>>> f"{1234567:.2E}"
'1.23E+06'

Der Typ g wählt abhängig von Größe und Präzision eine kompakte Darstellung:

>>> f"{1234567:.4g}"
'1.235e+06'

>>> f"{12.34567:.4g}"
'12.35'

Für normale Benutzeroberflächen ist f oft besser vorhersehbar. g eignet sich dagegen für kompakte technische Ausgaben mit sehr unterschiedlich großen Werten.

Debug-Syntax mit =

Seit Python 3.8 kannst Du direkt hinter einem Ausdruck ein Gleichheitszeichen setzen:

hp = 75

print(f"{hp=}")

Die Ausgabe enthält sowohl den Ausdruck als auch seinen Wert:

hp=75

Das funktioniert auch mit komplexeren Ausdrücken:

hp = 75
max_hp = 100

print(f"{max_hp - hp=}")
print(f"{hp * 2=}")

Ausgabe:

max_hp - hp=25
hp * 2=150

Diese Schreibweise ist beim schnellen Debugging praktisch, weil Du nicht zusätzlich einen erklärenden String schreiben musst:

print("hp =", hp)

Leerzeichen bleiben erhalten

Die Debug-Syntax übernimmt die Schreibweise des Ausdrucks einschließlich vieler Leerzeichen:

hp = 75

print(f"{hp = }")

Ausgabe:

hp = 75

Du kannst dadurch selbst bestimmen, wie kompakt die Ausgabe aussehen soll.

Debug-Syntax mit Formatangabe

Auch Formatangaben lassen sich mit = kombinieren:

trefferquote = 0.7564

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

Ausgabe:

trefferquote=75.6%

Ebenso funktionieren Conversions:

name = "Karl\n"

print(f"{name=!r}")

Ausgabe:

name='Karl\n'

Conversions mit !s, !r und !a

Vor dem Doppelpunkt kann eine Conversion stehen:

f"{ausdruck!conversion:formatangabe}"

Python unterstützt drei Varianten:

!s: normale String-Darstellung

!s ruft str(...) auf:

name = "Karl"

print(f"{name!s}")

Bei normalen Strings ist das Ergebnis meist identisch zur Ausgabe ohne Conversion.

!r: genaue Repräsentation

!r ruft repr(...) auf und ist besonders beim Debugging hilfreich:

name = "Karl "

print(f"{name!r}")

Ausgabe:

'Karl '

Die Anführungszeichen machen sichtbar, dass es sich um einen String handelt. Außerdem ist das Leerzeichen vor dem schließenden Anführungszeichen nun leichter zu erkennen.

Escape-Sequenzen bleiben ebenfalls sichtbar:

text = "Zeile 1\nZeile 2"

print(f"{text!r}")

Ausgabe:

'Zeile 1\nZeile 2'

!a: Nicht-ASCII-Zeichen escapen

!a verwendet ascii(...):

name = "Jörg"

print(f"{name!a}")

Ausgabe:

'J\xf6rg'

Nicht-ASCII-Zeichen werden dabei durch Escape-Sequenzen dargestellt.

Im normalen Anwendungscode wird !a selten benötigt. Beim Untersuchen von Encoding-Problemen kann es jedoch nützlich sein.

Dynamische Breite und Präzision

Eine Formatangabe kann selbst Replacement Fields enthalten. Dadurch lassen sich Breite und Präzision zur Laufzeit festlegen:

wert = 3.14159
stellen = 3

print(f"{wert:.{stellen}f}")

Ausgabe:

3.142

Der innere Ausdruck

{stellen}

wird zuerst ausgewertet. Daraus entsteht die Formatangabe .3f, die anschließend auf wert angewendet wird.

Auch die Breite kann dynamisch sein:

name = "Karl"
breite = 12

print(f"|{name:^{breite}}|")

Ausgabe:

|    Karl    |

Breite und Präzision lassen sich kombinieren:

wert = 3.14159
breite = 10
stellen = 2

print(f"{wert:{breite}.{stellen}f}")

Ausgabe:

      3.14

Solche dynamischen Formatangaben sind beispielsweise sinnvoll, wenn der Benutzer die Anzahl der Nachkommastellen festlegen kann oder Tabellenbreiten aus Daten berechnet werden.

Formatangaben können verschachtelte Replacement Fields enthalten. Tieferes Verschachteln ist allerdings nicht beliebig garantiert und wird schnell schwer lesbar. Für komplexe Fälle solltest Du die Formatangabe vorher in einer Variablen zusammensetzen:

stellen = 2
formatangabe = f".{stellen}f"
wert = 3.14159

print(f"{wert:{formatangabe}}")

Datum und Uhrzeit formatieren

Objekte dürfen ihre eigene Bedeutung der Formatangabe definieren. Ein wichtiges Beispiel sind date- und datetime-Objekte.

from datetime import datetime

zeitpunkt = datetime(2026, 6, 23, 14, 30)

print(f"{zeitpunkt:%Y-%m-%d %H:%M}")

Ausgabe:

2026-06-23 14:30

Die Format-Codes entsprechen denen von strftime(...).

Einige häufig verwendete Codes:

Eine deutsche Datumsdarstellung lässt sich numerisch so erzeugen:

print(f"{zeitpunkt:%d.%m.%Y um %H:%M Uhr}")

Ausgabe:

23.06.2026 um 14:30 Uhr

Die Format-Mini-Sprache wird also vom jeweiligen Datentyp interpretiert. Zahlen und datetime-Objekte verstehen deshalb unterschiedliche Format-Codes.

Geschweifte Klammern ausgeben

Geschweifte Klammern markieren in einem f-String normalerweise ein Replacement Field:

name = "Karl"

print(f"Hallo, {name}!")

Möchtest Du eine echte geschweifte Klammer ausgeben, musst Du sie verdoppeln:

print(f"Eine Klammer sieht so aus: {{")
print(f"Ein Paar sieht so aus: {{}}")

Ausgabe:

Eine Klammer sieht so aus: {
Ein Paar sieht so aus: {}

Das gilt auch für die schließende Klammer:

print(f"{{links}} und {{rechts}}")

Ausgabe:

{links} und {rechts}

Ein Backslash wie \{ ersetzt diese Schreibweise nicht.

Mehrzeilige f-Strings

Wie normale Strings können auch f-Strings mit dreifachen Anführungszeichen über mehrere Zeilen gehen:

name = "Karl"
hp = 75
gold = 50

status = f"""
Name: {name}
HP:   {hp}
Gold: {gold}
"""

print(status)

Dabei gehört der Zeilenumbruch direkt nach den öffnenden Anführungszeichen zum String. Möchtest Du ihn vermeiden, kannst Du den f-String anders anordnen:

status = (
    f"Name: {name}\n"
    f"HP:   {hp}\n"
    f"Gold: {gold}"
)

Nebeneinanderstehende String-Literale in Klammern werden von Python automatisch verbunden. Jeder Teil kann dabei ein eigener f-String sein.

Diese Variante ist häufig leichter einzurücken und erzeugt keine unbeabsichtigten Leerzeilen.

Was sich mit Python 3.12 geändert hat

Mit Python 3.12 wurde die Grammatik von f-Strings durch PEP 701 in den normalen Python-Parser integriert.

Dadurch entfallen mehrere historische Einschränkungen.

Dieselben Anführungszeichen innen und außen

Seit Python 3.12 darf ein Ausdruck denselben Typ von Anführungszeichen verwenden wie der äußere f-String:

spieler = {
    "name": "Karl",
}

print(f"{spieler["name"]}")

Vor Python 3.12 führte diese Schreibweise zu einem SyntaxError. Damals musste für den Dictionary-Schlüssel ein anderer Typ von Anführungszeichen verwendet werden:

print(f"{spieler['name']}")

Die ältere Schreibweise funktioniert weiterhin und ist für viele Menschen sogar leichter zu lesen.

Backslashes innerhalb eines Ausdrucks

Backslashes sind seit Python 3.12 auch innerhalb eines Replacement Fields erlaubt:

zeilen = ["Halle", "Bibliothek", "Krypta"]

print(f"Räume:\n{"\n".join(zeilen)}")

Ausgabe:

Räume:
Halle
Bibliothek
Krypta

Vor Python 3.12 war "\n" innerhalb des Ausdrucks eines f-Strings nicht zulässig.

Mehrzeilige Ausdrücke und Kommentare

Ausdrücke in f-Strings dürfen sich seit Python 3.12 natürlicher über mehrere Zeilen erstrecken und Kommentare enthalten:

hp = 75
max_hp = 100

text = f"""Fehlende HP: {
    max_hp - hp  # Differenz zum Maximum
}"""

print(text)

Ausgabe:

Fehlende HP: 25

Steht innerhalb des Ausdrucks ein Kommentar, muss die schließende Klammer in einer späteren Zeile stehen. Alles hinter # bis zum Zeilenende gehört zum Kommentar.

f-Strings lassen sich leichter verschachteln

Auch verschachtelte f-Strings können seit Python 3.12 dieselben Anführungszeichen wiederverwenden:

name = "Karl"

text = f"Spieler: {f"{name:^10}"}"
print(text)

Das ist gültig, bedeutet aber nicht automatisch, dass es gut lesbar ist.

Meistens ist eine Zwischenvariable klarer:

name = "Karl"
formatierter_name = f"{name:^10}"

text = f"Spieler: {formatierter_name}"

PEP 701 erlaubt Python-Implementierungen außerdem, eine maximale Verschachtelungstiefe festzulegen. Du solltest daher nicht versuchen, möglichst viele f-Strings ineinander zu stapeln.

f-Strings und eigene Klassen

Die Formatierung eines Wertes wird letztlich über dessen Methode __format__(...) gesteuert.

Dadurch können eigene Klassen benutzerdefinierte Formatangaben unterstützen:

class Spieler:
    def __init__(self, name, hp):
        self.name = name
        self.hp = hp

    def __format__(self, formatangabe):
        if formatangabe == "kurz":
            return f"{self.name} ({self.hp} HP)"

        return self.name


spieler = Spieler("Karl", 75)

print(f"{spieler}")
print(f"{spieler:kurz}")

Ausgabe:

Karl
Karl (75 HP)

Für den normalen Einstieg musst Du __format__(...) noch nicht selbst implementieren. Das Beispiel erklärt aber, warum verschiedene Datentypen unterschiedliche Formatangaben verstehen.

Ein float interpretiert .2f anders als ein datetime-Objekt die Angabe %d.%m.%Y.

f-Strings sind keine Templates für alles

f-Strings setzen Werte unmittelbar beim Erzeugen des Strings ein:

name = "Karl"
text = f"Hallo, {name}!"

text enthält danach nur noch den fertigen String:

Hallo, Karl!

Änderst Du name später, verändert sich text nicht automatisch:

name = "Karl"
text = f"Hallo, {name}!"

name = "Lara"

print(text)

Ausgabe:

Hallo, Karl!

Der f-String müsste erneut ausgewertet werden, um den neuen Wert einzusetzen.

Außerdem übernehmen f-Strings keine automatische Absicherung oder Kontext-Escaping. Benutzereingaben sollten deshalb nicht direkt per f-String in SQL-Abfragen oder Shell-Kommandos eingebaut werden:

# Nicht für Benutzereingaben verwenden:
sql = f"SELECT * FROM spieler WHERE name = '{name}'"

Für SQL-Abfragen verwendest Du stattdessen die Parameterübergabe des jeweiligen Datenbanktreibers.

Ein f-String ist ein Werkzeug zum Erzeugen von Strings, keine allgemeine Template- oder Sicherheitslösung.

Stolperfallen

• Das f vergessen: Ohne das Präfix bleibt {name} normaler Text.

python name = "Karl" print("{name}")

Ausgabe:

console {name}

• Eine einzelne geschweifte Klammer verwenden: Für eine sichtbare Klammer benötigst Du {{ oder }}.

• Breite mit maximaler Länge verwechseln: {text:10} reserviert mindestens zehn Zeichen. Ein längerer String wird nicht abgeschnitten.

• join(...) mit Zahlen verwenden: join(...) erwartet Strings. Zahlen müssen zunächst umgewandelt werden.

• Vom Tausendertrenner auf die Locale schließen: :, erzeugt ein Komma als Gruppierungszeichen und keine automatisch deutsche Zahlendarstellung.

• Zu viel Logik in den f-String schreiben: Nur weil ein Ausdruck syntaktisch erlaubt ist, wird er dadurch nicht gut lesbar.

• Versionsabhängige Syntax verwenden: Wiederverwendete Anführungszeichen, Backslashes und Kommentare innerhalb der Replacement Fields benötigen mindestens Python 3.12.

• Ungeprüfte Daten in SQL oder Shell-Kommandos einsetzen: f-Strings escapen die eingesetzten Werte nicht für den jeweiligen Kontext.

Kompakte Übersicht

Weiterlesen

• Python lernen, Teil 2: Werte und Variablen
• Python-Dokumentation: Format Specification Mini-Language
• Python-Dokumentation: f-Strings
• PEP 498: Literal String Interpolation
• PEP 701: Syntactic Formalization of f-Strings