Python-String-Operationen: Ein umfassendes Tutorial
In diesem Tutorial werden wir uns mit der Erstellung von Python-Programmen beschäftigen, die häufige Fragen zu String-Operationen beantworten.
Wir werden untersuchen, wie man feststellt, ob ein Python-String ein Palindrom oder ein Anagramm ist und ob er im Titelformat vorliegt.
Python-Strings: Eine kurze Einführung
In Python sind Strings ein integraler und leistungsfähiger Datentyp. Sie ermöglichen es uns, Zeichenketten zu speichern.
Indizierung in Python-Strings: Wie bei allen iterierbaren Objekten in Python, erfolgt die Indizierung von Strings ab Null. Für einen String der Länge N sind die gültigen Indizes 0, 1, 2 bis N-1.
Python unterstützt auch die negative Indizierung, wodurch man vom Ende des Strings auf Elemente zugreifen kann. -1 repräsentiert das letzte Zeichen, -2 das vorletzte usw.
Unveränderlichkeit von Python-Strings: Strings in Python sind unveränderlich. Dies bedeutet, dass man sie nicht direkt ändern kann. Stattdessen können wir verschiedene String-Methoden verwenden, um Kopien der Strings mit den gewünschten Modifikationen zu erhalten.
Nach dieser kurzen Einführung in Python-Strings können wir uns nun einigen grundlegenden, aber interessanten Problemen zuwenden.
Lasst uns beginnen.
Überprüfung auf Palindrome in Python-Strings
Problemstellung: Gegeben sei ein Python-String. Bestimme, ob es sich um ein Palindrom handelt.
Gib `True` zurück, wenn ja; ansonsten `False`.
Ein Palindrom ist ein String, der von links nach rechts und von rechts nach links identisch gelesen wird. Beispiele hierfür sind: „rotor“, „anna“, „lagerregal“, „rentner“.
Hier sind die Schritte zur Lösung:
- Erstelle eine umgekehrte Kopie des Strings und speichere sie gegebenenfalls in einer neuen Variablen.
- Vergleiche die Original- und die umgekehrte Kopie.
- Sind beide gleich, ist der String ein Palindrom. Gib `True` zurück und beende.
- Sind sie ungleich, ist es kein Palindrom. Gib `False` zurück.
Die Kernoperation ist die Erstellung der umgekehrten Kopie. Dafür gibt es in Python mehrere Möglichkeiten.
Wir werden zwei Methoden betrachten:
- String-Slicing
- Verwendung der `reversed()`-Funktion und `join()`-Methode
Umkehrung eines Python-Strings mit Slicing
Die Syntax `
- Wenn `start` nicht angegeben ist, beginnt der Slice am Anfang des Strings.
- Wenn `stop` nicht angegeben ist, geht der Slice bis zum Ende des Strings.
- Negative Werte für `step` ermöglichen es, Slices vom Ende des Strings aus zu erstellen.
Somit liefert `
Die folgende Funktion `is_palindrome()` akzeptiert einen String und gibt `True` oder `False` zurück, je nachdem, ob es sich um ein Palindrom handelt.
Hier nutzen wir String-Slicing für die umgekehrte Kopie.
def is_palindrome(this_str):
rev_str = this_str[::-1]
if (this_str == rev_str):
return True
else:
return False
▶️ Nach Definition können wir die Funktion mit beliebigen gültigen Strings aufrufen.
is_palindrome("rotor")
# Output
True
Im obigen Beispiel ist „rotor“ ein Palindrom. Daher gibt die Funktion `is_palindrome()` korrekterweise `True` zurück.
Versuchen wir es mit einem Nicht-Palindrom, z. B. „fluss“.
is_palindrome("fluss")
# Output
False
Wie erwartet gibt die Funktion `False` zurück. ✅
Umkehrung eines Python-Strings mit `reversed()` und `join()`
In Python können wir `join()` in Kombination mit `reversed()` verwenden, um einen String umzukehren.
- Die Funktion `reversed()` gibt einen Iterator zurück, der die Zeichen des Strings in umgekehrter Reihenfolge durchläuft.
- `join()` verbindet diese Zeichen dann in umgekehrter Reihenfolge.
Mit dieser Methode können wir die Funktion `is_palindrome()` wie folgt umschreiben:
def is_palindrome(this_str):
rev_str="".join(reversed(this_str))
if (this_str == rev_str):
return True
else:
return False
Wir können die Funktion `is_palindrome()` auch innerhalb einer List Comprehension verwenden, um alle Palindrome aus einer Liste von Strings zu filtern:
str_list = ["anna","blau","lagerregal","12321","drache"]
palindromes = [string for string in str_list if is_palindrome(string)]
print(palindromes)
# Output
['anna', 'lagerregal', '12321']
Der Code funktioniert so:
- Wir iterieren durch `str_list` und rufen `is_palindrome()` für jeden String auf.
- Wenn `is_palindrome()` `True` zurückgibt, wird der String der `palindromes`-Liste hinzugefügt.
Die Ausgabe zeigt die Liste aller palindromischen Strings in `str_list`.
Überprüfung auf Anagramme in Python-Strings
Eine weitere gängige Interviewfrage ist die Feststellung, ob zwei Strings, `str1` und `str2`, Anagramme sind.
Zwei Strings sind Anagramme, wenn sie genau die gleiche Anzahl an Zeichen enthalten. Ein String kann durch Permutation oder Umordnung der Zeichen des anderen Strings gebildet werden.
Beispiele für Anagramme sind „Name“ – „Amen“, „Lager“ – „Regal“, „Bogen“ – „Gobe“.
Anagrammprüfung mit dem `Counter`-Objekt
Eine einfache Möglichkeit ist es, die Häufigkeit jedes Zeichens in beiden Strings zu zählen und zu vergleichen, ob die Zählungen gleich sind.
Das `Counter`-Objekt aus dem Modul `itertools` vereinfacht dies. Counter gibt ein Python-Dictionary zurück, in dem die Zeichen als Schlüssel und die entsprechenden Zählungen als Werte dienen.
Betrachten wir die Strings „ame“ und „ema“.
str1 = "ame"
str2 = "ema"
Hier sind `c1` und `c2` `Counter`-Objekte mit den Zeichenzählungen der Strings `str1` bzw. `str2`.
from collections import Counter
c1 = Counter(str1)
c2 = Counter(str2)
print(c1)
print(c2)
c1 == c2
# Output
Counter({'a': 1, 'm': 1, 'e': 1})
Counter({'e': 1, 'm': 1, 'a': 1})
True
`c1 == c2` gibt `True` zurück, da `str1` und `str2` Anagramme sind.
Aufbauend darauf definieren wir `are_anagrams()` mit zwei Parametern, `word1` und `word2`. Wir prüfen, ob `Counter(word1) == Counter(word2)`.
def are_anagrams(word1, word2):
if Counter(word1) == Counter(word2):
return True
else:
return False
▶️ Rufen wir `are_anagrams()` mit `str1` und `str2` auf. Da die Strings Anagramme sind, gibt die Funktion `True` zurück.
are_anagrams(str1, str2)
# Output
True
Anagrammprüfung durch Sortieren der Strings
Eine weitere Methode ist die Sortierung der Strings. Wenn zwei Strings Anagramme sind, sind ihre sortierten Kopien identisch.
Wir können also prüfen, ob die sortierte Version von `str1` identisch mit der sortierten Version von `str2` ist. Wenn sie gleich sind, sind die Strings Anagramme, ansonsten nicht.
Die Funktion `are_anagrams()` mit Sortierung:
def are_anagrams(word1, word2):
if sorted(word1) == sorted(word2):
return True
else:
return False
Beispiele für Funktionsaufrufe:
- „bogen“ und „goben“ sind Anagramme, die Funktion gibt `True` zurück.
- „hallo“ und „halloa“ sind keine Anagramme, die Funktion gibt `False` zurück.
are_anagrams("goben","bogen")
# Output
True
are_anagrams("hallo","halloa")
# Output
False
Überprüfung auf Titelformat in Python-Strings
Hier ist die letzte Aufgabe dieses Tutorials.
Problemstellung: Gegeben sei ein String, der den Namen einer Person mit Vor- und Nachnamen darstellt. Wir müssen überprüfen, ob der erste Buchstabe des Vor- und Nachnamens großgeschrieben ist.
Diese Art der Groß- und Kleinschreibung, bei der der erste Buchstabe jedes Wortes großgeschrieben wird, wird als Titelformat bezeichnet.
Wir müssen überprüfen, ob der Name im Titelformat geschrieben ist:
- Wenn ja, geben wir eine Meldung aus, dass die Formatierung korrekt ist.
- Andernfalls geben wir eine Kopie des Strings im Titelformat zurück.
- Python bietet die String-Methode `istitle()`, die überprüft, ob ein String im Titelformat vorliegt.
`
- Die String-Methode `title()` gibt eine Kopie des Strings im Titelformat zurück.
Wir können diese Methoden zur Lösung des Problems nutzen.
Definieren wir die Funktion `check_titlecase()`, die `name` als Argument akzeptiert.
- Mit `isttitle()` prüfen wir, ob der Eingabestring im Titelformat vorliegt.
- Wenn `True`, geben wir eine Meldung aus, dass der String bereits im Titelformat ist.
- Andernfalls rufen wir `title()` auf und geben eine Kopie des Strings im Titelformat zurück.
Die folgende Funktion `check_titlecase()` implementiert diese Logik.
def check_titlecase(name):
if name.istitle():
print(f"'{name}' ist bereits im Titelformat.")
else:
return name.title()
Rufen wir die Methode `check_titlecase()` auf.
check_titlecase("jane smith")
# Output
Jane Smith
Die Ausgabe zeigt, dass der String „jane smith“ jetzt im Titelformat vorliegt.
▶️ Ein weiteres Beispiel.
check_titlecase("agatha christie")
# Output
Agatha Christie
Rufen wir die Funktion mit einem String im Titelformat auf.
check_titlecase("Grace Hopper")
# Output
'Grace Hopper' ist bereits im Titelformat.
Die Meldung bestätigt, dass der String bereits im Titelformat ist, die Funktion arbeitet wie erwartet.
Fazit 👩🏫
Fassen wir die bisherigen Themen zusammen:
- Um zu prüfen, ob ein String ein Palindrom ist, prüfen wir, ob der String und seine umgekehrte Version identisch sind. Dafür können wir String-Slicing oder die `reversed()`-Funktion nutzen.
- Um zu prüfen, ob zwei Strings Anagramme sind, prüfen wir, ob ihre sortierten Kopien identisch sind. Die Sortierung erfolgt über die Funktion `sorted()`.
- Um zu prüfen, ob ein Name im Titelformat vorliegt, verwenden wir die Methode `.isttitle()` für die Prüfung und `.title()` für die Umwandlung in das Titelformat.
Ich hoffe, dieses Tutorial zu Python-Strings hat dir gefallen. Als Nächstes könntest du dich mit List Comprehensions oder dem Ungleichheitsoperator in Python beschäftigen.
Viel Spaß beim Lernen und Programmieren!🎉