Skip to content

Python F-Strings: Der vollständige Leitfaden zur String-Formatierung

Soren Atelier
Name
Soren Atelier

Updated on

Die String-Formatierung ist eine der häufigsten Operationen in Python, war aber jahrelang eine Quelle der Frustration. Der %-Operator verwendet kryptische Formatcodes, die aus C übernommen wurden. Die .format()-Methode verteilt Werte weit davon entfernt, wo sie im Template erscheinen. Die String-Konkatenation mit + zwingt Sie dazu, Typen manuell zu konvertieren und produziert unübersichtlichen, schwer lesbaren Code. Jeder Ansatz fühlt sich so an, als würde er Reibung hinzufügen, wo es sich um eine einfache Aufgabe handeln sollte: Einen Wert in einen String zu setzen.

Das Problem verschlimmert sich in realen Projekten. Sie müssen Währungen mit zwei Dezimalstellen formatieren, Spalten in einem Bericht ausrichten, Zahlen mit führenden Nullen auffüllen, Prozentsätze anzeigen und Zeitstempel formatieren – alles während Sie den Code lesbar halten. Bei älteren Formatierungsmethoden enden Sie damit, zwei parallele Strukturen zu warten: den Template-String und die Argumentliste. Ein einzelner Umordnungsfehler zerstört alles stillschweigend und produziert falsche Ausgaben statt eines Fehlers.

Python 3.6 führte f-strings (formatierte String-Literale) ein und veränderte die String-Formatierung nachhaltig. Indem Sie einem String ein f voranstellen und Ausdrücke direkt innerhalb von {geschweiften Klammern} einbetten, halten f-Strings Werte dort, wo sie erscheinen. Sie sind schneller als jede andere Formatierungsmethode. Sie unterstützen die volle Bandbreite an Formatierungsspezifikationen. Und in Python 3.8 erhielten sie mit dem =-Spezifikator ein integriertes Debugging-Feature. Dieser Leitfaden deckt alle f-String-Funktionen mit praktischen, ausführbaren Beispielen ab.

📚

    Was sind F-Strings?

    F-Strings, formell "formatierte String-Literale" genannt, wurden in PEP 498 (opens in a new tab) eingeführt und mit Python 3.6 ausgeliefert. Das Konzept ist einfach: Stellen Sie einem beliebigen String ein f (oder F) voran, und Python wertet jeden Ausdruck innerhalb von geschweiften Klammern {} zur Laufzeit aus, konvertiert das Ergebnis in einen String und fügt es in die Ausgabe ein.

    name = "Alice"
age = 30
 
greeting = f"My name is {name} and I am {age} years old."
print(greeting)
# Output: 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:

    single = f'Hello, {name}'
double = f"Hello, {name}"
triple_double = f"""Hello, {name}"""
triple_single = f'''Hello, {name}'''

    Im Hintergrund kompiliert Python f-Strings zur Parse-Zeit in eine Reihe von String-Konkatenationen und format()-Operationen. Deshalb sind f-Strings schneller als der manuelle Aufruf von .format() – der Interpreter optimiert die Operation direkt.

    Grundlegende F-String-Syntax

    Die Kernelemente der Syntax sind unkompliziert: Schreiben Sie f"text {ausdruck} mehr text". Python wertet den Ausdruck aus, ruft str() für das Ergebnis auf und fügt es in den String ein.

    # Variables
city = "Tokyo"
population = 13960000
 
print(f"{city} has a population of {population}.")
# Output: Tokyo has a population of 13960000.
 
# You can use either f or F
print(F"Welcome to {city}!")
# Output: Welcome to Tokyo!

    Sie können beliebig viele Ausdrücke innerhalb eines einzelnen f-Strings platzieren:

    first = "Grace"
last = "Hopper"
title = "Rear Admiral"
year = 1906
 
bio = f"{title} {first} {last}, born {year}, lived to {1992 - year} years."
print(bio)
# Output: Rear Admiral Grace Hopper, born 1906, lived to 86 years.

    Ausdrücke innerhalb von F-Strings

    F-Strings fügen nicht nur Variablen ein. Sie werten jeden gültigen Python-Ausdruck zwischen den Klammern aus. Dies umfasst Arithmetik, Methodenaufrufe, Funktionsaufrufe, ternäre Ausdrücke, Listen-Indizierung, Dictionary-Zugriff und mehr.

    Arithmetik und Mathematik

    x = 15
y = 4
 
print(f"{x} + {y} = {x + y}")
print(f"{x} / {y} = {x / y:.2f}")
print(f"{x} ** {y} = {x ** y}")
print(f"{x} % {y} = {x % y}")
# Output:
# 15 + 4 = 19
# 15 / 4 = 3.75
# 15 ** 4 = 50625
# 15 % 4 = 3

    Methodenaufrufe

    text = "  hello, python world  "
 
print(f"Stripped: '{text.strip()}'")
print(f"Title case: '{text.strip().title()}'")
print(f"Upper: '{text.strip().upper()}'")
print(f"Replace: '{text.strip().replace('python', 'f-string')}'")
# Output:
# Stripped: 'hello, python world'
# Title case: 'Hello, Python World'
# Upper: 'HELLO, PYTHON WORLD'
# Replace: 'hello, f-string world'

    Funktionsaufrufe

    def calculate_bmi(weight_kg, height_m):
    return weight_kg / (height_m ** 2)
 
weight = 70
height = 1.75
 
print(f"BMI: {calculate_bmi(weight, height):.1f}")
# Output: BMI: 22.9
 
# Built-in functions
items = [3, 1, 4, 1, 5, 9, 2, 6]
print(f"Items: {items}")
print(f"Count: {len(items)}, Sum: {sum(items)}, Min: {min(items)}, Max: {max(items)}")
# Output:
# Items: [3, 1, 4, 1, 5, 9, 2, 6]
# Count: 8, Sum: 31, Min: 1, Max: 9

    Ternäre (bedingte) Ausdrücke

    score = 85
status = f"Result: {'PASS' if score >= 60 else 'FAIL'}"
print(status)
# Output: Result: PASS
 
temperature = -5
print(f"Water is {'frozen' if temperature <= 0 else 'liquid' if temperature < 100 else 'steam'}.")
# Output: Water is frozen.

    Dictionary- und Listen-Zugriff

    user = {"name": "Bob", "role": "engineer", "level": 3}
scores = [88, 92, 76, 95, 81]
 
print(f"{user['name']} is a level {user['level']} {user['role']}.")
# Output: Bob is a level 3 engineer.
 
print(f"First score: {scores[0]}, Last score: {scores[-1]}")
# Output: First score: 88, Last score: 81

    Formatierungsspezifikationen: Zahlen, Ausrichtung und Auffüllung

    Die wahre Stärke von f-Strings zeigt sich in den Formatierungsspezifikationen. Nach dem Ausdruck fügen Sie einen Doppelpunkt : gefolgt von einer Formatangabe hinzu. Die allgemeine Syntax ist:

    {ausdruck:[[füllung]ausrichtung][vorzeichen][#][0][breite][gruppierung][.präzision][typ]}

    Das sieht dicht aus, aber jedes Element ist optional. Lassen Sie uns das mit Beispielen aufschlüsseln.

    Dezimalstellen und Gleitkomma-Präzision

    Der .Nf-Spezifikator steuert, wie viele Dezimalstellen eine Float-Zahl anzeigt:

    pi = 3.141592653589793
 
print(f"Default:    {pi}")
print(f"2 decimals: {pi:.2f}")
print(f"4 decimals: {pi:.4f}")
print(f"0 decimals: {pi:.0f}")
print(f"8 decimals: {pi:.8f}")
# Output:
# Default:    3.141592653589793
# 2 decimals: 3.14
# 4 decimals: 3.1416
# 0 decimals: 3
# 8 decimals: 3.14159265

    Tausender-Trennzeichen

    Große Zahlen werden mit Komma- oder Unterstrich-Gruppierung sofort lesbar:

    revenue = 1234567890
small_amount = 1234.5
 
print(f"Revenue: {revenue:,}")
print(f"Revenue: {revenue:_}")
print(f"Amount: ${small_amount:,.2f}")
# Output:
# Revenue: 1,234,567,890
# Revenue: 1_234_567_890
# Amount: $1,234.50

    Prozentformatierung

    Der %-Typ multipliziert den Wert mit 100 und hängt ein Prozentzeichen an:

    completion = 0.876
error_rate = 0.034
growth = 1.25
 
print(f"Completion: {completion:.1%}")
print(f"Error rate: {error_rate:.2%}")
print(f"Growth: {growth:.0%}")
# Output:
# Completion: 87.6%
# Error rate: 3.40%
# Growth: 125%

    Wissenschaftliche Notation

    avogadro = 6.022e23
planck = 6.626e-34
 
print(f"Avogadro: {avogadro:.3e}")
print(f"Planck: {planck:.4E}")
# Output:
# Avogadro: 6.022e+23
# Planck: 6.6260E-34

    Ganzzahlige Zahlensysteme: Binär, Oktal, Hexadezimal

    value = 255
 
print(f"Decimal:     {value:d}")
print(f"Binary:      {value:b}")
print(f"Octal:       {value:o}")
print(f"Hex (lower): {value:x}")
print(f"Hex (upper): {value:X}")
print(f"With prefix: {value:#b}  {value:#o}  {value:#x}")
# Output:
# Decimal:     255
# Binary:      11111111
# Octal:       377
# Hex (lower): ff
# Hex (upper): FF
# With prefix: 0b11111111  0o377  0xff

    Ausrichtung und Auffüllung

    Ausrichtungsspezifikatoren steuern, wie Werte innerhalb einer gegebenen Breite positioniert werden. Verwenden Sie < für links, > für rechts und ^ für mittig:

    label = "Python"
 
print(f"|{label:<20}|")   # Left-align in 20 chars
print(f"|{label:>20}|")   # Right-align
print(f"|{label:^20}|")   # Center
print(f"|{label:*^20}|")  # Center with * fill
print(f"|{label:->20}|")  # Right with - fill
# Output:
# |Python              |
# |              Python|
# |       Python       |
# |*******Python*******|
# |--------------Python|

    Nullen-Auffüllung für Zahlen ist bei der Berichtsformatierung üblich:

    for i in [1, 42, 100, 7, 999]:
    print(f"ID: {i:05d}")
# Output:
# ID: 00001
# ID: 00042
# ID: 00100
# ID: 00007
# ID: 00999

    Erstellen ausgerichteter Tabellen

    Die Kombination von Ausrichtung mit Formatierungsspezifikationen erzeugt saubere Tabellen:

    products = [
    ("Laptop Pro", 1299.99, 45),
    ("Wireless Mouse", 29.50, 230),
    ("USB-C Hub", 54.95, 120),
    ("Monitor 27in", 449.00, 67),
]
 
print(f"{'Product':<18} {'Price':>10} {'Stock':>7}")
print("-" * 37)
for name, price, stock in products:
    print(f"{name:<18} ${price:>9.2f} {stock:>7,}")
print("-" * 37)
 
total_value = sum(p * s for _, p, s in products)
print(f"{'Total Value':<18} ${total_value:>9,.2f}")
 
# Output:
# Product               Price   Stock
# -------------------------------------
# Laptop Pro         $ 1,299.99      45
# Wireless Mouse     $    29.50     230
# USB-C Hub          $    54.95     120
# Monitor 27in       $   449.00      67
# -------------------------------------
# Total Value        $91,498.05

    Datums- und Zeitformatierung mit F-Strings

    F-Strings akzeptieren direkt strftime-Formatcodes, was bedeutet, dass Sie datetime-Objekte formatieren können, ohne .strftime() aufzurufen:

    from datetime import datetime, date, timedelta
 
now = datetime.now()
 
print(f"ISO format:  {now:%Y-%m-%d %H:%M:%S}")
print(f"US format:   {now:%m/%d/%Y}")
print(f"Long format: {now:%B %d, %Y at %I:%M %p}")
print(f"Day of week: {now:%A}")
print(f"Short month: {now:%b %d}")
# Output (varies by current time):
# ISO format:  2026-02-13 14:30:00
# US format:   02/13/2026
# Long format: February 13, 2026 at 02:30 PM
# Day of week: Friday
# Short month: Feb 13

    Das funktioniert auch mit date-Objekten:

    from datetime import date
 
birthday = date(1995, 8, 15)
today = date.today()
age_days = (today - birthday).days
 
print(f"Birthday: {birthday:%B %d, %Y}")
print(f"Days alive: {age_days:,}")
print(f"Years (approx): {age_days / 365.25:.1f}")
# Output:
# Birthday: August 15, 1995
# Days alive: 11,139
# Years (approx): 30.5

    Mehrzeilige F-Strings

    Mit dreifachen Anführungszeichen können Sie formatierte Textblöcke erstellen. Jede Zeile in einem dreifachen f-String kann {}-Ausdrücke enthalten:

    project = "Data Pipeline"
owner = "Engineering Team"
status = "In Progress"
completion = 0.73
budget = 250000
spent = 182500
 
report = f"""
========================================
  Project Status Report
========================================
  Project:    {project}
  Owner:      {owner}
  Status:     {status}
  Completion: {completion:.0%}
  Budget:     ${budget:>12,}
  Spent:      ${spent:>12,}
  Remaining:  ${budget - spent:>12,}
========================================
"""
 
print(report)

    Sie können auch mehrzeilige f-Strings erstellen, indem Sie mehrere f-Strings mit impliziter String-Konkatenation verketten (indem Sie sie nebeneinander ohne Operator platzieren):

    name = "Alice"
role = "Data Scientist"
years = 5
 
bio = (
    f"Name: {name}\n"
    f"Role: {role}\n"
    f"Experience: {years} years\n"
    f"Seniority: {'Senior' if years >= 5 else 'Mid-level'}"
)
 
print(bio)
# Output:
# Name: Alice
# Role: Data Scientist
# Experience: 5 years
# Seniority: Senior

    Der zweite Ansatz vermeidet die führende neue Zeile und Einrückungsprobleme, die manchmal mit dreifachen Anführungszeichen auftreten.

    Der = Spezifikator für Debugging (Python 3.8+)

    Python 3.8 fügte den =-Spezifikator zu f-Strings hinzu, und es ist eines der nützlichsten Debugging-Features der Sprache. Wenn Sie f"{ausdruck=}" schreiben, gibt Python sowohl den Ausdruckstext als auch seinen Wert aus.

    x = 42
y = 17
 
print(f"{x=}")
print(f"{y=}")
print(f"{x + y=}")
print(f"{x * y=}")
# Output:
# x=42
# y=17
# x + y=59
# x * y=714

    Sie können = mit Formatierungsspezifikationen kombinieren:

    price = 49.99
tax_rate = 0.0825
total = price * (1 + tax_rate)
 
print(f"{price=:.2f}")
print(f"{tax_rate=:.1%}")
print(f"{total=:.2f}")
# Output:
# price=49.99
# tax_rate=8.2%
# total=54.12

    Der =-Spezifikator bewahrt Leerzeichen um sich herum. Das Hinzufügen von Leerzeichen vor = formatiert die Ausgabe:

    name = "Alice"
score = 95
 
print(f"{name = }")
print(f"{score = }")
# Output:
# name = 'Alice'
# score = 95

    Beachten Sie, dass = für Strings standardmäßig repr() verwendet (zeigt die Anführungszeichen). Für Zahlen verwendet es str().

    Debugging komplexer Ausdrücke

    Der =-Spezifikator funktioniert mit jedem Ausdruck und ist ein schneller Weg, Zwischenwerte zu inspizieren:

    data = [23, 45, 12, 67, 34, 89, 56]
 
print(f"{len(data)=}")
print(f"{sum(data)=}")
print(f"{sum(data)/len(data)=:.2f}")
print(f"{sorted(data)=}")
print(f"{max(data) - min(data)=}")
# Output:
# len(data)=7
# sum(data)=326
# sum(data)/len(data)=46.57
# sorted(data)=[12, 23, 34, 45, 56, 67, 89]
# max(data) - min(data)=77

    Wenn Sie in Jupyter Notebooks arbeiten und sich ständig dabei ertappen, print(f"{variable=}")-Aufrufe zum Debuggen hinzuzufügen, erwägen Sie RunCell (opens in a new tab), einen AI-Agenten, der direkt innerhalb von Jupyter läuft. RunCell versteht die Variablen im Speicher Ihres Notebooks und kann inspizieren, erklären und Korrekturen vorschlagen, ohne dass Sie manuell Debug-Statements schreiben müssen. Es ist besonders nützlich, wenn Sie durch Datentransformationen schreiten, bei denen Sie Zwischenwerte über mehrere Zellen hinweg überprüfen müssen.

    Verschachtelte F-Strings

    Sie können f-Strings innerhalb von f-Strings verschachteln. Der häufigste Anwendungsfall sind dynamische Formatierungsspezifikationen, bei denen die Breite oder Präzision aus einer Variable kommt:

    # Dynamic precision
value = 3.14159265
for precision in range(1, 6):
    print(f"  {precision} decimals: {value:.{precision}f}")
# Output:
#   1 decimals: 3.1
#   2 decimals: 3.14
#   3 decimals: 3.142
#   4 decimals: 3.1416
#   5 decimals: 3.14159
    # Dynamic width
header = "Report"
for width in [20, 30, 40]:
    print(f"|{header:^{width}}|")
# Output:
# |       Report       |
# |            Report            |
# |                 Report                 |
    # Nested f-string for formatting a list
values = [1.234, 56.789, 0.001, 999.999]
decimals = 2
formatted = f"Results: {', '.join(f'{v:.{decimals}f}' for v in values)}"
print(formatted)
# Output: Results: 1.23, 56.79, 0.00, 1000.00

    Verwenden Sie Verschachtelung sparsam. Wenn ein f-String mehr als eine Verschachtelungsebene erfordert, extrahieren Sie die innere Logik in eine Variable oder Funktion zur besseren Lesbarkeit.

    F-Strings vs. andere String-Formatierungsmethoden

    Python hat vier Hauptansätze zur String-Formatierung. Hier ist ein direkter Vergleich:

    Featuref-string f"...{x}...".format() "...{}...".format(x)% operator "...%s..." % xTemplate Template("...$x...")
    Python Version3.6+2.6+AllAll
    ReadabilityExcellent -- values inlineGood -- numbered/named placeholdersFair -- positional codesGood -- named placeholders
    PerformanceFastest~1.5-2x slower~1.3-1.8x slowerSlowest
    Arbitrary ExpressionsYesLimitedNoNo
    Debug Specifier (=)Yes (3.8+)NoNoNo
    Reusable TemplatesNoYesYesYes
    Safe for User InputNoNoNoYes (safe_substitute)
    Type FormattingFullFullPartialNone
    name = "Charlie"
balance = 1234.56
 
# f-string (recommended)
print(f"{name} has ${balance:,.2f}")
 
# .format()
print("{} has ${:,.2f}".format(name, balance))
 
# % formatting
print("%s has $%,.2f" % (name, balance))  # Note: %  does not support comma grouping
 
# Template (from string module)
from string import Template
t = Template("$name has $balance")
print(t.substitute(name=name, balance=f"${balance:,.2f}"))

    Wann welche zu verwenden:

    • F-Strings: Standardwahl für neuen Code. Verwenden Sie sie, wann immer Sie Python 3.6+ ausführen.
    • .format(): Verwenden Sie diese, wenn Sie wiederverwendbare Templates benötigen, die in Variablen oder Konfigurationsdateien gespeichert sind.
    • % formatting: Nur für Legacy-Code. Kein Grund, dies in neuen Projekten zu verwenden.
    • Template: Verwenden Sie dies, wenn das Format-String aus nicht vertrauenswürdiger Benutzereingabe stammt (es kann keine beliebigen Ausdrücke ausführen).

    Leistungsvergleich

    F-Strings sind schneller, weil Python sie zur Parse-Zeit in optimierten Bytecode kompiliert und so den Overhead von Methodenaufrufen und Argument-Parsing vermeidet, den .format() und % erfordern.

    import timeit
 
name = "Alice"
age = 30
score = 95.5
 
# Benchmark each method with 1 million iterations
fstring_time = timeit.timeit(
    'f"{name} scored {score:.1f} at age {age}"',
    globals={"name": name, "age": age, "score": score},
    number=1_000_000
)
 
format_time = timeit.timeit(
    '"{} scored {:.1f} at age {}".format(name, score, age)',
    globals={"name": name, "age": age, "score": score},
    number=1_000_000
)
 
percent_time = timeit.timeit(
    '"%s scored %.1f at age %d" % (name, score, age)',
    globals={"name": name, "age": age, "score": score},
    number=1_000_000
)
 
concat_time = timeit.timeit(
    'name + " scored " + str(score) + " at age " + str(age)',
    globals={"name": name, "age": age, "score": score},
    number=1_000_000
)
 
print(f"f-string:      {fstring_time:.4f}s (baseline)")
print(f"str.format():  {format_time:.4f}s ({format_time/fstring_time:.2f}x slower)")
print(f"% formatting:  {percent_time:.4f}s ({percent_time/fstring_time:.2f}x slower)")
print(f"concatenation: {concat_time:.4f}s ({concat_time/fstring_time:.2f}x slower)")
 
# Typical results:
# f-string:      0.0850s (baseline)
# str.format():  0.1450s (1.71x slower)
# % formatting:  0.1100s (1.29x slower)
# concatenation: 0.1200s (1.41x slower)

    Die Leistungslücke vergrößert sich, wenn die Ausdrücke komplexer werden. In engen Schleifen, die Tausende von Datensätzen verarbeiten, machen f-Strings einen messbaren Unterschied.

    Häufige Fehler und Tücken

    Escaping von geschweiften Klammern

    Um ein literales { oder } in einem f-String einzufügen, verdoppeln Sie es:

    value = 42
 
# Literal braces around a value
print(f"{{{value}}}")
# Output: {42}
 
# JSON-like output
key = "name"
val = "Alice"
print(f'{{"{key}": "{val}"}}')
# Output: {"name": "Alice"}
 
# Just literal braces, no interpolation
print(f"Use {{variable}} syntax in f-strings")
# Output: Use {variable} syntax in f-strings

    Backslashes innerhalb von Ausdrücken

    Sie können keine Backslash-Zeichen innerhalb des {}-Ausdrucksteils eines f-Strings verwenden. Dies ist eine bewusste Designentscheidung für Lesbarkeit:

    items = ["apple", "banana", "cherry"]
 
# This causes a SyntaxError:
# print(f"{'\\n'.join(items)}")
 
# Solution 1: assign to a variable first
newline = "\n"
print(f"{newline.join(items)}")
 
# Solution 2: use a separate operation
joined = "\n".join(items)
print(f"Items:\n{joined}")
 
# Solution 3: use chr()
print(f"{chr(10).join(items)}")

    Anführungszeichen-Konflikte

    Wenn Ihr f-String doppelte Anführungszeichen verwendet, müssen Ausdrücke innerhalb einfache Anführungszeichen verwenden (oder umgekehrt):

    data = {"name": "Alice", "age": 30}
 
# Use single quotes inside when f-string uses double quotes
print(f"Name: {data['name']}, Age: {data['age']}")
 
# Or use double quotes inside when f-string uses single quotes
print(f'Name: {data["name"]}, Age: {data["age"]}')
 
# With triple quotes, you have more flexibility
print(f"""Name: {data["name"]}, Age: {data["age"]}""")

    F-Strings sind keine Konstanten

    F-Strings werden zur Laufzeit ausgewertet, was bedeutet, dass Sie sie nicht als Standardargumentwerte oder Modul-Level-Konstanten verwenden können, die von Laufzeit-Zuständen abhängen:

    # This works but evaluates at call time, not definition time
def greet(name, template=None):
    if template is None:
        template = f"Hello, {name}!"  # Evaluated here
    return template
 
# For true templates, use str.format()
TEMPLATE = "Hello, {name}! You have {count} messages."
print(TEMPLATE.format(name="Alice", count=5))

    Vorsicht vor großen Ausdrücken

    Nur weil Sie einen beliebigen Ausdruck in einen f-String setzen können, bedeutet das nicht, dass Sie das tun sollten. Halten Sie f-String-Ausdrücke einfach:

    # Hard to read -- too much logic inside the f-string
result = f"{'%.2f' % (sum(x**2 for x in range(100)) / 100)}"
 
# Much better -- compute first, then format
mean_square = sum(x**2 for x in range(100)) / 100
result = f"{mean_square:.2f}"

    Raw F-Strings

    Die Kombination von r (raw) und f-Präfixen erzeugt einen Raw f-String, bei dem Backslashes wörtlich behandelt werden (keine Escape-Sequenzen), während Ausdrücke weiterhin ausgewertet werden:

    user = "admin"
folder = "projects"
 
# Raw f-string for Windows paths
path = rf"C:\Users\{user}\{folder}\data.csv"
print(path)
# Output: C:\Users\admin\projects\data.csv
 
# Useful for regex patterns with dynamic parts
import re
prefix = "user"
pattern = rf"\b{prefix}_\d+\b"
text = "Found user_123 and user_456 in the log"
matches = re.findall(pattern, text)
print(f"Matches: {matches}")
# Output: Matches: ['user_123', 'user_456']

    Sowohl rf"..." als auch fr"..." sind gültig – die Reihenfolge der Präfixe spielt keine Rolle.

    F-Strings in Data-Science-Workflows

    F-Strings sind in der Datenwissenschaft unverzichtbar für die Formatierung von Ausgaben, das Erstellen dynamischer Labels und das Erstellen lesbarer Zusammenfassungen aus numerischen Ergebnissen.

    Formatierung numerischer Ausgaben

    import statistics
 
data = [23.4, 45.1, 31.8, 52.3, 41.7, 38.9, 29.6, 47.2]
 
mean = statistics.mean(data)
median = statistics.median(data)
stdev = statistics.stdev(data)
cv = stdev / mean  # coefficient of variation
 
print(f"Sample size:    {len(data)}")
print(f"Mean:           {mean:.2f}")
print(f"Median:         {median:.2f}")
print(f"Std deviation:  {stdev:.2f}")
print(f"CV:             {cv:.1%}")
print(f"Range:          {min(data):.1f} - {max(data):.1f}")
# Output:
# Sample size:    8
# Mean:           38.75
# Median:         40.30
# Std deviation:  9.87
# CV:             25.5%
# Range:          23.4 - 52.3

    Arbeiten mit Pandas DataFrames

    import pandas as pd
 
df = pd.DataFrame({
    "product": ["Widget A", "Widget B", "Widget C", "Widget D"],
    "revenue": [125000, 89000, 234000, 67000],
    "units": [1250, 2100, 980, 3400],
})
 
# Summary statistics with f-strings
total_rev = df["revenue"].sum()
avg_price = (df["revenue"] / df["units"]).mean()
 
print(f"Total Revenue:  ${total_rev:>12,}")
print(f"Avg Unit Price: ${avg_price:>12,.2f}")
print(f"Products:       {len(df):>12,}")
 
# Dynamic column formatting
for _, row in df.iterrows():
    unit_price = row["revenue"] / row["units"]
    print(f"  {row['product']:<12} | Revenue: ${row['revenue']:>9,} | Units: {row['units']:>5,} | $/unit: ${unit_price:.2f}")
 
# Output:
# Total Revenue:  $     515,000
# Avg Unit Price: $       56.00
# Products:              4
#   Widget A     | Revenue: $  125,000 | Units: 1,250 | $/unit: $100.00
#   Widget B     | Revenue: $   89,000 | Units: 2,100 | $/unit: $42.38
#   Widget C     | Revenue: $  234,000 | Units:   980 | $/unit: $238.78
#   Widget D     | Revenue: $   67,000 | Units: 3,400 | $/unit: $19.71

    Wenn Ihre Datenanalyse über Textzusammenfassungen hinausgeht und Sie interaktive Erkundung benötigen, kann PyGWalker (opens in a new tab) jeden pandas DataFrame mit einer einzigen Codezeile in eine Tableau-ähnliche interaktive Visualisierung verwandeln. Anstatt Zahlen manuell für statische Berichte zu formatieren, können Sie Spalten per Drag-and-Drop zu Diagrammen zusammenstellen, Filter anwenden und Muster visuell erkunden – alles innerhalb Ihres Jupyter Notebooks.

    import pandas as pd
import pygwalker as pyg
 
# After preparing your DataFrame with well-formatted columns
df = pd.DataFrame({
    "Month": ["Jan", "Feb", "Mar", "Apr", "May", "Jun"],
    "Revenue": [125000, 134000, 158000, 142000, 167000, 189000],
    "Growth": [0.05, 0.072, 0.179, -0.101, 0.176, 0.132],
})
 
# Add formatted columns for display
df["Revenue_Display"] = df["Revenue"].apply(lambda x: f"${x:,.0f}")
df["Growth_Display"] = df["Growth"].apply(lambda x: f"{x:+.1%}")
 
# Launch interactive visualization
# pyg.walk(df)

    Formatierung von Modellergebnissen

    # Formatting machine learning results
metrics = {
    "accuracy": 0.9234,
    "precision": 0.8891,
    "recall": 0.9456,
    "f1_score": 0.9164,
    "auc_roc": 0.9678,
}
 
print("Model Evaluation Results")
print("=" * 35)
for metric, value in metrics.items():
    bar_length = int(value * 20)
    bar = "#" * bar_length + "-" * (20 - bar_length)
    print(f"  {metric:<12} {value:.4f}  [{bar}]")
# Output:
# Model Evaluation Results
# ===================================
#   accuracy     0.9234  [##################--]
#   precision    0.8891  [#################---]
#   recall       0.9456  [##################--]
#   f1_score     0.9164  [##################--]
#   auc_roc      0.9678  [###################-]

    Konvertierungsflags: !s, !r und !a

    F-Strings unterstützen drei Konvertierungsflags, die steuern, wie der Ausdruckswert vor der Formatierung konvertiert wird:

    • !s ruft str() für den Wert auf (Standardverhalten)
    • !r ruft repr() für den Wert auf
    • !a ruft ascii() für den Wert auf
    text = "Hello\tWorld"
name = "Caf\u00e9"
 
print(f"str:   {text!s}")
print(f"repr:  {text!r}")
print(f"ascii: {name!a}")
# Output:
# str:   Hello	World
# repr:  'Hello\tWorld'
# ascii: 'Caf\xe9'

    Das !r-Flag ist besonders für das Debugging nützlich, da es die rohe Darstellung einschließlich Anführungszeichen und Escape-Zeichen zeigt. Es funktioniert gut zusammen mit dem =-Spezifikator.

    Häufig gestellte Fragen

    Was sind Python f-strings und wann wurden sie eingeführt?

    F-Strings (formatierte String-Literale) sind ein String-Formatierungsmechanismus, der in Python 3.6 durch PEP 498 eingeführt wurde. Sie ermöglichen es, Python-Ausdrücke direkt in String-Literale einzubetten, indem dem String ein f vorangestellt und Ausdrücke in geschweifte Klammern gesetzt werden. F-Strings werden zur Laufzeit ausgewertet, bieten die beste Lesbarkeit unter allen Python-String-Formatierungsoptionen und sind schneller als str.format() und %-Formatierung, da sie zur Parse-Zeit in optimierten Bytecode kompiliert werden.

    Wie formatiere ich Zahlen mit Kommas und Dezimalstellen in f-strings?

    Verwenden Sie die Formatierungsspezifikation nach einem Doppelpunkt innerhalb der Klammern. Für Kommas als Tausender-Trennzeichen verwenden Sie :, – zum Beispiel produziert f"{1234567:,}" "1.234.567". Für Dezimalstellen verwenden Sie :.Nf, wobei N die Anzahl der Ziffern ist. Kombinieren Sie beides: f"{1234.5:,.2f}" gibt "1.234,50" aus. Für Prozentsätze verwenden Sie :.N%, was mit 100 multipliziert und ein Prozentzeichen anhängt: f"{0.85:.1%}" produziert "85,0%".

    Was ist der f-string = Spezifikator und wie hilft er beim Debugging?

    Der =-Spezifikator wurde in Python 3.8 hinzugefügt und gibt sowohl den Ausdruckstext als auch seinen Wert aus. Das Schreiben von f"{variable=}" gibt variable=wert aus. Dies eliminiert die Notwendigkeit, den Variablennamen zweimal zu tippen, beim Debuggen. Es funktioniert mit jedem Ausdruck und kann mit Formatierungsspezifikationen wie f"{price=:.2f}" kombiniert werden.

    Kann ich f-strings mit mehrzeiligen Strings verwenden?

    Ja. Verwenden Sie dreifache Anführungszeichen (f"""...""" oder f'''...''') für mehrzeilige f-Strings. Jede Zeile kann {expression}-Platzhalter enthalten. Alternativ können Sie mehrere f-Strings mit impliziter String-Konkatenation verketten, indem Sie sie nebeneinander in Klammern platzieren.

    Sind f-strings schneller als str.format() und % Formatierung?

    Ja. F-Strings sind durchweg die schnellste String-Formatierungsmethode in Python. Sie laufen typischerweise 1,5 bis 2 Mal schneller als str.format() und 1,3 bis 1,8 Mal schneller als %-Formatierung. Der Geschwindigkeitsvorteil kommt von der Optimierung zur Compile-Zeit, bei der Python f-Strings direkt in effizienten Bytecode umwandelt.

    Wie füge ich literale geschweifte Klammern in einen f-string ein?

    Verdoppeln Sie die Klammern. Verwenden Sie {{ für ein literales { und }} für ein literales }. Zum Beispiel gibt f"{{value}}" {value} als reinen Text aus. Um einen interpolierten Wert in Klammern zu setzen, verwenden Sie f"{{{variable}}}" – die äußeren doppelten Klammern erzeugen literale Klammern, während die inneren einzelnen Klammern die Interpolation auslösen.

    Fazit

    F-Strings sind der Standardweg, Strings in modernem Python zu formatieren. Sie kombinieren die beste Lesbarkeit jedes Formatierungsansatzes mit der besten Performance, und sie unterstützen die volle Bandbreite an Formatierungsspezifikationen: Dezimalpräzision, Tausender-Trennzeichen, Prozentsätze, wissenschaftliche Notation, Ausrichtung, Auffüllung, Datumsformatierung und Zahlensystem-Konvertierungen.

    Die wichtigsten Dinge, die man sich merken sollte:

    • Präfix mit f und setzen Sie Ausdrücke innerhalb von {Klammern}.
    • Verwenden Sie : gefolgt von einer Formatangabe für präzise Kontrolle über die Ausgabe (:.2f, :, :.1%, :<20).
    • Verwenden Sie = nach dem Ausdruck für Debugging (f"{variable=}"). Erfordert Python 3.8+.
    • Escapen Sie literale Klammern durch Verdoppeln: {{ und }}.
    • Setzen Sie keine Backslashes innerhalb der {} Ausdrücke. Weisen Sie zuerst einer Variable zu.
    • Halten Sie Ausdrücke einfach. Wenn die Logik innerhalb von {} schwer zu lesen ist, extrahieren Sie sie.
    • Verwenden Sie .format() nur, wenn Sie wiederverwendbare Templates in Variablen benötigen.

    F-Strings behandeln alles vom schnellen print()-Debugging bis zur Produktionsberichtserstellung. Sobald Sie sie übernommen haben, gibt es keinen Grund, zu älteren Formatierungsmethoden zurückzukehren. Ob Sie Daten-Pipelines bauen, ML-Modell-Ausgaben formatieren oder Finanzberichte generieren – f-Strings liefern sauberen, schnellen, lesbaren Code.

    📚