F-Strings sind eine moderne und sehr bequeme Methode, um Variablenwerte und Ausdrücke direkt in den Text eines Strings einzubetten. Um einen F-String zu erstellen, setzen Sie einfach ein f vor das öffnende Anführungszeichen. Innerhalb des Strings können Sie Variablen einfügen, indem Sie sie in geschweifte Klammern {} einschließen, und Python ersetzt {variable} automatisch durch deren Wert.

# Erstellen zweier Variablen mit numerischen Werten.
eins = 1
zwei = 2

# Einfügen der Werte von 'eins' und 'zwei' in den String.
f"{eins}, {zwei}"
# Ausgabe: '1, 2'

Die Stärke von F-Strings liegt in ihrer Fähigkeit, nicht nur Variablen, sondern fast jeden gültigen Python-Ausdruck innerhalb der Klammern zu enthalten. Dies ermöglicht Berechnungen direkt bei der Formatierung, ohne unnötige Zwischenvariablen erstellen zu müssen.

# Durchführung einer Addition direkt im F-String.
f"{eins} + {zwei} = {eins + zwei}"
# Ausgabe: '1 + 2 = 3'

Sie können problemlos auf Elemente von Datenstrukturen wie Dictionaries (über Schlüssel) und Listen (über Index) aus einem F-String heraus zugreifen. Dies gilt auch für den Zugriff auf Objektattribute (mittels Punktnotation) und sogar für den Aufruf von Funktionen.

# Zugriff auf einen Dictionary-Wert über seinen Schlüssel.
farben = {"rot": "#ff0000", "grün": "#00ff00"}
f"Die Farbe Rot ist {farben['rot']}"
# Ausgabe: 'Die Farbe Rot ist #ff0000'

# Zugriff auf Listenelemente über ihren Index.
daten = [4, 8, 15, 16, 23, 42]
f"Beste Zahlen: {daten[4]} und {daten[5]}"
# Ausgabe: 'Beste Zahlen: 23 und 42'

# Zugriff auf Objektattribute und Aufruf von Funktionen.
from dataclasses import dataclass
@dataclass
class Punkt:
    x: int
    y: int
pos = Punkt(23, 42)
f"Position: {pos.x}, {pos.y}. Der größere Wert ist {max(pos.x, pos.y)}."
# Ausgabe: 'Position: 23, 42. Der größere Wert ist 42.'

F-Strings zum Debuggen verwenden

Seit Python 3.8 enthalten F-Strings ein leistungsstarkes Werkzeug für schnelles Debugging. Indem Sie ein Gleichheitszeichen (=) nach einer Variablen oder einem Ausdruck innerhalb der geschweiften Klammern hinzufügen, weisen Sie Python an, nicht nur den Wert, sondern auch den Ausdruck selbst auszugeben. Dies ist unglaublich praktisch, um Code zu inspizieren.

from datetime import date, timedelta
benutzer = "eric_idle"
mitglied_seit = date(1975, 7, 31)
delta = date(2022, 4, 11) - mitglied_seit

# Verwenden Sie f"{benutzer=}", um automatisch "benutzer='eric_idle'" zu erhalten.
f"{benutzer=} {mitglied_seit=}"
# Ausgabe: "benutzer='eric_idle' mitglied_seit=datetime.date(1975, 7, 31)"

Dieser Debugging-Spezifizierer kann mit regulären Formatierungsspezifizierern kombiniert werden. Sie können ihn auch auf ganze Ausdrücke anwenden, um sowohl die Berechnung als auch das Ergebnis klar darzustellen.

# = zeigt den Variablennamen, : startet die Formatierung, ,d formatiert als Ganzzahl mit Tausendertrennzeichen.
f"{delta.days=:,d}"
# Ausgabe: 'delta.days=17,056'

# Zeigt sowohl die Eingabe als auch das Ergebnis einer Berechnung.
from math import cos, radians
theta = 30
f"{theta=} {cos(radians(theta))=:.3f}"
# Ausgabe: 'theta=30 cos(radians(theta))=0.866'

Debug-Darstellungen (repr) ausgeben

Python-Objekte haben zwei String-Darstellungen: str() (für eine benutzerfreundliche Ausgabe) und repr() (für eine eindeutige, entwicklerfreundliche Ausgabe). Standardmäßig verwenden F-Strings str(). Um die repr()-Ausgabe zu erhalten, können Sie das Konvertierungsflag !r verwenden, was eine bequeme Abkürzung für den manuellen Aufruf von repr() ist. Das Flag !s ruft explizit str() auf.

class Daten:
    def __repr__(self): return '<Daten ...>' # Debug-Darstellung
    def __str__(self): return 'String-Darstellung' # Benutzer-Darstellung
daten = Daten()

# Standardverhalten ruft str(daten) auf
f"daten: {daten}"
# Ausgabe: 'daten: String-Darstellung'

# Verwendung des !r-Flags ruft repr(daten) auf
f"daten: {daten!r}"
# Ausgabe: 'daten: <Daten ...>'

Auffüllen, Ausrichtung und Abschneiden

F-Strings bieten die volle Kontrolle über die Formatierung der Ausgabe, einschließlich Feldbreite, Ausrichtung und Füllzeichen. Der Formatierungsspezifizierer folgt auf einen Doppelpunkt (:).

> richtet den Text rechtsbündig aus.
< richtet den Text linksbündig aus.
^ zentriert den Text.
Eine Zahl nach dem Ausrichtungszeichen gibt die Gesamtbreite des Feldes an.
Ein Zeichen vor dem Ausrichtungszeichen gibt das Füllzeichen an.

val = "test"

# Rechtsbündig in einem 10 Zeichen breiten Feld ausrichten
f"{val:>10}"
# Ausgabe: '      test'

# Linksbündig ausrichten und den leeren Raum mit '_' füllen
f"{val:_<10}"
# Ausgabe: 'test______'

# Den Text zentrieren
f"{val:^10}"
# Ausgabe: '   test   '

Um einen String auf eine maximale Länge zu kürzen, verwenden Sie die Syntax :.N, wobei N die Anzahl der Zeichen ist.

instrument = "xylophone"
# Den String auf 5 Zeichen kürzen.
f"{instrument:.5}"
# Ausgabe: 'xylop'

Zahlendarstellungen

Für Zahlen stehen zahlreiche Formatierungsoptionen zur Verfügung. Sie können Zahlen leicht in binär (b), oktal (o) oder hexadezimal (x/X) umwandeln. Die Verwendung von # fügt das entsprechende Präfix (0b, 0o, 0x) hinzu.

antwort = 42

# Hexadezimale Darstellung
f"{antwort:x}, {antwort:X}"
# Ausgabe: '2a, 2A'

# Mit einem Präfix
f"{antwort:#x}"
# Ausgabe: '0x2a'

# Wissenschaftliche Notation
f"{antwort ** 8:e}"
# Ausgabe: '9.682652e+12'

Das Auffüllen von Zahlen mit führenden Nullen erfolgt durch die Verwendung von 0 als Füllzeichen. Bei Fließkommazahlen können Sie sowohl die Gesamtbreite als auch die Anzahl der Dezimalstellen steuern. Sie können auch die Anzeige des Vorzeichens kontrollieren und Tausendertrennzeichen hinzufügen.

# Mit führenden Nullen auf 4 Stellen auffüllen
f"{antwort:04d}"
# Ausgabe: '0042'

# Für Pi: Gesamtbreite 6, 2 Dezimalstellen, mit Nullen auffüllen
import math
f"{math.pi:06.2f}"
# Ausgabe: '003.14'

# Immer das Vorzeichen anzeigen (+ für positiv, - für negativ)
f"{antwort:+d}"
# Ausgabe: '+42'

# Ein Komma als Tausendertrennzeichen verwenden
num = 1234567890
f"{num:,d}"
# Ausgabe: '1,234,567,890'

Weitere Themen und Best Practices

Viele eingebaute Objekte wie datetime haben ihre eigene Mini-Formatierungssprache, die direkt in F-Strings funktioniert.

from datetime import datetime
dt = datetime(2022, 4, 11, 13, 37)
# Standard-Formatierungscodes für Datum/Uhrzeit verwenden
f"{dt:%Y-%m-%d %H:%M}"
# Ausgabe: '2022-04-11 13:37'

Die Formatierungsspezifizierer selbst müssen nicht statisch sein! Sie können sie dynamisch mithilfe von Variablen und verschachtelten geschweiften Klammern festlegen.

# Breite und Ausrichtung werden durch Variablen festgelegt
wert = "test"
ausrichtung = "^"
breite = 10
# f'{wert:{ausrichtung}{breite}}' wird zuerst zu f'{wert:^10}'
f'{wert:{ausrichtung}{breite}}'
# Ausgabe: '   test   '

Wenn Sie eine literale geschweifte Klammer { oder } in Ihrem String benötigen, verdoppeln Sie sie einfach.

f"Literale geschweifte Klammern: {{wert}}"
# Ausgabe: 'Literale geschweifte Klammern: {wert}'

Praktische Ratschläge und Fallstricke

Lesbarkeit vs. Kürze

F-Strings ermöglichen das Einbetten sehr komplexer Ausdrücke, aber das ist nicht immer eine gute Idee. Ein Kernprinzip von Python ist die Lesbarkeit des Codes.

Schlechte Praxis (schwer zu lesen):

# Technisch funktioniert das, aber was passiert hier?
print(f"Ergebnis: {round([user.height for user in users if user.active][0] / 2.54, 2)} Zoll.")

Gute Praxis (Trennung von Logik und Darstellung):„`python

1. Zuerst die Daten vorbereiten

aktive_benutzer_groessen = [user.height for user in users if user.active]
groesse_erster_benutzer_cm = aktive_benutzer_groessen[0]
groesse_in_zoll = round(groesse_erster_benutzer_cm / 2.54, 2)

2. Dann das Ergebnis formatieren

print(f“Ergebnis: {groesse_in_zoll} Zoll.“)

Der Code ist länger, aber er ist jetzt verständlich, testbar und leicht zu ändern. **Eine allgemeine Regel: Wenn ein Ausdruck innerhalb von `{}` länger als 20-30 Zeichen ist oder komplexe Logik enthält, ist es besser, ihn in eine separate Variable auszulagern.**

#### Mehrzeilige F-Strings
Für lange Strings oder die Erzeugung von mehrzeiligem Text (z. B. SQL-Abfragen, HTML-Vorlagen) verwenden Sie dreifache Anführungszeichen. Die Ausdrücke darin können ebenfalls mehrzeilig sein.

python
benutzer = „hypo69“
berechtigungen = [‚read‘, ‚write‘, ‚execute‘]

Der Ausdruck im F-String ist zur besseren Lesbarkeit auf mehrere Zeilen aufgeteilt

bericht = f“““

Benutzerbericht: {benutzer.upper()}

Berechtigungen: {‚, ‚.join(p for p in berechtigungen
if p != ‚execute‘)}
„““
print(bericht)

#### Sicherheitsbedenken (Sehr wichtig!)
F-Strings selbst sind sicher. Ein Ausdruck wie `f"Hallo, {name}"` ist keine Sicherheitslücke; Python nimmt einfach die String-Darstellung von `name`.

**Die Gefahr entsteht, wenn Sie F-Strings mit Funktionen kombinieren, die Code ausführen, wie `eval()`.**

**EXTREM GEFÄHRLICHER CODE — TUN SIE DAS NIEMALS:**

python
import os
benutzervorlage = input(„Geben Sie eine Vorlage ein: „) # Benutzer gibt ein: ‚{os.system(„reboot“)}‘
eval(f’f“{benutzervorlage}“‚)
`` Wenn ein Benutzer{os.system(„reboot“)}eingibt, wird Ihr Server neu gestartet. Dies ist eine Sicherheitslücke für Remote Code Execution (RCE). **Übergeben Sie niemals von Benutzern bereitgestellte Strings an Funktionen wieeval()`, auch nicht über F-Strings.** Verwenden Sie für benutzerdefinierte Vorlagen sichere Template-Engines wie Jinja2.

Leistung: Warum sind F-Strings so schnell?

Ein F-String ist kein Funktionsaufruf; er ist Teil der Python-Syntax. Der Compiler analysiert den F-String und zerlegt ihn in literale Teile und auszuwertende Ausdrücke. Dies wird in hochgradig effizienten Bytecode kompiliert, der den endgültigen String in einer einzigen schnellen Operation erstellt. Dies ist wesentlich schneller als die .format()-Methode, die den Formatierungsstring zur Laufzeit analysieren muss.

Migrationswerkzeuge

Werkzeuge wie flynt und pyupgrade können alten Code, der .format() und % verwendet, automatisch in moderne F-Strings umwandeln, was eine großartige Möglichkeit ist, eine veraltete Codebasis schnell zu modernisieren.