Python-String-Interpolation: Ein Einsteigerleitfaden

Angenommen, du möchtest den Namen und den Beruf einer Person ausgeben. Du könntest ein einfaches Programm wie folgt schreiben.

# Define variables
name = 'Mark'
profession = 'Astronaut'
age = 7


# Output info
output_string = ('My name is ' + name +
                ', I am ' + str(age) + ' years old ' +
                'and my profession is ' + profession + '.')
print(output_string)Bereitgestellt von

   My name is Mark, I am 7 years old and my profession is Astronaut.Bereitgestellt von

Dieser Ansatz ist weder knapp noch gut lesbar. Zum Glück gibt es mit Stringinterpolation eine bessere Lösung. Damit lassen sich Variablen, Ausdrücke oder Funktionsausgaben direkt in einen String einfügen. Das macht die Stringverarbeitung dynamisch und erspart umständliche Verkettungen.

Mit Stringinterpolation ließe sich der Code zum Beispiel so schreiben.

# Define variables
name = 'Mark'
profession = 'Astronaut'
age = 7


# Output info
output_string = f'My name is {name}, I am {age} years old and my profession is {profession}.'
print(output_string)Bereitgestellt von

   My name is Mark, I am 7 years old and my profession is Astronaut.Bereitgestellt von

Die Version mit Stringinterpolation erlaubt es, Ausdrücke direkt im String zu platzieren – ganz ohne unübersichtliche Verkettungen. Wie du siehst, ist das deutlich aufgeräumter.

Grundlagen der Stringinterpolation in Python

In Python gibt es mehrere Techniken zur Stringinterpolation. Am häufigsten empfohlen werden formatierte String-Literale, die sogenannten f-Strings. Sie sind seit Python 3.6 verfügbar.

Eine weitere Methode, die du häufig in Code vor Python 3.6 siehst, ist die .format()-Methode. Sie ist zwar ausführlicher als f-Strings, hat aber gelegentlich Vorteile (siehe unten).

Schließlich könntest du in Legacy-Code auch noch auf %-Formatierung stoßen.

f-Strings verwenden (Python 3.6+)

f-Strings (formatierte String-Literale) sind eine leistungsfähige und kompakte Möglichkeit, Strings in Python zu formatieren. Sie wurden mit Python 3.6 eingeführt und bieten eine gut lesbare und effiziente Art, Variablen, Ausdrücke und Funktionsaufrufe direkt in Strings einzubetten.

Ein einfaches Beispiel für die f-String-Syntax sieht so aus:

name = 'Mark'
output_string = f'My name is {name}.'
print(output_string)Bereitgestellt von

   My name is Mark.Bereitgestellt von

In diesem Code wird der Variablen output_string ein f-String zugewiesen. Das Präfix f vor dem öffnenden Anführungszeichen zeigt an, dass der String eingebettete Ausdrücke unterstützt. Die Variable name wird ausgewertet und ihr Wert in den String eingesetzt. Dadurch ergibt sich die Ausgabe: "My name is Mark."

Nicht nur Variablenwerte, sondern auch Berechnungen oder Ausdrücke lassen sich in f-Strings einbetten. Betrachte dieses Beispiel:

import math


a = 3.0
b = 4.0


# Use string interpolation for the formula
print(f'The hypotenuse of a triangle with base {a} and side {b} is {math.sqrt(a ** 2 + b ** 2)}.')Bereitgestellt von

   The hypotenuse of a triangle with base 3.0 and side 4.0 is 5.0.Bereitgestellt von

Der Ausdruck math.sqrt(a ** 2 + b ** 2) wird direkt im String ausgewertet. Du musst den Wert also nicht vorher separat berechnen und anschließend einfügen.

Die .format()-Methode verwenden

Wie f-Strings erlaubt auch die Methode .format(), Variablen und Ausdrücke in einen String einzusetzen. Die Grundsyntax von .format() sieht so aus:

name = 'Mark'
output_string = 'My name is {}.'.format(name)
print(output_string)Bereitgestellt von

   My name is Mark.Bereitgestellt von

Die geschweiften Klammern {} fungieren als Platzhalter und signalisieren, dass an dieser Stelle ein Variablenwert in den String eingesetzt wird. Welche Variable in welchen Platzhalter wandert, ergibt sich aus den Argumenten der .format()-Methode.

Positionsargumente

Was passiert, wenn du mehrere Platzhalter für mehrere Variablen brauchst? Sieh dir den folgenden Code an.

name = 'Mark'
age = 7


# The placeholders are filled in order of the arguments
output_string = 'My name is {} and I am {} years old.'.format(name, age)


print(output_string)Bereitgestellt von

   My name is Mark and I am 7 years old.Bereitgestellt von

In diesem Beispiel werden zwei Variablen benötigt: name und age. Daher enthält der String zwei Platzhalter, und die Variablen werden in der Reihenfolge der Argumente in .format() eingesetzt. Diese Argumente heißen Positionsargumente, weil ihre Platzierung im String von ihrer Position in der Argumentliste abhängt.

Indizierte und benannte Platzhalter

Als Variante des Platzhalterprinzips betrachte dieses Beispiel.

name = 'Mark'
age = 7


# Print age twice
output_string = 'My name is {} and I am {} years old. My twin brother is also {} years old.'.format(name, age, age)
print(output_string)Bereitgestellt von

   My name is Mark and I am 7 years old. My twin brother is also 7 years old.Bereitgestellt von

Hier haben wir den Wert der Variablen age zweimal wiederverwendet. Dasselbe Argument mehrfach zu übergeben, ist unhandlich und mindert die Lesbarkeit. Lässt sich eine Variable mit .format() wiederverwenden, ohne sie zu wiederholen? Ja – mit sogenannten indizierten Platzhaltern.

name = 'Mark'
age = 7


# Use indexed placeholders
output_string = 'My name is {0} and I am {1} years old. My twin brother is also {1} years old.'.format(name, age)
print(output_string)Bereitgestellt von

   My name is Mark and I am 7 years old. My twin brother is also 7 years old.Bereitgestellt von

In diesem Beispiel definieren wir die Reihenfolge der Variablen innerhalb der geschweiften Klammern explizit gemäß Pythons nullbasierter Indizierung. Außerdem verwenden wir die Variable am Index 1 erneut, statt sie zu duplizieren.

Alternativ zu Positionsindizes kannst du auch benannte Argumente verwenden und jedem Argument einen Namen geben.

print('My name is {name} and I am {age} years old.'.format(name='Mark', age=7))Bereitgestellt von

   My name is Mark and I am 7 years old.Bereitgestellt von

Das benannte Argument wird in den geschweiften Klammern mit seinem Namen ausgewertet. Dadurch ersetzt {name} den Platzhalter durch den Wert "Mark" und {age} wird durch 30 ersetzt.

Den % Operator verwenden

Die dritte Methode zur Stringinterpolation ist der %-Operator. Er funktioniert ähnlich wie der printf()-Befehl in C. Seine Nutzung gilt als veraltet und wird zugunsten von f-Strings oder der .format()-Methode deutlich nicht empfohlen. Wir erwähnen ihn hier, weil du ihm in alten Codebasen begegnen könntest.

Das Grundmuster des %-Operators lautet: "format string" % values. Der Formatstring enthält Platzhalter wie %s für Strings, die durch Werte ersetzt werden. Das folgende Beispiel gibt etwa "Hello, Mark." aus.

'Hello %s' % 'Mark'Bereitgestellt von

   'Hello Mark'Bereitgestellt von

Weitere gängige Formatspezifizierer siehst du in der folgenden Tabelle.

Der % Operator hat viele Einschränkungen. Unter anderem ist er weniger gut lesbar als f-Strings. Betrachte diesen Code:

name = "Alice"
age = 30
height = 5.6


# The % operator is hard to scan
message = "My name is %s, I am %d years old, and my height is %.1f feet." % (name, age, height)
print(message)Bereitgestellt von

   My name is Alice, I am 30 years old, and my height is 5.6 feet.Bereitgestellt von

Ist dieser Code auf den ersten Blick klar? Eher nicht. Man muss ständig zwischen Platzhaltern und Variablen hin- und herblicken. Dabei kann man sich leicht vertun – oder schwindelig werden.

Schau dir nun den äquivalenten Code mit f-Strings an.

# This is much cleaner
message = f"My name is {name}, I am {age} years old, and my height is {height:.1f} feet."
print(message)Bereitgestellt von

   My name is Alice, I am 30 years old, and my height is 5.6 feet.Bereitgestellt von

Kein Hin-und-her-Scannen und keine kryptischen Formatstrings nötig. Der Code ist sauber, leicht zu verstehen und schnell geschrieben. Weitere Tipps für klaren, performanten Code findest du im Python Programming skill track von DataCamp. 

Fortgeschrittene Techniken der Python-Stringinterpolation

Nachdem wir die Grundlagen der Python-Stringinterpolation geklärt haben, werfen wir nun einen Blick auf weiterführende Anwendungsfälle. 

Mehrzeilige Stringinterpolation in Python

f-Strings lassen sich auch für mehrzeilige Inhalte verwenden, indem du das f-Präfix mit dreifachen Anführungszeichen (einfach oder doppelt) kombinierst. Der Text kann sich über mehrere Zeilen erstrecken und erscheint in der Ausgabe genau in diesem Format.

name = 'Mark'
profession = 'Astronaut'
age = 7


# This is an example of a multiline string
bio = f"""
Name: {name}
Profession: {profession}
Age: {age}
"""
print(bio)Bereitgestellt von

   Name: Mark

   Profession: Astronaut

   Age: 7Bereitgestellt von

 Mehrzeilige Strings lassen sich auch mit der .format()-Methode erstellen.

name = 'Mark'
profession = 'Astronaut'
age = 7


# This is a multiline string with .format()
bio = """
Name: {}
Profession: {}
Age: {}
""".format(name, profession, age)
print(bio)Bereitgestellt von

   Name: Mark

   Profession: Astronaut

   Age: 7Bereitgestellt von

Einsatzszenarien für mehrzeilige Stringinterpolation

Warum sollte man mehrzeilige Stringinterpolation nutzen? Es gibt zahlreiche Anwendungsfälle. Hier ein paar Beispiele:

• Mehrzeilige E-Mails oder Nachrichten generieren
• Logging und Debugging
• SQL-Queries dynamisch erzeugen

Mehrzeilige E-Mails oder Nachrichten generieren

Angenommen, du verschickst ein Standardschreiben an viele Einladungen für eine Tech-Konferenz.

name = "Alice"
event = "Annual Tech Conference"
date = "March 15, 2025"


email = """Dear {name},


We are pleased to invite you to the {event} taking place on {date}.
We hope you can join us for an exciting experience.


Best regards, 
The Event Team""".format(name=name, event=event, date=date)


print(email)Bereitgestellt von

   Dear Alice,

  

   We are pleased to invite you to the Annual Tech Conference taking place on March 15, 2025.

   We hope you can join us for an exciting experience.

  

   Best regards, 

   The Event TeamBereitgestellt von

Mit f-Strings ist das Erstellen von Serienbriefen simpel und effizient. Möchtest du Name, Event oder Datum ändern, passt du einfach die Variablen an – der String aktualisiert sich automatisch.

Logging und Debugging

Mehrzeilige Strings eignen sich hervorragend, um Fehlermeldungen für Logs strukturiert auszugeben.

error_code = 404
url = '/missing-page'
timestamp = '2025-02-05 12:30:00'
error_message = 'The requested page could not be found.'


log_message = f"""[ERROR {error_code}]
Time: {timestamp}
URL: {url}


{error_message}"""


print(log_message)Bereitgestellt von

   [ERROR 404]

   Time: 2025-02-05 12:30:00

   URL: /missing-page

 

   The requested page could not be found.Bereitgestellt von

So bleiben Logmeldungen strukturiert und erleichtern dank sauberem Format die Fehlersuche.

SQL-Queries dynamisch erzeugen

SQL-Abfragen lassen sich mit mehrzeiligen Strings dynamisch zusammenbauen.

table = 'users'
column = 'email'
value = '[email protected]'


query = f"""SELECT *
FROM {table}
WHERE {column} = '{value}';"""


print(query)Bereitgestellt von

   SELECT *

   FROM users

   WHERE email = '[email protected]';Bereitgestellt von

Das macht SQL-Queries gut lesbar und erhält Einrückungen. Außerdem entfällt die Verwendung von + zur Stringverkettung.

Weitere Anwendungsfälle sind:

• Formatierte Verträge schreiben
• Markdown- oder $\LaTeX-Dokumente generieren
• Mehrzeilige HTML/XML-Templates
• API-Responses oder JSON-ähnlichen Text erzeugen

Vorteile der mehrzeiligen Stringinterpolation

Wie wir sehen, bietet mehrzeilige Stringinterpolation mehrere Vorteile.

• Die Formatierung bleibt erhalten, ohne dass das Escape-Zeichen \n nötig ist. 
• Mehr Lesbarkeit gegenüber einzeiligen Formatierungen. 
• Weniger Ballast bei strukturierten Texten (z. B. Logs, Queries, Reports). 
• Dynamische Textgenerierung, ohne Einrückungen zu zerstören. 

Zahlen und Sonderwerte formatieren

Um die Zahl der Nachkommastellen in einem f-String zu steuern, verwende die Syntax: f'{value:.nf}', wobei value die Fließkommazahl ist, n die gewünschte Anzahl an Dezimalstellen und f (hinter dem .) für Float-Formatierung steht.

Zur Veranschaulichung gibt der folgende Code $\pi$ mit unterschiedlichen Nachkommastellen aus.

pi = 3.1415926535


print(f'Pi rounded to 2 decimal places: {pi:.2f}')
print(f'Pi rounded to 4 decimal places: {pi:.4f}')
print(f'Pi rounded to 0 decimal places: {pi:.0f}')Bereitgestellt von

   Pi rounded to 2 decimal places: 3.14
   Pi rounded to 4 decimal places: 3.1416
   Pi rounded to 0 decimal places: 3Bereitgestellt von

Die Formatierung mit der .format()-Methode funktioniert ähnlich.

print('Pi rounded to 2 decimal places: {:.2f}'.format(pi))
print('Pi rounded to 4 decimal places: {:.4f}'.format(pi))
print('Pi rounded to 0 decimal places: {:.0f}'.format(pi))Bereitgestellt von

   Pi rounded to 2 decimal places: 3.14
   Pi rounded to 4 decimal places: 3.1416
   Pi rounded to 0 decimal places: 3Bereitgestellt von

Prozentwerte formatierst du mit einem f-String über die Syntax :.nf in Kombination mit %, wobei n die Zahl der Dezimalstellen angibt.

score = 0.875
print(f"Success rate: {score:.2%}")Bereitgestellt von

   Success rate: 87.50%Bereitgestellt von

Währungsbeträge formatierst du mit einem f-String z. B. mit :, für Tausendertrennzeichen und .nf zur Steuerung der Nachkommastellen. Ein Währungssymbol wie $, € oder £ kannst du direkt im String ergänzen.

amount = 98765.4321


print(f"USD: ${amount:,.2f}")
print(f"EUR: €{amount:,.2f}")
print(f"GBP: £{amount:,.2f}")Bereitgestellt von

   USD: $98,765.43

   EUR: €98,765.43

   GBP: £98,765.43Bereitgestellt von

f-Strings mit Dictionaries und Listen verwenden

Um f-Strings mit einem Dictionary zu nutzen, greifst du innerhalb der geschweiften Klammern per eckiger Klammernotation (dict['key']) auf Werte zu oder entpackst das Dictionary mit **.

person = {
   'name': 'Alice',
   'age': 30,
   'city': 'New York'
}


print(f"My name is {person['name']}, I am {person['age']} years old, and I live in {person['city']}.")Bereitgestellt von

   My name is Alice, I am 30 years old, and I live in New York.Bereitgestellt von

Anstatt jeden Key manuell zu referenzieren, kannst du das Dictionary auch wie folgt in einen f-String entpacken.

person = {
   'name': 'Alice',
   'age': 30,
}


print(f'My name is {name} and I am {age} years old.'.format(**person))Bereitgestellt von

   My name is Alice and I am 7 years old.Bereitgestellt von

Um Fehler durch fehlende Keys zu vermeiden, nutze für den Dictionary-Zugriff get().

person = {"name": "Alice"}


# Error: key 'city' is missing
print(f"City: {person['city']}") Bereitgestellt von

   ---------------------------------------------------------------------------




   KeyError                                  Traceback (most recent call last)




   Cell In[87], line 4

         1 person = {"name": "Alice"}

         3 # Error: key 'city' is missing

   ----> 4 print(f"City: {person['city']}")







   KeyError: 'city'Bereitgestellt von

print(f"City: {person.get('city', 'Not specified')}")Bereitgestellt von

   City: Not specifiedBereitgestellt von

Vor- und Nachteile der Stringinterpolationsmethoden

Wie gesehen, sind f-Strings und die .format()-Methode beide nützlich für Stringinterpolation. Schauen wir uns einen Vergleich der Stärken und Schwächen an.

Wann solltest du .format() statt f-Strings verwenden?

Häufige Stolperfallen und Best Practices

Im Folgenden findest du einige Tipps und Troubleshooting-Hinweise für Python-Stringinterpolation. 

Syntaxfehler mit geschweiften Klammern vermeiden

Bei Stringinterpolation mit geschweiften Klammern passieren schnell Syntaxfehler.

• Achte darauf, dass jedes { ein passendes } hat.

print('Hello, my name is {name!'}Bereitgestellt von

     Cell In[96], line 1

       print('Hello, my name is {name!'}
                                       ^
   SyntaxError: closing parenthesis '}' does not match opening parenthesis '('Bereitgestellt von

Zum Glück ist die Fehlermeldung eindeutig und die Korrektur simpel.

• Verwende {{ und }} für die Ausgabe von wörtlichen {}

Was, wenn du geschweifte Klammern in einem interpolierten String anzeigen möchtest? Alles innerhalb von geschweiften Klammern wird (versuchsweise) ausgewertet.

print(f'Set notation: {a, b, c}')Bereitgestellt von

   ---------------------------------------------------------------------------

   NameError                                 Traceback (most recent call last)

   Cell In[101], line 1

   ----> 1 print(f'Set notation: {a, b, c}')

   NameError: name 'c' is not definedBereitgestellt von

Python interpretiert a, b, c innerhalb der geschweiften Klammern als Tuple und versucht, einen Wert zu a zu finden. Da es keine entsprechende Variable gibt, wird ein KeyError ausgelöst. Die Lösung ist, doppelte geschweifte Klammern {{}} zu verwenden.

print("Set notation: {{a, b, c}}")Bereitgestellt von

   Set notation: {{a, b, c}}

Performance-Vergleich: f-strings vs. .format()

Vergleichen wir die Performance von f-strings und .format().

import timeit


name = "Alice"
age = 30
pi = 3.1415926535


# Measure f-string performance
f_string_time = timeit.timeit('f"My name is {name} and I am {age} years old."', globals=globals(), number=1000000)


# Measure .format() performance
format_time = timeit.timeit('"My name is {} and I am {} years old.".format(name, age)', globals=globals(), number=1000000)


# Measure f-string performance with expressions
f_string_expr_time = timeit.timeit('f"Pi rounded to 2 decimal places: {pi:.2f}"', globals=globals(), number=1000000)


# Measure .format() performance with expressions
format_expr_time = timeit.timeit('"Pi rounded to 2 decimal places: {:.2f}".format(pi)', globals=globals(), number=1000000)


# Print results
print(f"f-string (simple): {f_string_time:.6f} seconds")
print(f".format() (simple): {format_time:.6f} seconds")
print(f"f-string (with expression): {f_string_expr_time:.6f} seconds")
print(f".format() (with expression): {format_expr_time:.6f} seconds")Bereitgestellt von

   f-string (simple): 0.080447 seconds

   .format() (simple): 0.129860 seconds

   f-string (with expression): 0.123171 seconds

   .format() (with expression): 0.146242 secondsBereitgestellt von

Wie du siehst, solltest du aus Effizienzgründen f-strings gegenüber .format() bevorzugen.

Best Practices für saubere, gut lesbare String-Interpolation

Damit deine String-Formatierung klar, effizient und wartbar bleibt, befolge bei interpolierten Strings diese Best Practices.

• Bevorzuge f-strings für bessere Lesbarkeit (Python 3.6+)

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


# Not Recommended (Less readable)
print("My name is {} and I am {} years old.".format(name, age))


# Avoid using % formatting (Outdated)
print("My name is %s and I am %d years old." % (name, age))Bereitgestellt von

   My name is Alice and I am 30 years old.

   My name is Alice and I am 30 years old.

   My name is Alice and I am 30 years old.Bereitgestellt von

• Verwende benannte Platzhalter für mehr Klarheit.

# Named placeholders (readable)
user = {"name": "Alice", "age": 30}
print(f"My name is {user['name']} and I am {user['age']} years old.")


# Using indexes in .format() (not as readable)
print("My name is {0} and I am {1} years old.".format("Alice", 30))Bereitgestellt von

   My name is Alice and I am 30 years old.

   My name is Alice and I am 30 years old.Bereitgestellt von

• Halte mehrzeilige Strings gut lesbar.

name = "Alice"
age = 30


message = f"""Hello, {name}!


We are happy to invite you to our event.
At {age} years old, you are eligible for the VIP pass.


Best regards,
Event Team
"""
print(message)Bereitgestellt von

   Hello, Alice!


   We are happy to invite you to our event.

   At 30 years old, you are eligible for the VIP pass.


   Best regards,

   Event Team  Bereitgestellt von

• Nutze f-strings im Logging für besseres Debugging.

Python 3.8 und neuer unterstützt = zum Debuggen in f-strings.

value = 42


# Output: value = 42
print(f"{value = }") Bereitgestellt von

   value = 42Bereitgestellt von

Fazit

String-Interpolation ist ein leistungsstarkes Feature in Python, das die String-Formatierung sauberer, besser lesbar und effizienter macht. Unter den verfügbaren Methoden sind f-strings der modernste und empfohlene Ansatz. Sie bieten bessere Performance, Klarheit und Flexibilität als ältere Methoden wie .format() und %-Formatierung. 

Wenn du Best Practices befolgst, etwa benannte Platzhalter nutzt, Dezimalgenauigkeit steuerst, Text zur besseren Lesbarkeit ausrichtest und fehlende Dictionary-Keys elegant behandelst, schreibst du saubere, professionelle und wartbare String-Formatierungen in Python. 

Egal ob du formatierte Reports, mehrzeilige Nachrichten oder strukturierte Datenausgaben erzeugst: f-strings bieten einen einfachen und zugleich leistungsfähigen Weg, Variablen und Ausdrücke nahtlos zu integrieren. Mit f-strings verbesserst du nicht nur die Codequalität, sondern auch die Effizienz. 

Weitere Infos zur String-Interpolation in Python findest du in den DataCamp-Ressourcen:

• f-string Formatting in Python Tutorial
• Python Append String: 6 Essential Concatenation Techniques
• Python Programming Lernpfad
• Python Fundamentals Lernpfad
• Introduction to Data Science in Python Kurs