Python-String-Interpolation: Ein Anfängerleitfaden

Angenommen, Sie möchten den Namen einer Person und ihren Beruf ausgeben. Sie könnten ein einfaches Programm wie folgt schreiben.

# Definieren von Variablen
name = 'Mark'
profession = 'Astronaut'
age = 7


# Informationen ausgeben
output_string = ('My name is ' + name +
                ', I am ' + str(age) + ' years old ' +
                'and my profession is ' + profession + '.')
print(output_string)

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

Dieser Ansatz mangelt an Kürze und Lesbarkeit. Glücklicherweise bietet die Zeichenketteninterpolation eine bessere Lösung. Sie ermöglicht es, Variablen, Ausdrücke oder Funktionsergebnisse direkt in eine Zeichenkette einzufügen, wodurch die dynamische Zeichenkettenmanipulation ermöglicht wird und die Notwendigkeit für manuelle Konkatenation entfällt.

Unter Verwendung eines Ansatzes mit Zeichenketteninterpolation könnten wir den Code wie folgt umschreiben.

# Definieren von Variablen
name = 'Mark'
profession = 'Astronaut'
age = 7


# Informationen ausgeben
output_string = f'My name is {name}, I am {age} years old and my profession is {profession}.'
print(output_string)

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

Die Version mit Zeichenketteninterpolation ermöglicht es, Ausdrücke direkt innerhalb der Zeichenkette einzubetten, ohne aufwendige Konkatenationen verwenden zu müssen. Wie Sie sehen können, ist dies ein viel saubererer Ansatz.

Grundlegende Zeichenketteninterpolation in Python

Es gibt verschiedene Techniken der Zeichenketteninterpolation in Python. Die am häufigsten empfohlene Methode sind formatierte Zeichenkettenliterale, auch bekannt als f-strings, die seit Python 3.6 verfügbar sind.

Eine weitere Methode, die häufig in Code vor Python 3.6 zu sehen ist, ist die .format() Methode. Obwohl diese Methode ausführlicher ist als f-strings, hat sie gelegentlich Vorteile (Details unten).

Schließlich können Sie %-Stil-Formatierungen in Legacy-Code antreffen.

Die Verwendung von f-strings (Python 3.6+)

f-strings (formatierte Zeichenfolgenliterale) sind eine leistungsstarke und prägnante Möglichkeit, Zeichenfolgen in Python zu formatieren. Sie wurden in Python 3.6 eingeführt und bieten eine lesbare und effiziente Möglichkeit, Variablen, Ausdrücke und Funktionsaufrufe direkt in Zeichenfolgen einzufügen.

Ein einfaches Beispiel für die grundlegende Syntax eines f-Strings ist wie folgt.

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

   My name is Mark.

In diesem Code wird die output_string Variable einem f-String zugewiesen. Das f Präfix vor dem öffnenden Anführungszeichen weist darauf hin, dass der String eingebettete Ausdrücke unterstützt. Die Variable name wird ausgewertet und ihr Wert wird in den String eingefügt, was zu folgendem Output führt: "Mein Name ist Mark."

Nicht nur Variablenwerte, sondern auch Berechnungen oder Ausdrücke können in f-Strings eingefügt werden. Betrachten Sie dieses Beispiel.

import math


a = 3.0
b = 4.0


# Verwenden Sie String-Interpolation für die Formel
print(f'The hypotenuse of a triangle with base {a} and side {b} is {math.sqrt(a ** 2 + b ** 2)}.')

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

Der Ausdruck math.sqrt(a ** 2 + b ** 2) wird direkt innerhalb des Strings ausgewertet, was die Notwendigkeit beseitigt, den Wert separat zu berechnen, bevor er in den String eingefügt wird.

Verwendung der .format() Methode

Wie bei f-Strings ermöglicht die .format() Methode das Einfügen von Variablen und Ausdrücken in einen String. Die grundlegende Syntax der .format() Methode lautet wie folgt.

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

   My name is Mark.

Die geschweiften Klammern {} dienen als Platzhalter, die signalisieren, dass der Wert einer Variablen an dieser Stelle in den String eingefügt wird. Der spezifische Wert der Variablen, der in den Platzhalter eingefügt wird, wird durch das Argument bestimmt, das an die .format() Methode übergeben wird.

Positionsargumente

Was passiert, wenn Sie mehrere Platzhalter für mehrere Variablen benötigen? Betrachten Sie den folgenden Code.

name = 'Mark'
age = 7


# Die Platzhalter werden in der Reihenfolge der Argumente ausgefüllt
output_string = 'My name is {} and I am {} years old.'.format(name, age)


print(output_string)

   My name is Mark and I am 7 years old.

In diesem Beispiel werden zwei Variablen, name und age, benötigt. Folglich enthält der String zwei Platzhalter, und die Variablen werden in der gleichen Reihenfolge eingefügt, in der sie im .format() -Methode erscheinen. Diese Argumente werden als *positionale* Argumente bezeichnet, da ihre Platzierung im String durch ihre Position in der Argumentliste der Methode bestimmt wird.

Indexierte und benannte Platzhalter

Als Variation der Platzhalter-Idee betrachten Sie dieses Beispiel.

name = 'Mark'
age = 7


# Geben Sie das Alter zweimal aus
output_string = 'My name is {} and I am {} years old. My twin brother is also {} years old.'.format(name, age, age)
print(output_string)

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

Hier haben wir den Wert der Variablen age zweimal wiederverwendet. Mehrfaches Einbinden derselben Variable auf diese Weise ist umständlich und beeinträchtigt die Lesbarkeit. Gibt es eine Möglichkeit, eine Variable in einem mit der .format() Methode formatierten String ohne Wiederholung wiederzuverwenden? Ja, das gibt es, und zwar durch Verwendung sogenannter *indizierter Platzhalter*.

name = 'Mark'
age = 7


# Verwenden von indizierten Platzhaltern
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)

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

In diesem Beispiel haben wir die Reihenfolge der Variablen innerhalb der geschweiften Klammern explizit definiert, indem wir dem nullbasierten Indexierungsschema von Python gefolgt sind. Zusätzlich haben wir die Variable am Index 1 wiederverwendet, anstatt sie zu wiederholen.

Als Alternative zur positionsbasierten Indizierung können Sie auch benannte Argumente verwenden, wobei jedem Argument ein Name zugewiesen wird.

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

   My name is Mark and I am 7 years old.

Das benannte Argument wird innerhalb der geschweiften Klammern ausgewertet, die seinen Namen angeben. Dadurch wird der {name} Platzhalter durch den Wert "Mark" ersetzt, und der {age} Platzhalter wird durch 30 ersetzt.

Verwendung des % Operators

Die letzte Methode für Zeichenketteninterpolation ist der % Operator. Es funktioniert ähnlich wie der printf() Befehl in C. Seine Verwendung ist veraltet und wird dringend zugunsten von f-Strings oder der .format() Methode abgeraten. Es wird hier erwähnt, weil Sie möglicherweise in Legacy-Codebasen darauf stoßen.

Das grundlegende Format für den % Operator ist: "Format-String" % Werte. Der Format-String enthält Platzhalter, wie %s für Zeichenfolgen, die durch Werte ersetzt werden. Zum Beispiel druckt das folgende Beispiel „Hallo, Mark.“

'Hello %s' % 'Mark'

   'Hello Mark'

Andere gängige Formatbezeichner sind in der folgenden Tabelle aufgeführt.

Der % Operator hat viele Einschränkungen. Zum einen ist er weniger lesbar als f-Strings. Betrachten Sie den folgenden Code.

name = "Alice"
age = 30
height = 5.6


# Der % Operator ist schwer zu überblicken
message = "My name is %s, I am %d years old, and my height is %.1f feet." % (name, age, height)
print(message)

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

Ist dieser Code auf den ersten Blick klar? Wahrscheinlich nicht. Es gibt viel visuelles Hin- und Herspringen zwischen dem Platzhalter und den Variablen, die die Lücken ausfüllen. Es ist einfach, sich bei all dem Hin- und Hersuchen zu verwirren (oder schwindelig zu werden).

Jetzt betrachten Sie äquivalenten Code unter Verwendung von f-Strings.

# Dies ist viel sauberer
message = f"My name is {name}, I am {age} years old, and my height is {height:.1f} feet."
print(message)

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

Kein Hin- und Hersuchen und keine obskuren Formatierungszeichenfolgen sind erforderlich. Der Code ist sauber, leicht zu verstehen und einfach zu schreiben. Sie können weitere Tipps zum Schreiben von klarem, optimierten Code mit dem Python-Programmierkurs von DataCamp erlernen. . 

Fortgeschrittene Python-String-Interpolations-Techniken

Nachdem wir die Grundlagen der Python-String-Interpolation verstanden haben, werfen wir einen Blick auf einige fortgeschrittenere Anwendungen. 

Python-Mehrzeilen-String-Interpolation

F-Strings können auch für mehrzeilige Inhalte verwendet werden, indem der f-Signifikator mit dreifachen Anführungszeichen (entweder einfach oder doppelt) verwendet wird. Der Text kann über mehrere Zeilen geschrieben werden und erscheint im Ausgabebereich genau wie formatiert.

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


# Dies ist ein Beispiel für einen mehrzeiligen String
bio = f"""
Name: {name}
Profession: {profession}
Age: {age}
"""
print(bio)

   Name: Mark

   Profession: Astronaut

   Age: 7

Mehrzeilige Zeichenfolgen können auch mit der Methode .format() erstellt werden.

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


# Dies ist eine mehrzeilige Zeichenfolge mit .format()
bio = """
Name: {}
Profession: {}
Age: {}
""".format(name, profession, age)
print(bio)

   Name: Mark

   Profession: Astronaut

   Age: 7

Verwendungszwecke für mehrzeilige Zeichenfolgen-Interpolation

Warum möchten Sie mehrzeilige Zeichenfolgen-Interpolation verwenden? Es gibt viele Verwendungen für mehrzeilige Zeichenfolgen-Interpolation. Hier sind einige Anwendungsfälle:

• Generierung von mehrzeiligen E-Mails oder Nachrichten
• Protokollierung und Debugging
• Generierung von SQL-Abfragen dynamisch

Generierung von mehrzeiligen E-Mails oder Nachrichten

Angenommen, Sie senden einen Formbrief an viele Teilnehmer einer Technologiekonferenz.

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)

   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 Team

Mit f-Strings ist die Erstellung eines Formbriefs einfach und effizient. Um den Namen, das Ereignis oder das Datum zu ändern, ändern Sie sie einfach in den Variablen, und die Zeichenfolge ändert sich automatisch.

Protokollierung und Debugging

Mehrzeilige Zeichenfolgen sind nützlich, um Fehlermeldungen für Protokolle 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)

   [ERROR 404]

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

   URL: /missing-page

 

   The requested page could not be found.

Diese Methode hält Protokollmeldungen strukturiert und erleichtert das Debuggen mit ordnungsgemäß formatierten Protokollen.

Generierung von SQL-Abfragen dynamisch

SQL-Abfragen können dynamisch mithilfe von mehrzeiligen Zeichenfolgen erstellt werden.

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


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


print(query)

   SELECT *

   FROM users

   WHERE email = '[email protected]';

Diese Methode macht SQL-Abfragen lesbar und hält die Einrückung bei. Darüber hinaus entfällt die Notwendigkeit, + für die Zeichenfolgenverkettung zu verwenden.

Weitere Anwendungsfälle sind:

• Formatierte Verträge schreiben
• Markdown oder $\LaTeX$-Dokumente erstellen
• Mehrzeilige HTML/XML-Vorlagen
• Generieren von API-Antworten oder JSON-ähnlichem Text

Vorteile der mehrzeiligen Zeichenketteninterpolation

Wie wir sehen können, gibt es mehrere Vorteile der mehrzeiligen Zeichenketteninterpolation.

• Die Zeichenketteninterpolation erhält die Formatierung, ohne dass das Escape-Zeichen \n benötigt wird.
• Die Zeichenketteninterpolation verbessert die Lesbarkeit im Vergleich zur Einzelzeilenformatierung.
• Die Zeichenketteninterpolation reduziert das Durcheinander beim Arbeiten mit strukturiertem Text (z.B. Protokollen, Abfragen, Berichten).
• String-Interpolation ermöglicht die dynamische Textgenerierung, ohne die Einrückung zu brechen.

Formatierung von Zahlen und speziellen Werten

Um die Anzahl der angezeigten Dezimalstellen mit einem f-String zu steuern, verwenden Sie die Syntax: f'{value:.nf}', wobei value die Fließkommazahl ist, n die Anzahl der Dezimalstellen ist und f (das nach dem .) für die Fließkommaformatierung steht.

Um dies zu veranschaulichen, gibt der folgende Code $\pi$ auf unterschiedlichen Dezimalstellen 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}')

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

Die Formatierung mit der .format() Methode ist ä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))

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

Sie können eine f-Zeichenkette verwenden, um Prozentsätze zu formatieren, indem Sie die :.nf Syntax kombiniert mit %, wobei n die Anzahl der Dezimalstellen ist.

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

   Success rate: 87.50%

Sie können ein f-String verwenden, um Währungen zu formatieren, indem Sie :, für Tausendertrennzeichen und .nf zur Steuerung der Dezimalstellen verwenden. Sie können auch ein Währungssymbol wie $, €, oder £ direkt in den String einfügen.

amount = 98765.4321


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

   USD: $98,765.43

   EUR: €98,765.43

   GBP: £98,765.43

Verwendung von f-Strings mit Dictionaries und Listen

Um f-Strings mit einem Dictionary in Python zu verwenden, greifen Sie innerhalb der geschweiften Klammern auf die Dictionary-Werte zu, indem Sie die eckige Klammernotation (dict[‚key‘]) verwenden oder das Dictionary mit ** entpacken.

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']}.")

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

Anstatt jeden Schlüssel manuell abzurufen, können Sie das Dictionary in einen f-String wie folgt entpacken.

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


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

   My name is Alice and I am 7 years old.

Um einen Fehler aufgrund fehlender Schlüssel zu vermeiden, verwenden Sie get() für den Zugriff auf das Dictionary.

person = {"name": "Alice"}


# Fehler: Schlüssel 'city' fehlt
print(f"City: {person['city']}") 

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




   KeyError                                  Traceback (most recent call last)




   Cell In[87], line 4

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

         3 # Fehler: Schlüssel 'city' fehlt

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







   KeyError: 'city'

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

   City: Not specified

Vor- und Nachteile von Methoden zur String-Interpolation

Wie wir gesehen haben, sind f-strings und die .format() Methode beide nützliche Methoden für die String-Interpolation. Lassen Sie uns einen Vergleich der Vor- und Nachteile jeder Methode betrachten.

Wann sollten Sie .format() anstelle von f-Strings verwenden?

Übliche Fallstricke und bewährte Verfahren

Hier finden Sie einige Problembehandlungsmethoden und Top-Tipps für die Verwendung der Python-String-Interpolation.

Vermeidung von Syntaxfehlern mit geschweiften Klammern

Es gibt viele Syntaxfehler, die man machen kann, wenn man String-Interpolation mit geschweiften Klammern verwendet.

• Stelle sicher, dass jede { eine passende } hat.

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

     Cell In[96], line 1

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

Zum Glück ist der Fehler einfach zu erkennen und zu beheben.

• Verwende {{ und }} um die wörtlichen {} anzuzeigen.

Was passiert, wenn du geschweifte Klammern innerhalb eines interpolierten Strings drucken möchtest? Alles innerhalb der geschweiften Klammern wird (versucht zu) ausgewertet.

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

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

   NameError                                 Traceback (most recent call last)

   Cell In[101], line 1

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

   NameError: name 'c' is not defined

Python interpretiert a, b, c innerhalb der geschweiften Klammern als ein Tupel und versucht, einen Wert zu finden, der mit a verbunden ist. Da eine solche Variable nicht existiert, wird ein KeyError ausgelöst. Die Lösung besteht darin, doppelte geschweifte Klammern {{}} zu verwenden.

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

   Mengennotation: {{a, b, c}}

Leistungsvergleich: f-strings vs .format()

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

import timeit


name = "Alice"
age = 30
pi = 3.1415926535


# F-String-Leistung messen
f_string_time = timeit.timeit('f"My name is {name} and I am {age} years old."', globals=globals(), number=1000000)


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


# F-String-Leistung mit Ausdrücken messen
f_string_expr_time = timeit.timeit('f"Pi rounded to 2 decimal places: {pi:.2f}"', globals=globals(), number=1000000)


# .format()-Leistung mit Ausdrücken messen
format_expr_time = timeit.timeit('"Pi rounded to 2 decimal places: {:.2f}".format(pi)', globals=globals(), number=1000000)


# Ergebnisse drucken
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")

   f-string (simple): 0.080447 seconds

   .format() (simple): 0.129860 seconds

   f-string (with expression): 0.123171 seconds

   .format() (with expression): 0.146242 seconds

Wie Sie sehen können, sollte man aus Effizienzsicht F-Strings .format() bevorzugen.

Best Practices für eine saubere und lesbare String-Interpolation

Um sicherzustellen, dass Ihre String-Formatierung klar, effizient und wartbar ist, befolgen Sie diese Best Practices, wenn Sie interpolierte Strings verwenden.

• Bevorzugen Sie F-Strings für Lesbarkeit (Python 3.6+)

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


# Nicht empfohlen (weniger lesbar)
print("My name is {} and I am {} years old.".format(name, age))


# Vermeiden Sie die Verwendung von % Formatierung (veraltet)
print("My name is %s and I am %d years old." % (name, age))

   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.

• Verwenden Sie benannte Platzhalter für Klarheit

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


# Verwendung von Indizes in .format() (nicht so lesbar)
print("My name is {0} and I am {1} years old.".format("Alice", 30))

   My name is Alice and I am 30 years old.

   My name is Alice and I am 30 years old.

• Halte mehrzeilige Strings 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)

   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  

• Verwende f-Strings im Logging für besseres Debugging

Python 3.8 und später unterstützt = zum Debuggen in f-Strings.

value = 42


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

   value = 42

Fazit

String-Interpolation ist ein leistungsstarkes Feature in Python, das die String-Formatierung sauberer, lesbarer und effizienter macht. Unter den verfügbaren Methoden sind f-Strings der modernste und empfohlene Ansatz, der eine bessere Leistung, Klarheit und Flexibilität im Vergleich zu älteren Methoden wie .format() und % Formatierung bietet. 

Indem Sie bewährte Verfahren befolgen, wie z. B. die Verwendung benannter Platzhalter, die Steuerung der Dezimalgenauigkeit, die Ausrichtung von Text für bessere Lesbarkeit und das elegante Umgang mit fehlenden Wörterbuchschlüsseln, können Sie sauberes, professionelles und wartbares Zeichenkettenformatieren in Python schreiben.

Ob Sie formatierte Berichte, mehrzeilige Nachrichten oder strukturierte Datenausgaben generieren, f-Strings bieten einen einfachen, aber leistungsstarken Weg, um Variablen und Ausdrücke nahtlos zu integrieren. Die Verwendung von f-Strings wird nicht nur die Qualität Ihres Codes verbessern, sondern auch seine Effizienz steigern.

Weitere Informationen zur Python-Zeichenketteninterpolation finden Sie in den Ressourcen von DataCamp:

• f-String-Formatierung in Python Tutorial
• Python String Anhängen: 6 Wesentliche Verknüpfungstechniken
• Python-Programmierung Skill-Track
• Python-Grundlagen Skill-Track
• Einführung in Data Science in Python Kurs