5. Mit Text und Strings arbeiten

Text ist allgegenwärtig in der Programmierung. Vom Anzeigen von Meldungen für Benutzer über die Verarbeitung von Datendateien bis hin zum Erstellen von Webanwendungen – mit Text zu arbeiten ist eine der grundlegendsten Fähigkeiten, die Sie als Programmierer entwickeln. In Python arbeiten wir mit Text mithilfe von Strings – Sequenzen von Zeichen, die Wörter, Sätze oder jede Art von Textdaten darstellen können.

Sie sind Strings bereits kurz in früheren Kapiteln begegnet, als Sie print() und input() verwendet haben. Jetzt werden wir Strings im Detail erforschen und lernen, wie man sie erstellt, verändert und Pythons leistungsstarke eingebaute String-Funktionen nutzt, um echte Textverarbeitungsprobleme zu lösen.

In diesem Kapitel lernen Sie, wie Sie Strings mit Sonderzeichen erstellen, Strings miteinander kombinieren, bestimmte Teile von Strings extrahieren, ihre Groß-/Kleinschreibung und Formatierung ändern, nach Text in Strings suchen und verstehen, warum sich Strings anders verhalten als Zahlen, wenn es um Änderungen geht. Am Ende verfügen Sie über ein solides Fundament für die Arbeit mit Text in Python.

5.1) String-Literale und Escape-Sequenzen

5.1.1) String-Literale erstellen

Ein String-Literal ist ein String-Wert, der direkt in Ihrem Code geschrieben ist. Sie haben bereits Strings gesehen, die mit einfachen Anführungszeichen (') oder doppelten Anführungszeichen (") erstellt wurden:

python

# string_basics.py
greeting = 'Hello, World!'
message = "Python is great!"
 
print(greeting)  # Output: Hello, World!
print(message)   # Output: Python is great!

Einfache und doppelte Anführungszeichen funktionieren in Python identisch – die Wahl liegt bei Ihnen. Beide Optionen sind jedoch nützlich, wenn Ihr String selbst Anführungszeichen enthält:

python

# quotes_in_strings.py
# Verwendung von doppelten Anführungszeichen, wenn der String ein einfaches Anführungszeichen enthält
sentence = "It's a beautiful day!"
print(sentence)  # Output: It's a beautiful day!
 
# Verwendung von einfachen Anführungszeichen, wenn der String doppelte Anführungszeichen enthält
quote = 'She said, "Hello!"'
print(quote)  # Output: She said, "Hello!"

Wenn Sie denselben Typ von Anführungszeichen einfügen müssen, der den String umgibt, können Sie ihn mit einem Backslash (\) escapen:

python

# escaping_quotes.py
# Ein einfaches Anführungszeichen in einem einfach-quotierten String escapen
sentence = 'It\'s a beautiful day!'
print(sentence)  # Output: It's a beautiful day!
 
# Doppelte Anführungszeichen in einem doppelt-quotierten String escapen
quote = "She said, \"Hello!\""
print(quote)  # Output: She said, "Hello!"

Der Backslash teilt Python mit, dass das folgende Anführungszeichen Teil des String-Inhalts ist und nicht das Ende des Strings markiert.

5.1.2) Mehrzeilige Strings mit dreifachen Anführungszeichen

Für Strings, die sich über mehrere Zeilen erstrecken, stellt Python dreifache Anführungszeichen bereit – entweder drei einfache Anführungszeichen (''') oder drei doppelte Anführungszeichen ("""):

python

# multiline_strings.py
poem = """Roses are red,
Violets are blue,
Python is awesome,
And so are you!"""
 
print(poem)
# Output:
# Roses are red,
# Violets are blue,
# Python is awesome,
# And so are you!

Dreifach-quotierte Strings behalten alle Zeilenumbrüche und Abstände genau so bei, wie Sie sie eingeben. Sie sind besonders nützlich für längere Textblöcke, Dokumentationsstrings (die wir in Kapitel 19 sehen werden) oder wenn Sie sowohl einfache als auch doppelte Anführungszeichen ohne Escaping einfügen müssen:

python

# triple_quotes_convenience.py
dialogue = '''The teacher said, "Don't forget: it's important to practice!"'''
print(dialogue)  # Output: The teacher said, "Don't forget: it's important to practice!"

5.1.3) Häufige Escape-Sequenzen

Über das Escapen von Anführungszeichen hinaus führt der Backslash Escape-Sequenzen ein – spezielle Zweierkombinationen von Zeichen, die Zeichen darstellen, die schwer oder unmöglich direkt zu tippen sind:

python

# escape_sequences.py
# Newline: springt in die nächste Zeile
print("First line\nSecond line")
# Output:
# First line
# Second line
 
# Tab: fügt horizontalen Abstand ein
print("Name:\tJohn\nAge:\t25")
# Output:
# Name:	John
# Age:	25
 
# Backslash: um einen tatsächlichen Backslash einzufügen
path = "C:\\Users\\Documents"
print(path)  # Output: C:\Users\Documents

Hier sind die am häufigsten verwendeten Escape-Sequenzen:

Escape Sequence	Bedeutung	Beispielausgabe
`\n`	Newline (Zeilenumbruch)	Zwei Zeilen
`\t`	Tab (horizontaler Abstand)	Eingegerückter Text
`\\`	Backslash	`\`-Zeichen
`\'`	Einfaches Anführungszeichen	`'`-Zeichen
`\"`	Doppeltes Anführungszeichen	`"`-Zeichen

Das Verständnis von Escape-Sequenzen ist entscheidend, wenn Sie mit Dateipfaden arbeiten (insbesondere unter Windows, das Backslashes verwendet), formatierten Ausgaben oder beliebigem Text, der eine besondere Formatierung benötigt.

5.1.4) Raw-Strings für wörtliche Backslashes

Manchmal möchten Sie, dass Backslashes wörtlich behandelt werden, ohne Escape-Sequenzen auszulösen. Das ist üblich, wenn Sie mit Dateipfaden oder regulären Ausdrücken (Regular Expressions, auf die wir kurz in Kapitel 39 eingehen) arbeiten. Python stellt Raw-Strings bereit, indem der String mit r präfixiert wird:

python

# raw_strings.py
# Normaler String: Backslashes lösen Escape-Sequenzen aus
regular = "C:\new\test"
print(regular)  # Output: C:
                #         ew   est
                # (\n wird zu Newline, \t wird zu Tab)
 
# Raw-String: Backslashes sind wörtlich
raw = r"C:\new\test"
print(raw)  # Output: C:\new\test

In einem Raw-String ist \n wörtlich die zwei Zeichen Backslash und n, kein Zeilenumbruch. Raw-Strings sind besonders nützlich für Windows-Dateipfade:

python

# windows_paths.py
# Ohne Raw-String müssen Sie jeden Backslash escapen
path1 = "C:\\Users\\John\\Documents\\file.txt"
 
# Mit Raw-String funktionieren Backslashes natürlich
path2 = r"C:\Users\John\Documents\file.txt"
 
print(path1)  # Output: C:\Users\John\Documents\file.txt
print(path2)  # Output: C:\Users\John\Documents\file.txt

Beide Ansätze erzeugen dasselbe Ergebnis, aber Raw-Strings sind lesbarer, wenn Sie viele Backslashes haben.

5.2) Konkatenation und String-Wiederholung

5.2.1) Strings mit + konkatenieren

Sie können Strings mit dem Operator + kombinieren, was Konkatenation genannt wird:

python

# string_concatenation.py
first_name = "John"
last_name = "Smith"
 
# Strings mit + kombinieren
full_name = first_name + " " + last_name
print(full_name)  # Output: John Smith
 
# Längere Strings aufbauen
greeting = "Hello, " + full_name + "!"
print(greeting)  # Output: Hello, John Smith!

Die Konkatenation erstellt einen neuen String, indem die Strings aneinandergehängt werden. Beachten Sie, dass Python nicht automatisch Leerzeichen einfügt – Sie müssen sie explizit hinzufügen:

python

# concatenation_spacing.py
word1 = "Hello"
word2 = "World"
 
# Ohne Leerzeichen
no_space = word1 + word2
print(no_space)  # Output: HelloWorld
 
# Mit Leerzeichen
with_space = word1 + " " + word2
print(with_space)  # Output: Hello World

Sie können beliebig viele Strings in einem einzelnen Ausdruck konkatenieren:

python

# multiple_concatenation.py
address = "123" + " " + "Main" + " " + "Street"
print(address)  # Output: 123 Main Street

Wichtige Einschränkung: Sie können nur Strings mit anderen Strings konkatenieren. Wenn Sie versuchen, einen String mit einer Zahl zu konkatenieren, führt das zu einem Fehler:

python

# concatenation_error.py
age = 25
# Dies führt zu einem Fehler:
# message = "I am " + age + " years old"  # TypeError!
 
# Sie müssen die Zahl zuerst in einen String umwandeln
message = "I am " + str(age) + " years old"
print(message)  # Output: I am 25 years old

Wir werden die Umwandlung zwischen Strings und Zahlen detaillierter in Abschnitt 5.6 untersuchen.

5.2.2) Strings mit * wiederholen

Python bietet eine bequeme Möglichkeit, einen String mehrfach mit dem Operator * zu wiederholen:

python

# string_repetition.py
separator = "-" * 20
print(separator)  # Output: --------------------
 
# Muster erstellen
pattern = "abc" * 3
print(pattern)  # Output: abcabcabc
 
# Nützlich für formatierte Ausgaben
print("=" * 30)
print("Important Message")
print("=" * 30)
# Output:
# ==============================
# Important Message
# ==============================

Der Wiederholungsoperator funktioniert mit jeder positiven Ganzzahl:

python

# repetition_examples.py
# Nullmal wiederholen ergibt einen leeren String
nothing = "Hello" * 0
print(nothing)      # Output: (empty string)
print(len(nothing)) # Output: 0
 
# Einmal wiederholen ergibt den ursprünglichen String
once = "Hello" * 1
print(once)  # Output: Hello
 
# Größere Wiederholungen
many = "Go! " * 5
print(many)  # Output: Go! Go! Go! Go! Go!

Die String-Wiederholung ist besonders nützlich, um visuelle Trennlinien, Abstände oder Testdaten zu erzeugen:

python

# practical_repetition.py
# Eine einfache Textbox erstellen
width = 40
border = "=" * width
title = "Welcome"
padding = " " * ((width - len(title)) // 2)
 
print(border)
print(padding + title)
print(border)
# Output:
# ========================================
#                 Welcome
# ========================================

5.2.3) Konkatenation und Wiederholung kombinieren

Sie können beide Operatoren im selben Ausdruck kombinieren, wobei Pythons Operatorrangfolge gilt (Multiplikation vor Addition, genau wie bei Zahlen):

python

# combined_operations.py
# Zuerst wird wiederholt, dann konkatenieren
result = "=" * 10 + " Title " + "=" * 10
print(result)  # Output: ========== Title ==========
 
# Verwendung von Klammern zur Steuerung der Reihenfolge
repeated_phrase = ("Hello " + "World ") * 3
print(repeated_phrase)  # Output: Hello World Hello World Hello World

Diese Operationen bilden die Grundlage der String-Manipulation und ermöglichen es Ihnen, komplexe Strings aus einfachen Bausteinen aufzubauen.

5.3) Strings indizieren und slicen

Strings in Python sind Sequenzen von Zeichen, was bedeutet, dass jedes Zeichen eine bestimmte Position besitzt. Sie können einzelne Zeichen oder Teile eines Strings mithilfe von Indizierung und Slicing abrufen.

5.3.1) String-Indizes verstehen

Jedes Zeichen in einem String hat eine numerische Position, einen sogenannten Index. Python verwendet nullbasierte Indizierung, das heißt, das erste Zeichen hat den Index 0, das zweite den Index 1 usw.:

python

# string_indexing.py
text = "Python"
 
# Einzelne Zeichen per Index abrufen
print(text[0])  # Output: P (erstes Zeichen)
print(text[1])  # Output: y (zweites Zeichen)
print(text[5])  # Output: n (sechstes Zeichen)

Hier ist eine visuelle Darstellung, wie Indizes auf Zeichen abgebildet werden:

String:  P  y  t  h  o  n
Index:   0  1  2  3  4  5

Python unterstützt auch negative Indizes, die vom Ende des Strings aus zählen. Index -1 bezieht sich auf das letzte Zeichen, -2 auf das vorletzte usw.:

python

# negative_indexing.py
text = "Python"
 
print(text[-1])  # Output: n (letztes Zeichen)
print(text[-2])  # Output: o (vorletztes Zeichen)
print(text[-6])  # Output: P (erstes Zeichen)

Negative Indizes sind besonders nützlich, wenn Sie Zeichen nahe dem Ende eines Strings abrufen wollen, ohne seine exakte Länge zu kennen:

String:    P  y  t  h  o  n
Positive:  0  1  2  3  4  5
Negative: -6 -5 -4 -3 -2 -1

Wichtig: Wenn Sie versuchen, auf einen Index zuzugreifen, der nicht existiert, führt das zu einem IndexError:

python

# index_error.py
text = "Python"
 
# Das funktioniert
print(text[5])  # Output: n
 
# Dies führt zu einem Fehler, weil der Index 6 nicht existiert
# print(text[6])  # IndexError: string index out of range

5.3.2) Strings mit Slicing in Substrings aufteilen

Während die Indizierung Ihnen ein einzelnes Zeichen gibt, ermöglicht Slicing, einen Teil eines Strings (einen Substring) zu extrahieren. Die grundlegende Syntax lautet:

string[start:stop]

Dies extrahiert Zeichen von Index start bis (aber ohne) Index stop:

python

# basic_slicing.py
text = "Python Programming"
 
# Zeichen von Index 0 bis (aber ohne) 6 extrahieren
print(text[0:6])  # Output: Python
 
# Zeichen von Index 7 bis 18 extrahieren
print(text[7:18])  # Output: Programming
 
# Einen mittleren Abschnitt extrahieren
print(text[7:11])  # Output: Prog

Das Wichtigste ist, dass der stop-Index nicht im Ergebnis enthalten ist. Stellen Sie sich die Indizes so vor, dass sie zwischen Zeichen zeigen:

 P  y  t  h  o  n
 0  1  2  3  4  5  6

text[0:6] bedeutet also „beginne an Position 0 und stoppe vor Position 6“ und gibt Ihnen die Zeichen an den Positionen 0, 1, 2, 3, 4 und 5.

5.3.3) Start- oder Stop-Indizes weglassen

Sie können den start-Index weglassen, um vom Beginn zu slicen, oder den stop-Index weglassen, um bis zum Ende zu slicen:

python

# omitting_indices.py
text = "Python Programming"
 
# Vom Anfang bis Index 6
print(text[:6])  # Output: Python
 
# Von Index 7 bis zum Ende
print(text[7:])  # Output: Programming
 
# Der gesamte String (vom Anfang bis zum Ende)
print(text[:])  # Output: Python Programming

Diese Abkürzungen sind in Python-Code sehr verbreitet, weil sie die Absicht klar machen und das Hartkodieren von Längen vermeiden.

5.3.4) Negative Indizes in Slices verwenden

Negative Indizes funktionieren auch in Slices und erlauben es Ihnen, vom Ende her zu zählen:

python

# negative_slice_indices.py
text = "Python Programming"
 
# Letzte 11 Zeichen
print(text[-11:])  # Output: Programming
 
# Alles außer den letzten 11 Zeichen
print(text[:-11])  # Output: Python
 
# Letzte 7 Zeichen
print(text[-7:])  # Output: ramming
 
# Von Index 7 bis zum drittletzten Zeichen
print(text[7:-3])  # Output: Programm (stoppt vor 'ing')

Negative Indizes sind besonders nützlich, wenn Sie eine bestimmte Anzahl von Zeichen vom Ende ausschließen möchten:

python

# removing_suffix.py
filename = "document.txt"
 
# Alles außer den letzten 4 Zeichen (.txt) holen
name_without_extension = filename[:-4]
print(name_without_extension)  # Output: document

5.3.5) Slicing mit einem Schrittwert

Slices können einen dritten Wert namens step enthalten, der bestimmt, wie viele Zeichen übersprungen werden:

string[start:stop:step]

python

# slicing_with_step.py
text = "Python Programming"
 
# Jedes zweite Zeichen aus dem gesamten String
print(text[::2])  # Output: Pto rgamn
 
# Jedes zweite Zeichen von Index 0 bis 6
print(text[0:6:2])  # Output: Pto
 
# Jedes dritte Zeichen
print(text[::3])  # Output: Ph oai

Ein besonders nützlicher Trick ist die Verwendung eines Schritts von -1, um einen String umzukehren:

python

# reversing_strings.py
text = "Python"
 
# Den gesamten String umkehren
reversed_text = text[::-1]
print(reversed_text)  # Output: nohtyP
 
# Praktisches Beispiel: auf Palindrome prüfen
word = "radar"
if word == word[::-1]:
    print(f"{word} is a palindrome!")  # Output: radar is a palindrome!

5.3.6) Slicing verursacht niemals Fehler

Im Gegensatz zur Indizierung ist Slicing sehr fehlertolerant. Wenn Sie Indizes angeben, die außerhalb des gültigen Bereichs liegen, passt Python sie einfach an:

python

# safe_slicing.py
text = "Python"
 
# Diese Anweisungen funktionieren alle ohne Fehler
print(text[0:100])   # Output: Python (stoppt am Ende)
print(text[10:20])   # Output: (empty string - start liegt hinter dem Ende)
print(text[-100:3])  # Output: Pyt (start wird auf 0 angepasst)

Dieses Verhalten macht Slicing sicher in der Anwendung, selbst wenn Sie die exakte String-Länge nicht kennen.

5.3.7) Praktische Slicing-Beispiele

Hier sind einige gängige Muster, die Sie häufig verwenden werden:

python

# practical_slicing.py
text = "Hello, World!"
 
# Erste 5 Zeichen
print(text[:5])  # Output: Hello
 
# Letzte 6 Zeichen
print(text[-6:])  # Output: World!
 
# Alles außer dem ersten und letzten Zeichen
print(text[1:-1])  # Output: ello, World
 
# Jedes zweite Zeichen
print(text[::2])  # Output: Hlo ol!
 
# Den String umkehren
print(text[::-1])  # Output: !dlroW ,olleH

Das Verständnis von Indizierung und Slicing ist grundlegend für die Textverarbeitung in Python. Diese Techniken werden auf Ihrer Programmierreise immer wieder auftauchen.

5.4) Häufige String-Methoden für Groß-/Kleinschreibung und Whitespace

Python-Strings besitzen viele eingebaute Methoden – Funktionen, die an String-Objekte gebunden sind und Operationen auf ihnen ausführen. In diesem Abschnitt werden wir Methoden zur Änderung der Groß-/Kleinschreibung und zur Verwaltung von Whitespace betrachten, die für das Bereinigen und Formatieren von Text unerlässlich sind.

5.4.1) String-Methoden verstehen

Eine Methode wird mit Punktnotation aufgerufen: string.method_name(). Methoden sind Funktionen, die zu einem bestimmten Objekttyp gehören. Für Strings stellt Python Dutzende nützlicher Methoden bereit:

python

# method_basics.py
text = "hello"
 
# Eine Methode auf einem String aufrufen
result = text.upper()
print(result)  # Output: HELLO
 
# Der Original-String bleibt unverändert (warum, besprechen wir in Abschnitt 5.8)
print(text)  # Output: hello

Methoden können verkettet werden, weil jede Methode einen neuen String zurückgibt:

python

# method_chaining.py
text = "  hello world  "
 
# Mehrere Methoden verketten
result = text.strip().upper().replace("WORLD", "PYTHON")
print(result)  # Output: HELLO PYTHON

5.4.2) Methoden zur Änderung der Groß-/Kleinschreibung

Python stellt mehrere Methoden bereit, um die Groß-/Kleinschreibung von Strings zu ändern:

python

# case_methods.py
text = "Python Programming"
 
# In Großbuchstaben umwandeln
print(text.upper())  # Output: PYTHON PROGRAMMING
 
# In Kleinbuchstaben umwandeln
print(text.lower())  # Output: python programming
 
# Erstes Zeichen groß, Rest klein
print(text.capitalize())  # Output: Python programming
 
# Title Case: erstes Zeichen jedes Wortes groß
print(text.title())  # Output: Python Programming

Diese Methoden sind besonders nützlich, um Benutzereingaben zu vereinheitlichen:

python

# case_normalization.py
# Benutzereingabe simulieren
user_input = "YES"
 
# Groß-/Kleinschreibung-unabhängiger Vergleich
if user_input.lower() == "yes":
    print("User confirmed!")  # Output: User confirmed!
 
# Anderer Ansatz mit upper()
command = "start"
if command.upper() == "START":
    print("Starting process...")  # Output: Starting process...

Die Methode title() macht den ersten Buchstaben jedes Wortes groß, was nützlich für die Formatierung von Namen und Titeln ist:

python

# title_case.py
name = "john smith"
print(name.title())  # Output: John Smith
 
book = "the great gatsby"
print(book.title())  # Output: The Great Gatsby

Beachten Sie jedoch, dass title() bei Apostrophen und Sonderfällen Einschränkungen hat:

python

# title_limitations.py
text = "it's a beautiful day"
print(text.title())  # Output: It'S A Beautiful Day (beachten Sie das große S)
 
# Für ausgefeiltere Titel-Formatierung benötigen Sie möglicherweise eigene Logik

Die Methode capitalize() macht nur das allererste Zeichen des gesamten Strings groß:

python

# capitalize_examples.py
sentence = "python is great"
print(sentence.capitalize())  # Output: Python is great
 
# Hinweis: nur der erste Buchstabe wird großgeschrieben
multi_word = "hello world"
print(multi_word.capitalize())  # Output: Hello world (nicht Hello World)

5.4.3) Methoden zur Fallprüfung

Python stellt auch Methoden bereit, um die Groß-/Kleinschreibung von Strings zu prüfen:

python

# case_checking.py
text1 = "HELLO"
text2 = "hello"
text3 = "Hello World"
 
# Prüfen, ob alle Zeichen Großbuchstaben sind
print(text1.isupper())  # Output: True
print(text2.isupper())  # Output: False
 
# Prüfen, ob alle Zeichen Kleinbuchstaben sind
print(text1.islower())  # Output: False
print(text2.islower())  # Output: True
 
# Prüfen, ob der String im Title Case ist
print(text3.istitle())  # Output: True
print(text2.istitle())  # Output: False

Diese Prüfmethoden geben True oder False zurück (Boolesche Werte, die wir in Kapitel 3 kennengelernt haben) und eignen sich perfekt für Bedingungen:

python

# case_checking_conditions.py
password = "SECRET123"
 
if password.isupper():
    print("Password is all uppercase")  # Output: Password is all uppercase

5.4.4) Methoden zum Entfernen von Whitespace

Whitespace umfasst Leerzeichen, Tabs (\t) und Zeilenumbrüche (\n). Python stellt Methoden bereit, um Whitespace von den Rändern eines Strings zu entfernen:

python

# whitespace_removal.py
text = "   Hello, World!   "
 
# Whitespace von beiden Enden entfernen
print(text.strip())  # Output: Hello, World!
 
# Whitespace vom linken Rand (Anfang) entfernen
print(text.lstrip())  # Output: Hello, World!   
 
# Whitespace vom rechten Rand (Ende) entfernen
print(text.rstrip())  # Output:    Hello, World!

Die Methode strip() ist äußerst nützlich, um Benutzereingaben zu bereinigen:

python

# cleaning_input.py
# Benutzereingabe mit zusätzlichen Leerzeichen simulieren
user_name = "  John Smith  "
 
# Die Eingabe bereinigen
clean_name = user_name.strip()
print(f"Welcome, {clean_name}!")  # Output: Welcome, John Smith!

Diese Methoden entfernen auch Tabs und Zeilenumbrüche:

python

# strip_all_whitespace.py
text = "\n\t  Hello  \t\n"
print(repr(text))  # Output: '\n\t  Hello  \t\n'
 
cleaned = text.strip()
print(repr(cleaned))  # Output: 'Hello'

Beachten Sie, dass strip(), lstrip() und rstrip() nur Whitespace an den Rändern entfernen, nicht in der Mitte:

python

# strip_edges_only.py
text = "  Hello   World  "
print(text.strip())  # Output: Hello   World (Leerzeichen in der Mitte bleiben)

5.4.5) Bestimmte Zeichen entfernen

Die Strip-Methoden können auch bestimmte Zeichen (nicht nur Whitespace) an den Rändern entfernen:

python

# Mehrere unterschiedliche Zeichen entfernen
text = "...Hello!!!"
cleaned = text.strip(".!")
print(cleaned)  # Output: Hello

Wenn Sie strip() einen String übergeben, entfernt es jede Kombination dieser Zeichen an den Rändern:

python

# strip_character_set.py
text = "xxxyyyHelloyyyxxx"
 
# Alle x und y von beiden Enden entfernen
result = text.strip("xy")
print(result)  # Output: Hello

5.4.6) Praktische Beispiele mit Groß-/Kleinschreibungs- und Whitespace-Methoden

Hier sind praxisnahe Szenarien, in denen diese Methoden sehr wertvoll sind:

python

# practical_text_cleaning.py
# Benutzereingaben bereinigen und vereinheitlichen
user_email = "  JohnSmith@EXAMPLE.com  "
clean_email = user_email.strip().lower()
print(clean_email)  # Output: johnsmith@example.com
 
# Namen ordentlich formatieren
raw_name = "  john smith  "
formatted_name = raw_name.strip().title()
print(formatted_name)  # Output: John Smith
 
# Befehle verarbeiten (unabhängig von der Groß-/Kleinschreibung)
command = "  START  "
if command.strip().upper() == "START":
    print("Command recognized!")  # Output: Command recognized!

Diese Methoden bilden das Fundament für Textbereinigung und Normalisierung, die Sie ständig einsetzen werden, wenn Sie Benutzereingaben verarbeiten, Dateien einlesen oder Daten für Analysen vorbereiten.

5.5) Suchen und Ersetzen in Strings

Text in Strings zu finden und zu verändern, ist eine häufige Aufgabe in der Programmierung. Python stellt leistungsfähige Methoden bereit, um nach Substrings zu suchen und Text zu ersetzen.

5.5.1) Substrings mit find() und index() finden

Die Methode find() sucht nach einem Substring und gibt den Index zurück, an dem er zuerst erscheint:

python

# find_method.py
text = "Python is great. Python is powerful."
 
# Erstes Vorkommen von "Python" finden
position = text.find("Python")
print(position)  # Output: 0 (am Anfang gefunden)
 
# "great" finden
position = text.find("great")
print(position)  # Output: 10
 
# Etwas finden, das nicht existiert
position = text.find("Java")
print(position)  # Output: -1 (nicht gefunden)

Die Methode find() gibt -1 zurück, wenn der Substring nicht gefunden wird, was sie sicher in der Anwendung macht, ohne Fehler zu verursachen:

python

# safe_searching.py
text = "Hello, World!"
 
# Prüfen, ob ein Substring existiert
if text.find("World") != -1:
    print("Found 'World'!")  # Output: Found 'World'!
 
if text.find("Python") == -1:
    print("'Python' not found")  # Output: 'Python' not found

Sie können auch ab einer bestimmten Position nach einem Substring suchen:

python

# find_with_start.py
text = "Python is great. Python is powerful."
 
# Erstes Vorkommen finden
first = text.find("Python")
print(first)  # Output: 0
 
# Nächstes Vorkommen nach dem ersten finden
second = text.find("Python", first + 1)
print(second)  # Output: 17

Die Methode index() funktioniert ähnlich wie find(), löst aber einen Fehler aus, wenn der Substring nicht gefunden wird:

python

# index_method.py
text = "Hello, World!"
 
# Das funktioniert
position = text.index("World")
print(position)  # Output: 7
 
# Dies würde einen ValueError auslösen:
# position = text.index("Python")  # ValueError: substring not found

Wann welche Methode verwenden:

Verwenden Sie find(), wenn Sie prüfen möchten, ob etwas existiert (gibt -1 zurück, wenn nicht gefunden)
Verwenden Sie index(), wenn Sie erwarten, dass der Substring vorhanden ist (löst Fehler aus, wenn nicht gefunden)

python

# choosing_find_vs_index.py
text = "Python Programming"
 
# find() für sichere Prüfung verwenden
if text.find("Java") != -1:
    print("Found Java")
else:
    print("Java not found")  # Output: Java not found
 
# index() verwenden, wenn Sie sicher sind, dass es existiert
position = text.index("Python")  # Wir wissen, dass Python enthalten ist
print(f"Found at position {position}")  # Output: Found at position 0

5.5.2) Vom Ende her mit rfind() und rindex() suchen

Die Methoden rfind() und rindex() suchen von rechts (vom Ende) des Strings:

python

# rfind_method.py
text = "Python is great. Python is powerful."
 
# Letztes Vorkommen von "Python" finden
last_position = text.rfind("Python")
print(last_position)  # Output: 17
 
# Im Vergleich dazu find(), das das erste Vorkommen liefert
first_position = text.find("Python")
print(first_position)  # Output: 0

Das ist nützlich, wenn Sie das letzte Vorkommen von etwas suchen:

python

# last_occurrence.py
filename = "document.backup.txt"
 
# Den letzten Punkt finden (um die Dateierweiterung zu erhalten)
last_dot = filename.rfind(".")
if last_dot != -1:
    extension = filename[last_dot:]
    print(extension)  # Output: .txt

5.5.3) Vorkommen mit count() zählen

Die Methode count() sagt Ihnen, wie oft ein Substring vorkommt:

python

# count_method.py
text = "Python is great. Python is powerful. Python is fun."
 
# Zählen, wie oft "Python" vorkommt
count = text.count("Python")
print(count)  # Output: 3
 
# Einen Buchstaben zählen
letter_count = text.count("o")
print(f"Letter 'o' appears {letter_count} times")  # Output: Letter 'o' appears 4 times

Sie können auch in einem bestimmten Bereich zählen:

python

# count_in_range.py
text = "abcabcabc"
 
# "abc" im gesamten String zählen
total = text.count("abc")
print(total)  # Output: 3
 
# "abc" nur in den ersten 6 Zeichen zählen
partial = text.count("abc", 0, 6)
print(partial)  # Output: 2

5.5.4) Text mit replace() ersetzen

Die Methode replace() erstellt einen neuen String, in dem alle Vorkommen eines Substrings ersetzt wurden:

python

# replace_method.py
text = "I love Java. Java is great."
 
# Alle Vorkommen von "Java" durch "Python" ersetzen
new_text = text.replace("Java", "Python")
print(new_text)  # Output: I love Python. Python is great.
 
# Original-String bleibt unverändert
print(text)  # Output: I love Java. Java is great.

Sie können die Anzahl der Ersetzungen mit einem dritten Argument begrenzen:

python

# limited_replace.py
text = "one one one one"
 
# Nur die ersten 2 Vorkommen ersetzen
result = text.replace("one", "two", 2)
print(result)  # Output: two two one one

Die Methode replace() ist groß-/kleinschreibungssensitiv:

python

# case_sensitive_replace.py
text = "Python is great. python is powerful."
 
# Dies ersetzt nur "Python" (mit großem P)
result = text.replace("Python", "Java")
print(result)  # Output: Java is great. python is powerful.

Für ein Groß-/Kleinschreibung-unabhängiges Ersetzen müssen Sie es manuell behandeln:

python

# case_insensitive_approach.py
text = "Python is great. python is powerful."
 
# In Kleinbuchstaben umwandeln, ersetzen – dies verliert jedoch die ursprüngliche Großschreibung
result = text.lower().replace("python", "java")
print(result)  # Output: java is great. java is powerful.

5.5.5) Praktische Beispiele zum Suchen und Ersetzen

Hier sind praxisnahe Szenarien, in denen diese Methoden glänzen:

python

# practical_search_replace.py
# Daten bereinigen: unerwünschte Zeichen entfernen
phone = "123-456-7890"
clean_phone = phone.replace("-", "")
print(clean_phone)  # Output: 1234567890
 
# Wörter zensieren
message = "This is a bad word and another bad word."
censored = message.replace("bad", "***")
print(censored)  # Output: This is a *** word and another *** word.
 
# Dateierweiterung extrahieren
filename = "document.txt"
dot_position = filename.rfind(".")
if dot_position != -1:
    extension = filename[dot_position + 1:]
    print(f"File type: {extension}")  # Output: File type: txt
 
# Wortvorkommen zählen (einfacher Ansatz)
text = "Python is fun. I love Python. Python rocks!"
word = "Python"
occurrences = text.count(word)
print(f"'{word}' appears {occurrences} times")  # Output: 'Python' appears 3 times

Diese Such- und Ersetzungsmethoden sind grundlegende Werkzeuge für Textverarbeitung, Datenbereinigung und String-Manipulation in Python-Programmen.

5.6) Zwischen Strings und Zahlen konvertieren

Eine der häufigsten Aufgaben in der Programmierung ist die Umwandlung zwischen Text- und Zahlenrepräsentationen. Wenn Sie Benutzereingaben mit input() einlesen, erhalten Sie einen String – selbst wenn der Benutzer eine Zahl eingibt. Ebenso müssen Sie Zahlen in Strings umwandeln, wenn Sie sie im Text anzeigen wollen.

5.6.1) Strings in Zahlen umwandeln

Wir haben die Funktionen int() und float() bereits in Kapitel 3 gesehen, aber schauen wir sie uns genauer an:

python

# string_to_number.py
# String in Integer konvertieren
age_text = "25"
age = int(age_text)
print(age)        # Output: 25
print(type(age))  # Output: <class 'int'>
 
# String in Float konvertieren
price_text = "19.99"
price = float(price_text)
print(price)        # Output: 19.99
print(type(price))  # Output: <class 'float'>

Diese Umwandlungen sind entscheidend bei der Verarbeitung von Benutzereingaben:

python

# user_input_conversion.py
# Benutzereingabe simulieren (in echtem Code würden Sie input() verwenden)
user_age = "30"
user_height = "5.9"
 
# In Zahlen konvertieren, damit wir rechnen können
age = int(user_age)
height = float(user_height)
 
# Jetzt können wir Berechnungen durchführen
print(f"In 10 years, you'll be {age + 10}")  # Output: In 10 years, you'll be 40
print(f"Your height in meters: {height * 0.3048:.2f}")  # Output: Your height in meters: 1.80

Wichtig: Der String muss eine gültige Zahl darstellen, sonst erhalten Sie einen Fehler:

python

# conversion_errors.py
# Diese funktionieren
print(int("123"))      # Output: 123
print(float("3.14"))   # Output: 3.14
 
# Diese verursachen ValueError:
# print(int("hello"))     # ValueError: invalid literal for int()
# print(int("12.5"))      # ValueError: invalid literal for int() with base 10
# print(float("12.5.3"))  # ValueError: could not convert string to float

Wir werden in Kapitel 28 lernen, wie man solche Fehler elegant behandelt. Für den Moment sollten Sie wissen, dass die Umwandlung fehlschlagen kann, wenn der String keine gültige Zahl darstellt.

5.6.2) Whitespace in numerischen Strings behandeln

Die Konvertierungsfunktionen von Python verarbeiten führenden und nachgestellten Whitespace automatisch:

python

# whitespace_handling.py
# Diese funktionieren trotz der Leerzeichen
print(int("  42  "))      # Output: 42
print(float("  3.14  "))  # Output: 3.14
 
# strip() mit Konvertierung zur Sicherheit kombinieren
user_input = "  100  "
number = int(user_input.strip())
print(number)  # Output: 100

Das ist hilfreich bei der Verarbeitung von Benutzereingaben, die oft zusätzliche Leerzeichen enthalten.

5.6.3) Zahlen in Strings umwandeln

Die Funktion str() wandelt jeden Wert in seine String-Repräsentation um:

python

# number_to_string.py
age = 25
height = 5.9
 
# Zahlen in Strings konvertieren
age_text = str(age)
height_text = str(height)
 
print(type(age_text))     # Output: <class 'str'>
print(type(height_text))  # Output: <class 'str'>
 
# Jetzt können wir sie mit anderen Strings konkatenieren
message = "I am " + str(age) + " years old"
print(message)  # Output: I am 25 years old

Dies ist notwendig, wann immer Sie Zahlen mit Strings kombinieren wollen:

python

# concatenation_with_numbers.py
score = 95
total = 100
 
# Zahlen müssen für die Konkatenation in Strings umgewandelt werden
result = "Score: " + str(score) + "/" + str(total)
print(result)  # Output: Score: 95/100
 
# Alternative: f-strings verwenden (in Kapitel 6 ausführlich behandelt)
result = f"Score: {score}/{total}"
print(result)  # Output: Score: 95/100

5.6.4) Zwischen Integer und Float konvertieren

Sie können auch zwischen Integer- und Float-Typen konvertieren:

python

# int_float_conversion.py
# Float in int (schneidet den Dezimalteil ab)
price = 19.99
price_int = int(price)
print(price_int)  # Output: 19 (Dezimalteil entfernt, nicht gerundet)
 
# Int in Float
age = 25
age_float = float(age)
print(age_float)  # Output: 25.0

Wichtig: Die Umwandlung von Float zu int schneidet (kappt) den Dezimalteil ab – sie rundet nicht:

python

# truncation_not_rounding.py
print(int(3.9))   # Output: 3 (nicht 4!)
print(int(3.1))   # Output: 3
print(int(-3.9))  # Output: -3 (schneidet in Richtung 0 ab)
 
# Zum Runden verwenden Sie zuerst die Funktion round() (in Kapitel 4 behandelt)
print(int(round(3.9)))  # Output: 4

5.6.5) Praktische Konvertierungsbeispiele

Hier sind praxisnahe Szenarien, in denen Typumwandlung unerlässlich ist:

python

# practical_conversions.py
# Benutzereingaben lesen und verarbeiten
# (input() simulieren – in echtem Code würden Sie input() verwenden)
user_input = "42"
 
# In Zahl konvertieren, um Berechnungen durchzuführen
number = int(user_input)
doubled = number * 2
print(f"Double of {number} is {doubled}")  # Output: Double of 42 is 84
 
# Formatierte Ausgaben erzeugen
name = "John"
age = 30
height = 5.9
 
# Methode 1: Zahlen in Strings konvertieren
info = name + " is " + str(age) + " years old and " + str(height) + " feet tall"
print(info)  # Output: John is 30 years old and 5.9 feet tall
 
# Methode 2: f-strings verwenden (lesbarer – in Kapitel 6 behandelt)
info = f"{name} is {age} years old and {height} feet tall"
print(info)  # Output: John is 30 years old and 5.9 feet tall
 
# Daten aus Dateien verarbeiten (Vorschau)
data_line = "100,200,300"  # Eine Zeile aus einer CSV-Datei simulieren
numbers = data_line.split(",")  # In Liste von Strings aufteilen
total = int(numbers[0]) + int(numbers[1]) + int(numbers[2])
print(f"Total: {total}")  # Output: Total: 600

5.6.6) Häufige Fallstricke bei Konvertierungen

Achten Sie auf diese typischen Fehler:

python

# conversion_pitfalls.py
# Fallstrick 1: Versuch, nicht-numerische Strings zu konvertieren
# text = "hello"
# number = int(text)  # ValueError!
 
# Fallstrick 2: Vergessen, vor arithmetischen Operationen zu konvertieren
age_text = "25"
# next_year = age_text + 1  # TypeError: can only concatenate str to str
 
# Korrektes Vorgehen:
age = int(age_text)
next_year = age + 1
print(next_year)  # Output: 26
 
# Fallstrick 3: Genauigkeit mit int() verlieren
price = 19.99
price_int = int(price)  # Wird zu 19, nicht 20!
print(price_int)  # Output: 19
 
# Fallstrick 4: Versuch, Strings mit Kommas oder Währungssymbolen zu konvertieren
# price_text = "$1,234.56"
# price = float(price_text)  # ValueError!
 
# Sie müssen den String zuerst bereinigen:
price_text = "$1,234.56"
clean_price = price_text.replace("$", "").replace(",", "")
price = float(clean_price)
print(price)  # Output: 1234.56

Das Verständnis von Typumwandlung ist entscheidend, um Programme zu bauen, die mit Benutzern interagieren und reale Daten verarbeiten. Sie werden diese Konvertierungen ständig in Ihrer Python-Programmierung einsetzen.

5.7) Substrings mit in und not in prüfen

Python stellt einfache und gut lesbare Möglichkeiten bereit, um zu prüfen, ob ein String einen anderen enthält, mithilfe der Operatoren in und not in. Diese sind unglaublich nützlich für Validierung, Filterung und Entscheidungslogik in Ihren Programmen.

5.7.1) in verwenden, um nach Substrings zu prüfen

Der Operator in gibt True zurück, wenn ein String in einem anderen gefunden wird, und False andernfalls:

python

# in_operator.py
text = "Python is a powerful programming language"
 
# Prüfen, ob Substring existiert
print("Python" in text)      # Output: True
print("powerful" in text)    # Output: True
print("Java" in text)        # Output: False

Das ist viel lesbarer, als find() oder index() zu verwenden:

python

# in_vs_find.py
text = "Hello, World!"
 
# Verwendung von in (klar und lesbar)
if "World" in text:
    print("Found World!")  # Output: Found World!
 
# Verwendung von find (weniger lesbar)
if text.find("World") != -1:
    print("Found World!")  # Output: Found World!

Der Operator in ist groß-/kleinschreibungssensitiv:

python

# case_sensitivity.py
text = "Python Programming"
 
print("python" in text)   # Output: False (kleines p)
print("Python" in text)   # Output: True (großes P)
 
# Für Groß-/Kleinschreibung-unabhängige Prüfung zuerst in Kleinbuchstaben umwandeln
print("python" in text.lower())  # Output: True

5.7.2) not in verwenden, um Abwesenheit zu prüfen

Der Operator not in prüft, ob ein Substring NICHT vorhanden ist:

python

# not_in_operator.py
text = "Python is great"
 
print("Java" not in text)     # Output: True (Java ist nicht enthalten)
print("Python" not in text)   # Output: False (Python ist enthalten)

Dies ist besonders nützlich für Validierungen:

python

# validation_examples.py
# Auf ungültige Zeichen in einem Benutzernamen prüfen
username = "john_smith"
 
if " " not in username:
    print("Username is valid (no spaces)")  # Output: Username is valid (no spaces)

5.7.3) Zusätzliche String-Prüfmethoden

Python stellt mehrere weitere nützliche Methoden zur Prüfung von String-Eigenschaften bereit:

python

# string_checking_methods.py
text = "Python"
 
# Prüfen, ob String mit einem Substring beginnt
print(text.startswith("Py"))   # Output: True
print(text.startswith("Ja"))   # Output: False
 
# Prüfen, ob String mit einem Substring endet
print(text.endswith("on"))     # Output: True
print(text.endswith("ing"))    # Output: False
 
# Diese sind präziser als in
filename = "report.txt"
print(filename.endswith(".txt"))  # Output: True
print(".txt" in filename)         # Output: True (aber weniger präzise)
 
# startswith/endswith können mehrere Optionen prüfen
filename = "document.pdf"
print(filename.endswith((".pdf", ".doc", ".txt")))  # Output: True

Diese Prüfmethoden sind wesentliche Werkzeuge für Eingabevalidierung, Datenfilterung und bedingte Logik in Ihren Programmen. Sie machen Ihren Code lesbarer und wartbarer als manuelle String-Suchlogik.

5.8) Strings sind unveränderlich (immutable): Was das praktisch bedeutet

Eine der wichtigsten Eigenschaften von Python-Strings ist, dass sie unveränderlich (immutable) sind – einmal erstellt, können sie nicht mehr verändert werden. Das mag zunächst wie eine Einschränkung wirken, aber das Verständnis der Unveränderlichkeit ist entscheidend, um korrekten Python-Code zu schreiben und subtile Fehler zu vermeiden.

5.8.1) Was Unveränderlichkeit bedeutet

Wenn wir sagen, Strings sind unveränderlich, meinen wir, dass Sie die Zeichen in einem bestehenden String nicht ändern können. Jede Operation, die scheinbar einen String „ändert“, erstellt tatsächlich einen neuen String:

python

# immutability_basics.py
text = "Hello"
 
# Das sieht so aus, als würde es den String ändern, tut es aber nicht
text = text + " World"
print(text)  # Output: Hello World
 
# Was tatsächlich passiert ist:
# 1. Python hat einen neuen String "Hello World" erstellt
# 2. Die Variable 'text' verweist jetzt auf diesen neuen String
# 3. Der ursprüngliche String "Hello" existiert weiterhin (bis er vom Garbage Collector entfernt wird)

Sie können einzelne Zeichen in einem String nicht ändern:

python

# cannot_modify_characters.py
text = "Hello"
 
# Dies führt zu einem Fehler:
# text[0] = "J"  # TypeError: 'str' object does not support item assignment
 
# Sie müssen stattdessen einen neuen String erstellen
text = "J" + text[1:]
print(text)  # Output: Jello

Das unterscheidet sich grundlegend von der Arbeitsweise von Listen (lists), die wir in Kapitel 13 kennenlernen werden. Listen sind veränderlich – Sie können ihre Elemente ändern:

python

# lists_are_mutable.py
# Vorschau auf Listen (in Kapitel 13 behandelt)
numbers = [1, 2, 3]
numbers[0] = 10  # Das funktioniert bei Listen problemlos
print(numbers)   # Output: [10, 2, 3]
 
# Aber Strings erlauben das nicht:
text = "Hello"
# text[0] = "J"  # TypeError bei Strings!

5.8.2) Warum String-Methoden neue Strings zurückgeben

Alle String-Methoden, die scheinbar einen String verändern, geben tatsächlich einen neuen String zurück und lassen das Original unverändert:

python

# methods_return_new_strings.py
original = "hello world"
 
# Diese Methoden geben neue Strings zurück
uppercase = original.upper()
capitalized = original.capitalize()
replaced = original.replace("world", "Python")
 
# Original-String bleibt unverändert
print(original)      # Output: hello world
print(uppercase)     # Output: HELLO WORLD
print(capitalized)   # Output: Hello world
print(replaced)      # Output: hello Python

Deshalb müssen Sie das Ergebnis einer Methode einer Variablen zuweisen (oder dieselbe Variable wiederverwenden), um die Änderungen zu behalten:

python

# keeping_changes.py
text = "  hello  "
 
# Falsch: Ergebnis geht verloren
text.strip()
print(text)  # Output:   hello   (hat immer noch Leerzeichen!)
 
# Richtig: Ergebnis zuweisen
text = text.strip()
print(text)  # Output: hello (Leerzeichen entfernt)

Das ist ein häufiger Fehler bei Einsteigern:

python

# common_mistake.py
message = "python programming"
 
# Fehler: Methode aufrufen, aber Ergebnis nicht verwenden
message.upper()
message.replace("python", "Python")
print(message)  # Output: python programming (unverändert!)
 
# Richtig: Ergebnisse zuweisen
message = message.upper()
message = message.replace("PYTHON", "Python")
print(message)  # Output: Python PROGRAMMING

5.8.3) Auswirkungen der Unveränderlichkeit

Das Verständnis der Unveränderlichkeit hilft Ihnen, besseren Code zu schreiben:

1. Strings sind sicher gemeinsam nutzbar:

python

# safe_sharing.py
original = "Hello"
copy = original  # Beide Variablen verweisen auf denselben String
 
# Da Strings unveränderlich sind, ist das sicher
copy = copy + " World"
 
print(original)  # Output: Hello (unverändert)
print(copy)      # Output: Hello World (neuer String)

2. String-Operationen erzeugen neue Objekte:

python

# new_objects.py
text = "Python"
 
# Jede Operation erzeugt ein neues String-Objekt
result1 = text.upper()
result2 = text.lower()
result3 = text.replace("P", "J")
 
# Alles unterschiedliche Objekte
print(id(text))     # Eine Speicheradresse
print(id(result1))  # Andere Speicheradresse
print(id(result2))  # Andere Speicheradresse
print(id(result3))  # Andere Speicheradresse

3. Strings in Schleifen aufzubauen, kann ineffizient sein:

python

# inefficient_string_building.py
# Dies erzeugt viele temporäre String-Objekte
result = ""
for i in range(5):
    result = result + str(i)  # Jedes Mal wird ein neuer String erstellt
print(result)  # Output: 01234
 
# Effizienterer Ansatz (für viele Konkatenationen):
# Eine Liste verwenden und join aufrufen (wir lernen das in Kapitel 6)
parts = []
for i in range(5):
    parts.append(str(i))
result = "".join(parts)
print(result)  # Output: 01234

5.8.4) Unveränderlichkeit und Funktionsargumente

Wenn Sie einen String an eine Funktion übergeben, müssen Sie sich keine Sorgen machen, dass er versehentlich verändert wird:

python

# safe_function_arguments.py
def process_text(text):
    # Jede Operation erzeugt neue Strings
    text = text.upper()
    text = text.replace("A", "X")
    return text
 
original = "banana"
result = process_text(original)
 
print(original)  # Output: banana (unverändert)
print(result)    # Output: BXNXNX (veränderte Version)

Das ist anders bei veränderlichen Typen (wie Listen, die wir in Kapitel 13 kennenlernen werden), bei denen Änderungen in Funktionen das Originalobjekt beeinflussen.

5.8.5) Unveränderlichkeit visualisieren

Hier ist eine visuelle Darstellung dessen, was passiert, wenn Sie einen String „ändern“:

Wenn Sie verstehen, dass Strings unveränderlich sind, hilft Ihnen das dabei:

Fehler zu vermeiden, bei denen Sie vergessen, Methodenrückgaben zu speichern
Zu verstehen, warum String-Operationen neue Objekte erzeugen
Effizienteren Code zu schreiben, wenn Sie große Strings aufbauen
Strings sicher zwischen verschiedenen Teilen Ihres Programms zu teilen

Diese Unveränderlichkeit ist ein grundlegendes Merkmal, das Strings von veränderlichen Typen wie Listen unterscheidet, die wir ausführlich in Teil IV dieses Buches untersuchen werden.

Kapitelzusammenfassung:

In diesem Kapitel haben Sie die Grundlagen der Arbeit mit Text in Python mithilfe von Strings kennengelernt. Sie verstehen nun, wie man:

String-Literale mit Anführungszeichen und Escape-Sequenzen erstellt
Strings mit Konkatenation und Wiederholung kombiniert
Einzelne Zeichen mit Indizierung abruft und Substrings mit Slicing extrahiert
Strings mit Methoden zur Groß-/Kleinschreibungsänderung und Whitespace-Entfernung transformiert
In Strings nach Text sucht und Text ersetzt
Zwischen Strings und Zahlen zur Eingabeverarbeitung und Ausgabeformatierung konvertiert
Substrings mithilfe der Operatoren in und not in prüft
Erkennt, dass Strings unveränderlich sind, und was das für Ihren Code bedeutet

Diese Fähigkeiten zur String-Manipulation bilden das Fundament für die Textverarbeitung in Python. Sie werden diese Techniken ständig einsetzen, wenn Sie Benutzeroberflächen erstellen, Datendateien verarbeiten, Eingaben validieren und Ausgaben formatieren.

Im nächsten Kapitel werden wir auf diesen Grundlagen aufbauen, indem wir fortgeschrittenere Techniken zur String-Verarbeitung untersuchen, darunter das Aufteilen und Zusammenfügen von Strings, leistungsfähige Formatierung mit f-strings und der Methode format() sowie das Verständnis von Textkodierung, um mit internationalen Zeichen zu arbeiten.