6. Praktische Arbeit mit Zeichenketten

In Kapitel 5 haben Sie die Grundlagen der Arbeit mit Zeichenketten (Strings) gelernt: wie man sie erstellt, über Indizierung und Slicing auf Zeichen zugreift und grundlegende String-Methoden verwendet. Jetzt bauen wir auf diesem Fundament auf und erkunden fortgeschrittenere String-Operationen, die Sie in echten Python-Programmen ständig verwenden werden.

Dieses Kapitel konzentriert sich auf praktische Techniken zur String-Manipulation, die alltägliche Programmierprobleme lösen: Text zerlegen und wieder zusammensetzen, formatierten Output erzeugen, der professionell aussieht. Diese Fähigkeiten sind unerlässlich, egal ob Sie Benutzereingaben verarbeiten, Berichte erzeugen, Datendateien einlesen oder irgendein Programm bauen, das mit Text arbeitet.

6.1) Zeichenketten zerlegen und zusammenfügen

Eine der häufigsten Aufgaben in der Textverarbeitung ist es, eine Zeichenkette in kleinere Teile zu zerlegen oder mehrere Teile zu einer einzigen Zeichenkette zu kombinieren. Python stellt für beide Operationen leistungsfähige Methoden bereit.

6.1.1) Zeichenketten mit split() zerlegen

Die Methode split() zerlegt eine Zeichenkette in eine Liste kleinerer Zeichenketten anhand eines Trennzeichens (auch Separator oder Delimiter genannt). Das ist unglaublich nützlich für die Verarbeitung von strukturiertem Text wie CSV-Daten, Benutzereingaben mit mehreren Werten oder Sätzen, die in Wörter zerlegt werden sollen.

Einfaches Zerlegen nach Leerraum:

Wenn Sie split() ohne Argumente aufrufen, wird nach beliebigem Leerraum (Spaces, Tabs, Newlines) getrennt und leere Zeichenketten werden automatisch aus dem Ergebnis entfernt:

python

# split_basic.py
sentence = "Python is a powerful programming language"
words = sentence.split()
print(words)  # Output: ['Python', 'is', 'a', 'powerful', 'programming', 'language']
print(len(words))  # Output: 6

Beachten Sie, wie split() mit mehreren Spaces intelligent umgeht:

python

# split_whitespace.py
messy_text = "Python    is     awesome"
words = messy_text.split()
print(words)  # Output: ['Python', 'is', 'awesome']

Auch wenn mehrere Spaces zwischen den Wörtern stehen, behandelt split() jede Menge Leerraum als ein einzelnes Trennzeichen und erzeugt eine saubere Liste.

Zerlegen mit einem bestimmten Trennzeichen:

Sie können genau angeben, nach welchem Zeichen oder welcher Zeichenkette getrennt werden soll, indem Sie sie als Argument übergeben:

python

# split_separator.py
csv_data = "apple,banana,cherry,date"
fruits = csv_data.split(',')
print(fruits)  # Output: ['apple', 'banana', 'cherry', 'date']
 
date_string = "2024-03-15"
parts = date_string.split('-')
print(parts)  # Output: ['2024', '03', '15']
year = parts[0]
month = parts[1]
day = parts[2]
print(f"Year: {year}, Month: {month}, Day: {day}")  # Output: Year: 2024, Month: 03, Day: 15

Wichtiger Unterschied: Wenn Sie ein Trennzeichen angeben, behandelt split() dieses buchstäblich und erstellt leere Zeichenketten, wenn das Trennzeichen direkt hintereinander vorkommt:

python

# split_empty_strings.py
data = "apple,,cherry"
result = data.split(',')
print(result)  # Output: ['apple', '', 'cherry']
print(len(result))  # Output: 3

Die leere Zeichenkette '' in der Mitte repräsentiert das „Nichts“ zwischen den zwei aufeinanderfolgenden Kommata. Dieses Verhalten unterscheidet sich vom Zerlegen nach Leerraum ohne Argumente.

Die Anzahl der Splits begrenzen:

Sie können steuern, wie viele Splits durchgeführt werden, indem Sie ein zweites Argument (maxsplit) übergeben:

python

# split_maxsplit.py
text = "one:two:three:four:five"
parts = text.split(':', 2)  # Nur an den ersten 2 Doppelpunkten trennen
print(parts)  # Output: ['one', 'two', 'three:four:five']

Dadurch entstehen höchstens 3 Teile (maxsplit + 1), weil das Zerlegen nach der angegebenen Anzahl von Splits stoppt. Der Rest der Zeichenkette bleibt intakt.

Praktisches Beispiel: Benutzereingaben verarbeiten

python

# process_input.py
user_input = input("Enter your full name: ")
# User enters: "Alice Marie Johnson"
 
name_parts = user_input.split()
if len(name_parts) >= 2:
    first_name = name_parts[0]
    last_name = name_parts[-1]  # Letztes Element
    print(f"First name: {first_name}")  # Output: First name: Alice
    print(f"Last name: {last_name}")    # Output: Last name: Johnson
else:
    print("Please enter at least a first and last name")

6.1.2) Zeichenketten mit join() zusammenfügen

Die Methode join() ist das Gegenstück zu split(): Sie kombiniert eine Liste (oder jedes Iterable) von Zeichenketten zu einer einzigen Zeichenkette und fügt zwischen den Elementen ein Trennzeichen ein. Die Syntax wirkt anfangs vielleicht ungewohnt – die Trennzeichen-Zeichenkette ruft die Methode auf, und die Liste wird als Argument übergeben.

Einfaches Zusammenfügen:

python

# join_basic.py
words = ['Python', 'is', 'awesome']
sentence = ' '.join(words)
print(sentence)  # Output: Python is awesome
 
csv_line = ','.join(['apple', 'banana', 'cherry'])
print(csv_line)  # Output: apple,banana,cherry

Die Zeichenkette, die join() aufruft (wie ' ' oder ','), wird als Trennzeichen zwischen den Elementen verwendet.

Warum die Syntax separator.join(list) lautet:

Diese Syntax ergibt Sinn, wenn Sie sie aus Sicht des Trennzeichens betrachten: „Ich möchte diese Elemente zusammenfügen und mich selbst zwischen jedes Paar einfügen.“ Sie ermöglicht außerdem elegantes Chaining und macht das Trennzeichen im Code sehr sichtbar.

Zusammenfügen mit verschiedenen Trennzeichen:

python

# join_separators.py
items = ['eggs', 'milk', 'bread', 'butter']
 
# Durch Komma getrennt
print(', '.join(items))  # Output: eggs, milk, bread, butter
 
# Durch Newline getrennt (jedes Element in einer eigenen Zeile)
print('\n'.join(items))
# Output:
# eggs
# milk
# bread
# butter
 
# Durch Bindestrich getrennt
print('-'.join(items))  # Output: eggs-milk-bread-butter
 
# Ohne Trennzeichen (Konkatenation)
print(''.join(items))  # Output: eggsmilkbreadbutter

Wichtig: join() funktioniert nur mit Zeichenketten:

Alle Elemente im Iterable müssen Zeichenketten sein. Wenn Sie versuchen, Zahlen oder andere Typen zusammenzufügen, erhalten Sie einen Fehler:

python

# join_error.py
numbers = [1, 2, 3, 4]
# result = ','.join(numbers)  # This would cause: TypeError: sequence item 0: expected str instance, int found

Um Nicht-String-Elemente zu verbinden, müssen Sie sie zuerst in Zeichenketten konvertieren. Wir lernen in Kapitel 34 eine elegantere Methode dafür kennen, aber vorerst können Sie jedes Element manuell umwandeln:

python

# join_numbers.py
numbers = [1, 2, 3, 4]
# Jedes Element manuell in eine Zeichenkette umwandeln
string_numbers = [str(numbers[0]), str(numbers[1]), str(numbers[2]), str(numbers[3])]
result = ','.join(string_numbers)
print(result)  # Output: 1,2,3,4

Praktisches Beispiel: Dateipfade aufbauen

python

# build_path.py
path_parts = ['home', 'user', 'documents', 'report.txt']
# Auf Unix-ähnlichen Systemen (Linux, macOS)
unix_path = '/'.join(path_parts)
print(unix_path)  # Output: home/user/documents/report.txt
 
# Unter Windows
windows_path = '\\'.join(path_parts)
print(windows_path)  # Output: home\user\documents\report.txt

Hinweis: In Kapitel 26 lernen wir das Modul os.path kennen, das eine bessere plattformübergreifende Behandlung von Pfaden bietet, aber dieses Beispiel veranschaulicht das Konzept des Zusammenfügens.

6.1.3) split() und join() für Textverarbeitung kombinieren

Diese beiden Methoden arbeiten hervorragend zusammen, um Text zu transformieren. Durch ihre Kombination können Sie unordentliche Eingaben bereinigen, zwischen Formaten konvertieren oder Daten extrahieren und neu anordnen:

python

# transform_text.py
# Mehrere Leerzeichen durch einfache Leerzeichen ersetzen
messy = "Python    is     really    cool"
clean = ' '.join(messy.split())
print(clean)  # Output: Python is really cool
 
# Komma-getrennt in Space-getrennt umwandeln
csv_data = "apple,banana,cherry"
space_separated = ' '.join(csv_data.split(','))
print(space_separated)  # Output: apple banana cherry
 
# Alle Leerzeichen entfernen
text_with_spaces = "H e l l o"
no_spaces = ''.join(text_with_spaces.split())
print(no_spaces)  # Output: Hello

6.1.4) Weitere Methoden zum Zerlegen

Python stellt zusätzliche Methoden zum Zerlegen für spezielle Anwendungsfälle bereit:

rsplit() – von rechts aus zerlegen:

python

# rsplit_example.py
path = "folder/subfolder/file.txt"
 
# Normales split mit maxsplit
parts = path.split('/', 1)
print(parts)  # Output: ['folder', 'subfolder/file.txt']
 
# rsplit zerlegt von rechts
parts = path.rsplit('/', 1)
print(parts)  # Output: ['folder/subfolder', 'file.txt']

Das ist nützlich, wenn Sie den letzten Teil einer Zeichenkette vom Rest trennen möchten.

splitlines() – an Zeilenumbrüchen zerlegen:

python

# splitlines_example.py
multiline = "Line 1\nLine 2\nLine 3"
lines = multiline.splitlines()
print(lines)  # Output: ['Line 1', 'Line 2', 'Line 3']
 
# Funktioniert mit unterschiedlichen Zeilenendungen
mixed_lines = "Line 1\nLine 2\r\nLine 3\rLine 4"
all_lines = mixed_lines.splitlines()
print(all_lines)  # Output: ['Line 1', 'Line 2', 'Line 3', 'Line 4']

Die Methode splitlines() erkennt alle gängigen Zeilenumbruch-Konventionen (\n, \r\n, \r) und zerlegt entsprechend. Dadurch ist sie robuster als split('\n') für die Verarbeitung von Text aus verschiedenen Quellen.

6.2) Zeichenketten mit f-Strings formatieren

Formatierten Output zu erzeugen ist eine der häufigsten Aufgaben in der Programmierung. Sie müssen Text mit Variablenwerten kombinieren, Spalten ausrichten, Zahlen formatieren und gut lesbaren Output für Benutzer erzeugen. Pythons f-Strings (formatted string literals) bieten die modernste, lesbarste und mächtigste Möglichkeit dafür.

6.2.1) Grundsyntax von f-Strings

Ein f-String ist ein String-Literal mit vorangestelltem f oder F, das Ausdrücke in geschweiften Klammern {} enthalten kann. Python wertet diese Ausdrücke aus und konvertiert ihre Ergebnisse in Zeichenketten:

python

# fstring_basic.py
name = "Alice"
age = 30
greeting = f"Hello, {name}! You are {age} years old."
print(greeting)  # Output: Hello, Alice! You are 30 years old.

Die Ausdrücke innerhalb der {} können beliebige gültige Python-Ausdrücke sein:

python

# fstring_expressions.py
x = 10
y = 20
result = f"The sum of {x} and {y} is {x + y}"
print(result)  # Output: The sum of 10 and 20 is 30
 
price = 19.99
quantity = 3
total = f"Total cost: ${price * quantity}"
print(total)  # Output: Total cost: $59.97

6.2.2) Warum f-Strings besser sind als ältere Ansätze

Vor f-Strings (eingeführt in Python 3.6) nutzten Programmierer String-Konkatenation oder die Methode format(). Vergleichen wir das:

String-Konkatenation (die alte, fehleranfällige Methode):

python

# concatenation_example.py
name = "Bob"
age = 25
# Erfordert das Konvertieren von Zahlen in Strings und viele + Operatoren
message = "Hello, " + name + "! You are " + str(age) + " years old."
print(message)  # Output: Hello, Bob! You are 25 years old.

Dieser Ansatz ist umständlich, fehleranfällig (wenn man str() vergisst, entstehen Fehler) und bei vielen Variablen schwer zu lesen.

f-Strings (die moderne, saubere Methode):

python

# fstring_clean.py
name = "Bob"
age = 25
message = f"Hello, {name}! You are {age} years old."
print(message)  # Output: Hello, Bob! You are 25 years old.

F-Strings konvertieren Werte automatisch in Zeichenketten, sind besser lesbar und tatsächlich schneller als andere Ansätze.

6.2.3) Ausdrücke und Methodenaufrufe in f-Strings

Sie können komplexe Ausdrücke, Methodenaufrufe und sogar Funktionsaufrufe in f-Strings verwenden:

python

# fstring_methods.py
name = "alice"
print(f"Capitalized: {name.capitalize()}")  # Output: Capitalized: Alice
print(f"Uppercase: {name.upper()}")  # Output: Uppercase: ALICE
print(f"Length: {len(name)}")  # Output: Length: 5
 
# Arithmetik und Vergleiche
x = 10
print(f"Is {x} even? {x % 2 == 0}")  # Output: Is 10 even? True
 
# Indizierung und Slicing
text = "Python"
print(f"First letter: {text[0]}")  # Output: First letter: P
print(f"First three: {text[:3]}")  # Output: First three: Pyt

6.2.4) Zahlen in f-Strings formatieren

F-Strings unterstützen Format-Spezifizierer, die steuern, wie Werte dargestellt werden. Die Syntax lautet {expression:format_spec}:

Anzahl der Nachkommastellen für Gleitkommazahlen steuern:

python

# fstring_decimals.py
pi = 3.14159265359
 
print(f"Default: {pi}")  # Output: Default: 3.14159265359
print(f"2 decimals: {pi:.2f}")  # Output: 2 decimals: 3.14
print(f"4 decimals: {pi:.4f}")  # Output: 4 decimals: 3.1416
print(f"No decimals: {pi:.0f}")  # Output: No decimals: 3

Der Format-Spezifizierer .2f bedeutet „als Float mit 2 Nachkommastellen formatieren“. Das f steht für „Fixed-Point-Notation“.

Formatierung mit Tausendertrennzeichen:

python

# fstring_thousands.py
large_number = 1234567890
 
print(f"No separator: {large_number}")  # Output: No separator: 1234567890
print(f"With commas: {large_number:,}")  # Output: With commas: 1,234,567,890
print(f"With underscores: {large_number:_}")  # Output: With underscores: 1_234_567_890
 
# In Kombination mit Nachkommastellen
price = 1234567.89
print(f"Price: ${price:,.2f}")  # Output: Price: $1,234,567.89

Prozentformatierung:

python

# fstring_percentage.py
ratio = 0.847
print(f"Ratio: {ratio}")  # Output: Ratio: 0.847
print(f"Percentage: {ratio:.1%}")  # Output: Percentage: 84.7%
print(f"Percentage: {ratio:.2%}")  # Output: Percentage: 84.70%

Der Format-Spezifizierer % multipliziert mit 100 und fügt das Prozentzeichen hinzu.

6.2.5) Praktische Beispiele mit f-Strings

Formatierte Berichte erzeugen:

python

# report_example.py
product = "Laptop"
price = 899.99
quantity = 5
tax_rate = 0.08
 
subtotal = price * quantity
tax = subtotal * tax_rate
total = subtotal + tax
 
print(f"Product: {product}")  # Output: Product: Laptop
print(f"Price: ${price:.2f}")  # Output: Price: $899.99
print(f"Quantity: {quantity}")  # Output: Quantity: 5
print(f"Subtotal: ${subtotal:.2f}")  # Output: Subtotal: $4499.95
print(f"Tax (8%): ${tax:.2f}")  # Output: Tax (8%): $360.00
print(f"Total: ${total:.2f}")  # Output: Total: $4859.95

Benutzerfreundliche Meldungen erzeugen:

python

# user_messages.py
username = "Alice"
login_count = 42
last_login = "2024-03-15"
 
welcome = f"Welcome back, {username}!"
stats = f"You've logged in {login_count} times. Last login: {last_login}"
 
print(welcome)  # Output: Welcome back, Alice!
print(stats)  # Output: You've logged in 42 times. Last login: 2024-03-15

6.2.6) Debugging mit f-Strings

Python 3.8 hat den =-Spezifizierer für Debugging eingeführt, der sowohl den Ausdruck als auch seinen Wert anzeigt:

python

# fstring_debug.py
x = 10
y = 20
z = x + y
 
print(f"{x=}")  # Output: x=10
print(f"{y=}")  # Output: y=20
print(f"{z=}")  # Output: z=30
print(f"{x + y=}")  # Output: x + y=30

Das ist unglaublich nützlich, um während der Entwicklung Variablenwerte schnell zu überprüfen, ohne den Variablennamen doppelt tippen zu müssen.

6.2.7) Geschweifte Klammern in f-Strings maskieren

Wenn Sie wörtliche geschweifte Klammern in einem f-String benötigen, verdoppeln Sie sie:

python

# fstring_escape.py
value = 42
# Einzelne Klammern sind Platzhalter für Ausdrücke
print(f"Value: {value}")  # Output: Value: 42
 
# Doppelte Klammern erzeugen wörtliche Klammern
print(f"Use {{value}} as a placeholder")  # Output: Use {value} as a placeholder
print(f"The value is {value}, shown as {{value}}")  # Output: The value is 42, shown as {value}

6.3) Formatierung mit format() und Format-Spezifizierern

Auch wenn f-Strings der moderne bevorzugte Ansatz sind, wird die Methode format() immer noch häufig verwendet und bietet einige Fähigkeiten, die nützlich zu verstehen sind. Sie ist außerdem die Grundlage, auf der f-Strings aufbauen, daher hilft das Verständnis von format(), f-Strings besser zu verstehen.

6.3.1) Grundsyntax von format()

Die Methode format() verwendet geschweifte Klammern {} als Platzhalter in einer Zeichenkette, und die einzusetzenden Werte werden als Argumente übergeben:

python

# format_basic.py
template = "Hello, {}! You are {} years old."
message = template.format("Alice", 30)
print(message)  # Output: Hello, Alice! You are 30 years old.
 
# Mehrfache Verwendung von format()
greeting = "Hello, {}!".format("Bob")
print(greeting)  # Output: Hello, Bob!

6.3.2) Positions- und Schlüsselwortargumente

Sie können steuern, welches Argument an welche Stelle gesetzt wird, indem Sie Positionsnummern oder Namen verwenden:

Positionsargumente:

python

# format_positional.py
# Standardreihenfolge (0, 1, 2, ...)
template = "{} + {} = {}"
result = template.format(5, 3, 8)
print(result)  # Output: 5 + 3 = 8
 
# Explizite Positionen
template = "{0} + {1} = {2}"
result = template.format(5, 3, 8)
print(result)  # Output: 5 + 3 = 8
 
# Umordnen und Wiederverwenden
template = "{2} = {0} + {1}"
result = template.format(5, 3, 8)
print(result)  # Output: 8 = 5 + 3
 
# Den gleichen Wert wiederverwenden
template = "{0} times {0} equals {1}"
result = template.format(7, 49)
print(result)  # Output: 7 times 7 equals 49

Schlüsselwortargumente:

python

# format_keyword.py
template = "Hello, {name}! You are {age} years old."
message = template.format(name="Alice", age=30)
print(message)  # Output: Hello, Alice! You are 30 years old.
 
# Kann mit Positionsargumenten gemischt werden (Positionsargumente müssen zuerst kommen)
template = "{0}, your score is {score} out of {1}"
result = template.format("Alice", 100, score=95)
print(result)  # Output: Alice, your score is 95 out of 100

6.3.3) Format-Spezifizierer mit format()

Format-Spezifizierer funktionieren in format() genauso wie in f-Strings, mit : als Trenner:

python

# format_specifiers.py
pi = 3.14159265359
 
print("{:.2f}".format(pi))  # Output: 3.14
print("{:.4f}".format(pi))  # Output: 3.1416
 
# Mit Namen
print("{value:.2f}".format(value=pi))  # Output: 3.14
 
# Mehrere Werte mit unterschiedlichen Formaten
template = "{name}'s score is {score:.1f}%"
result = template.format(name="Bob", score=87.654)
print(result)  # Output: Bob's score is 87.7%

6.3.4) Wann man format() statt f-Strings verwenden sollte

F-Strings sind im Allgemeinen vorzuziehen, aber format() ist in bestimmten Situationen nützlich:

1. Vorlagen-Strings, die getrennt von den Daten definiert sind:

python

# format_templates.py
# Vorlage einmal definieren und mehrfach mit unterschiedlichen Daten verwenden
email_template = "Dear {name},\n\nYour order #{order_id} has shipped.\n\nThank you!"
 
# Die Vorlage mit unterschiedlichen Kunden verwenden
message1 = email_template.format(name="Alice", order_id=12345)
message2 = email_template.format(name="Bob", order_id=12346)
 
print(message1)
# Output:
# Dear Alice,
#
# Your order #12345 has shipped.
#
# Thank you!
 
print(message2)
# Output:
# Dear Bob,
#
# Your order #12346 has shipped.
#
# Thank you!

2. Wenn die Vorlage aus externen Quellen stammt:

python

# format_external.py
# Die Vorlage könnte aus einer Konfigurationsdatei oder Datenbank stammen
# (Wir lernen in Kapitel 24, wie man Dateien liest)
user_template = input("Enter message template: ")
# User enters: "Hello, {name}! Welcome to {place}."
 
message = user_template.format(name="Charlie", place="Python")
print(message)  # Output: Hello, Charlie! Welcome to Python.

Bei f-Strings muss die Vorlage in Ihrem Code stehen, weil Ausdrücke sofort ausgewertet werden. Mit format() kann die Vorlage jede beliebige Zeichenkette sein, die von irgendwoher kommt.

6.3.5) Auf Objektattribute und Dictionary-Keys zugreifen

Die Methode format() kann direkt auf Attribute und Dictionary-Keys zugreifen:

python

# format_access.py
# Dictionary-Zugriff
person = {"name": "Alice", "age": 30, "city": "Boston"}
message = "Name: {0[name]}, Age: {0[age]}, City: {0[city]}".format(person)
print(message)  # Output: Name: Alice, Age: 30, City: Boston
 
# Mit Schlüsselwortargument
message = "{p[name]} is {p[age]} years old".format(p=person)
print(message)  # Output: Alice is 30 years old

Hinweis: Wir lernen Objektattribute in Kapitel 30 kennen, aber dieses Beispiel zeigt, dass format() auf verschachtelte Datenstrukturen zugreifen kann.

6.4) Zahlen im formatierten Output ausrichten und runden

Professionell aussehender Output erfordert oft eine sorgfältige Ausrichtung und Zahlenformatierung. Sowohl f-Strings als auch format() bieten leistungsfähige Werkzeuge, um gut formatierte Tabellen, Berichte und Anzeigen zu erzeugen.

6.4.1) Textausrichtung

Sie können Breite und Ausrichtung von Werten mit Hilfe von Format-Spezifizierern steuern:

python

# alignment_basic.py
# Syntax: {value:width}
# Standard ist linksbündig für Strings, rechtsbündig für Zahlen
 
name = "Alice"
print(f"|{name}|")      # Output: |Alice|
print(f"|{name:10}|")   # Output: |Alice     |  (linksbündig, Breite 10)
print(f"|{name:>10}|")  # Output: |     Alice|  (rechtsbündig)
print(f"|{name:^10}|")  # Output: |  Alice   |  (zentriert)

Die Ausrichtungs-Spezifizierer sind:

< : linksbündig (Standard für Strings)
> : rechtsbündig (Standard für Zahlen)
^ : zentriert

Ausrichtung mit Zahlen:

python

# alignment_numbers.py
value = 42
print(f"|{value}|")      # Output: |42|
print(f"|{value:5}|")    # Output: |   42|  (standardmäßig rechtsbündig)
print(f"|{value:<5}|")   # Output: |42   |  (linksbündig)
print(f"|{value:^5}|")   # Output: | 42  |  (zentriert)

6.4.2) Benutzerdefinierte Füllzeichen

Sie können ein Zeichen angeben, mit dem der Leerraum aufgefüllt wird:

python

# alignment_fill.py
name = "Bob"
print(f"|{name:*<10}|")  # Output: |Bob*******|
print(f"|{name:*>10}|")  # Output: |*******Bob|
print(f"|{name:*^10}|")  # Output: |***Bob****|
 
# Nützlich, um visuelle Trenner zu erzeugen
print(f"{name:=^20}")    # Output: ========Bob=========

Die Syntax lautet {value:fill_char align width}.

6.4.3) Ausrichtung mit Zahlenformatierung kombinieren

Sie können Breite, Ausrichtung und Zahlenformatierung kombinieren:

python

# alignment_combined.py
price = 19.99
quantity = 5
total = price * quantity
 
# Rechtsbündig mit Breite 10, 2 Nachkommastellen
print(f"Price:    ${price:>10.2f}")     # Output: Price:    $     19.99
print(f"Quantity: {quantity:>10}")      # Output: Quantity:          5
print(f"Total:    ${total:>10.2f}")     # Output: Total:    $     99.95
 
# Mit Füllzeichen für einen visuellen Effekt
print(f"Total:    ${total:>10.2f}".replace(' ', '.'))  # Output: Total:....$.....99.95

In diesem Kapitel haben Sie grundlegende Techniken zur String-Manipulation gelernt, die Sie in nahezu jedem Python-Programm verwenden werden: Zeichenketten zum Zweck der Textverarbeitung zerlegen und zusammenfügen, formatierten Output mit f-Strings und Format-Spezifizierern erzeugen sowie Zahlen für professionelle Darstellungen ausrichten und formatieren.

Diese Fähigkeiten bilden die Grundlage für die Arbeit mit Textdaten in Python. Sie können nun Benutzereingaben verarbeiten, formatierte Berichte erstellen und mit Daten aus Dateien umgehen (was wir in Kapitel 24 behandeln werden). Während Sie Python weiter lernen, werden Sie diese Techniken zum Umgang mit Zeichenketten ständig verwenden – üben Sie sie also so lange, bis sie in Fleisch und Blut übergegangen sind.