Python bietet exzellente Unterstützung für String-Operationen und Textverarbeitung. Die Sprache beinhaltet reichhaltige Optionen zur Formatierung und Ausgabe von Texten. Wir stellen die wichtigsten Methoden zur Python-String-Formatierung vor.

Günstige Webhosting-Pakete von IONOS!

Vertrauen Sie auf flexibel skalierbares und zuverlässiges Webhosting inklusive persönlichem Berater mit IONOS!

Kostenlose Domain
SSL Zertifikat
DDoS-Schutz

Wozu werden in Python die String-Format-Methoden verwendet?

Strings sind Zeichenketten und können in Python einzelne Buchstaben, Wörter, Sätze oder auch ganze Dokumente enthalten. In der Praxis benötigt man häufig Methoden zum Formatieren von Strings. Damit sind keinesfalls visuelle Auszeichnungen wie Fettdruck in Word gemeint. Worum also geht es?

Strings lassen sich aus mehreren Stücken zusammensetzen. In vielen Fällen möchte man statische String-Bestandteile und variable Daten vermischen. Benötigt wird dies bei der Ausgabe von Daten und dem Erzeugen von Dokumenten in der Webentwicklung.

Stellen wir uns beispielshalber einen Onlineshop vor. Wir möchten den Gesamtpreis der Produkte im Einkaufswagen berechnen und dem Nutzer bzw. der Nutzerin anzeigen: „Der Gesamtpreis beträgt […] Euro.“ Ein erster Lösungsansatz besteht darin, den String per Konkatenations-Operator zusammenzubauen:

price = 69.42
message = "The total price is" + price + "EUR"

Leider bekommen wir eine Fehlermeldung, denn der Preis ist eine Zahl und lässt sich nicht mit einem String konkatenieren. Wir müssen die Zahl zunächst mit der str()-Funktion in einen String konvertieren:

message = "The total price is" + str(price) + "EUR"

Das wird schnell unübersichtlich. Besser wäre es, den gesamten Text samt Platzhalter zu definieren und diesen mit Daten zu befüllen. Beim Umwandeln der Daten gilt es ggf., deren Formatierung anzupassen. Genau diese Anforderungen erfüllen die Python String-Format-Methoden.

Wie funktionieren die Python-String-Format-Methoden?

Python unterstützt mehrere String-Format-Methoden, jeweils mit eigenen Vor- und Nachteilen. Die Vielfalt ist historisch gewachsen, wodurch es zwischen den einzelnen Methoden viele Gemeinsamkeiten und einige Unterschiede gibt. Wir stellen die vier bekanntesten Ansätze zur Python-String-Formatierung vor:

  1. String-Formatierung mit dem Modulo-Operator
  2. String-Formatierung mit der str.format()-Methode
  3. String-Formatierung mit String-Interpolation
  4. String-Formatierung mit Template-Strings

Modulo-Operator

Diese älteste in Python eingebaute String-Formatierung nutzt den Python-Operator für Prozentzeichen, der sonst für die mathematische Modulo-Operation verwendet wird. Der Ansatz ist daher auch als Modulo-String-Formatierung bekannt.

Wir nutzen im Folgenden ein Schema mit drei Variablen. Die eigentlichen Namen spielen keine Rolle; wir haben diese so gewählt, damit der Code möglichst gut nachvollziehbar ist.

Komponente Bezeichnung
String-Vorlage mit Platzhalter(n) template
Modulo-Operator %
Einzufügende Daten data
Fertig formatierter String message

Zunächst definieren wir die Vorlage als String-Variable mit dem Namen template. Innerhalb der Vorlage legen wir die Position des Platzhalters mit dem Kürzel %s fest:

template = "The total price is %s"

Im Anschluss definieren wir den einzufügenden Wert als Variable mit Namen data:

data = 69.51

Um die Python-String-Formatierung durchzuführen, schreiben wir die String-Vorlage, gefolgt vom Modulo-Operator und schließlich der data-Variable. Den formatierten String weisen wir im selben Zuge der message-Variable zu:

message = template % data

Bei den Daten kann es sich um eine Variable handeln. Wir können aber genauso gut ein Literal oder einen Ausdruck verwenden. Die Modulo-Operation lässt sich auf einer einzigen Zeile unterbringen. Hier ein Beispiel mit einem String-Literal, das anstelle des Platzhalters eingefügt wird:

message = "Here comes %s" % "Jack"

Ein weiteres Beispiel: Wir berechnen die Summe von Einzelpreisen und fügen den Gesamtpreis in die Nachricht ein. Es kommt dasselbe Schema zum Tragen; dabei zeigen wir, dass nach dem Modulo-Operator ein Ausdruck folgen darf:

prices = (42, 69, 51)
message = "The total price is %s" % sum(prices)

Vielleicht fragen Sie sich an diesem Punkt, warum als Platzhalter %s verwendet wird und nicht einfach nur das Prozentzeichen an sich. In der Tat hat das „s“ eine besondere Bedeutung: Beim Einfügen der Daten werden diese mit der str()-Funktion in einen String umgewandelt.

Es gibt in Python weitere String-Formatierungs-Kürzel, die z. B. Zahlen speziell formatieren. Anschaulich darstellen lässt sich dies am Beispiel der Kreiszahl Pi. Wir füllen die Zahl dazu einmal in den schon bekannten Platzhalter %s ein. Die Ausgabe enthält 15 Nachkommastellen:

from math import pi as PI
print("The value of Pi is approximately %s" % PI)

Nutzen wir stattdessen das Kürzel %g als Platzhalter, werden lediglich fünf Nachkommastellen angezeigt:

print("The value of Pi is approximately %g" % PI)

Neben %s und %g existiert eine Reihe weiterer Optionen – siehe dazu den folgenden Abschnitt.

Es ist mit Pythons Modulo-String-Formatierung auch möglich, mehrere Platzhalter zu definieren und zu befüllen. In dem Fall erwartet der Modulo-Operator ein Tupel mit genauso vielen Werten, wie Platzhalter vorhanden sind. Die Platzhalter werden mit den Werten befüllt:

person = ('John', 42)
message = "My friend %s is %s years old" % person

Sie sehen schon, besonders lesbar ist die Python-String-Formatierung mit Modulo-Operator nicht. Etwas schöner wird es, wenn wir statt eines Tupels ein Dict mit den Daten übergeben. In diesem Fall tragen wie die Namen der Dict-Einträge zwischen Klammern hinter dem Prozentzeichen der Platzhalter ein. So wird beim Lesen der String-Vorlage ersichtlich, welche Werte zu erwarten sind:

person = {'name': 'John', 'age': 42}
message = "My friend %(name)s is %(age)s years old" % person

str.format()-Methode

Pythons String-Format-Methode ist eine Verbesserung der Modulo-Formatierung, die ursprünglich in Python 3 enthalten war und später nach Python 2.6 übertragen wurde. Statt eines speziellen Operators wird ein objektorientierter Ansatz angewandt. Damit ist str.format() konsistent mit anderen String-Methoden, etwa Pythons str.split-Funktion.

Das grundlegende Schema der Python str.format()-Methode ähnelt der Formatierung mit dem Modulo-Operator und existiert in ähnlicher Form auch in .NET und Rust. Als Platzhalter im Template-String kommen geschweifte Klammern zum Einsatz, die Daten werden als Argumente des Funktionsaufrufs übergeben:

template = "Here comes {}"
data = 'Jack'
message = template.format(data)

Enthält der Template-String mehrere Platzhalter, übergeben wir entsprechend viele Argumente:

message = "My friend {} is {} years old".format('John', 42)

Optional spezifizieren wir die Position der einzubindenden Argumente als Indizes. So lässt sich die Reihenfolge der Platzhalter von den Argumenten entkoppeln. Bedenken Sie dabei, dass Indizes bei null beginnen:

message = "My friend {1} is {0} years old".format(69, 'Jim')

Sofern die einzelnen Werte in einer Datenstruktur vorliegen, nutzen wir den Sternchen-Operator vor dem Argument, um die Datenstruktur zu entpacken. Das funktioniert mit Listen und Tupeln:

person = ('John', 42)
message = "My friend {} is {} years old".format(*person)

Bei längeren Strings werden die nichtssagenden Platzhalter schnell verwirrend. Schöner ist es, benannte Argumente zu benutzen:

template = "My friend {name} is {age} years old"
message = template.format(name = 'Jack', age = 51)

Bei vielen Werten würde die Argumentliste sehr lang und damit unübersichtlich. Dann ist es besser, die Werte in einem Dict zusammenzufassen und das Dict beim Funktionsaufruf zu entpacken. Anders als bei Listen und Tupeln nutzen wir zum Entpacken eines Dicts ein Doppelsternchen:

# define dict
person = {'name': 'Jim', 'age': 69}
# define string with placeholders
template = "My friend {name} is {age} years old"
# unpack dict in `format()` call
message = template.format(**person)

Besonders an der Python-String-Formatierung mit str.format() sind die vielfältigen Formatierungsoptionen. Sie erweitern den Funktionsumfang der Modulo-Formatierung und sind besonders mächtig für die Ausgabe von Text auf der Kommandozeile sowie für tabellarische Daten. Im Folgenden stellen wir den Mechanismen zum Formatieren von Zahlen vor.

Python bietet präzise Kontrolle bei der Ausgabe von Zahlen als Text. So lässt sich festlegen, wie die Vorzeichen von Zahlen angezeigt werden sollen. Für Dezimalzahlen lässt sich ferner die Anzahl an Nachkommastellen bestimmen. Nützlich ist das bei der tabellarischen Darstellung positiver oder negativer Zahlen.

Stellen wir uns vor, wir wollen Temperaturmessungen ausgeben:

samples = [('A0147D', 27.6), ('X1489M', -4.7), ('P9921U', -10.93)]
for sample in samples:
    print('| {} | {} |'.format(*sample))

Die Ausgabe erscheint zerhackt, da die Zahlen unterschiedlich lang sind:

| A0147D | 27.6 |
| X1489M | -4.7 |
| P9921U | -10.93 |

Wir passen den Code an und definieren eine Reihe von Formatierungs-Optionen:

for sample in samples:
    print('| {} | {: 6.2f} |'.format(*sample))

Jetzt passt die Ausgabe:

| A0147D | 27.60 |
| X1489M | -4.70 |
| P9921U | -10.93 |

Schauen wir uns die Formatierungs-Optionen des zweiten Platzhalters genauer an. Diese folgen nach dem Doppelpunkt und umfassen vier Komponenten:

  1. Leerzeichen: stellt positiven Zahlen ein Leerzeichen voran, um den vom Minuszeichen negativer Zahlen eingenommenen Platz auszugleichen
  2. Zahl vor dem Punkt: Anzahl der insgesamt für die Zahl zur Verfügung stehenden Buchstaben
  3. Zahl nach dem Punk: Anzahl der Nachkommastellen; füllt ggf. mit Nullen auf
  4. Buchstabe „f“ vor der schließenden geschweiften Klammer: formatiert die Zahl als Dezimalzahl

Es gibt eine Reihe weiterer Formatierungs-Optionen, mit denen sich die Ausgabe von Zahlen und Strings präzise steuern lässt. Im täglichen Gebrauch ist der Einsatz eher selten; bei Bedarf schaut man in der offiziellen Python String Formatierungs-Dokumentation nach.

String-Interpolation

Seit Python 3.6 ist die String-Interpolation als weitere Formatierungs-Methode verfügbar. Der auch als „f-Strings“ bekannte Ansatz ist für viele Anwendungsfälle am komfortabelsten und am performantesten. Der Name entstammt der generellen Syntax; f-Strings beginnen mit dem Buchstaben „f“ direkt vor den öffnenden Anführungszeichen.

Als Platzhalter kommen geschweifte Klammern zum Einsatz. Anders als bei den bisher vorgestellten Methoden enthalten die Platzhalter keinen Index oder Namen, sondern einen beliebigen Ausdruck. Beim Definieren des f-Strings werden die Platzhalter sofort befüllt:

message = f"40 + 2 equals {40 + 2}"

Der Ausdruck kann auch der Name einer Variable sein:

name = 'Jack'
message = f"Here comes {name}"

Es lassen sich problemlos mehrere Ausdrücke einbinden:

prices = (42, 69, 51)
currency = 'EUR'
message = f"The total price is {sum(prices)} {currency}"

Template-Strings

Neben den drei vorgestellten Methoden unterstützt Python die String-Formatierung mit sogenannten Template-Strings. Diese werden aus einer eigenen Klasse erzeugt und bieten Schutz vor Sicherheitslücken beim Formatieren von Strings, die vom Nutzer bzw. von der Nutzerin stammen.

Die Formatierungsmöglichkeiten innerhalb von Template-Strings sind begrenzt. So dürfen die Platzhalter anstelle beliebiger Ausdrücke lediglich Variablennamen enthalten. Aufgrund ihrer Einfachheit sind Template-Strings gut geeignet zur Internationalisierung von Strings, die in mehreren Sprachen vorliegen.

Als Platzhalter kommt ein Dollarzeichen, gefolgt vom Namen der einzusetzenden Variable, zum Einsatz. Damit ähneln Template-Strings der Syntax von Shell-Sprachen wie Bash oder Zsh. Das Einsetzen des Wertes erfolgt beim Aufruf der substitute()-Methode:

# import `Template` class from `string` module
from string import Template
# instantiate template
template = Template("Hey there, I'm $name")
# perform substitution
message = template.substitute(name = 'Jack')

Wie in Shell-Sprachen gibt es eine weitere Syntax für die Platzhalter. Dabei folgen dem Dollarzeichen geschweifte Klammen, die den Namen der Variable enthalten. So lassen sich Ersetzungen innerhalb eines Wortes vornehmen:

template = Template("Let's buy $amount ${fruit}s")
message = template.substitute(amount = 3, fruit = 'orange')

Welche Methode für das Python-String-Format sollte man wählen?

Die einzelnen Methoden haben spezifische Eigenheiten, die wir hier zusammenfassen:

Methode Schema Platzhalter Nutzen
Modulo-Formatierung template % data %, %(key) bei Python Version < 2.6
str.format() template.format(data) {}, {index}, {key} für komplexe Formatierungen
f-String f"{expression}" {expression} für umfangreiche Strings
Template-String template.substitute(data) ${identifier} wenn die Strings von Nutzerseite stammen
Page top