Python-Programme für String-Operationen

In diesem Lernprogramm schreiben Sie Python-Programme, um häufig gestellte Fragen zu Zeichenfolgenoperationen zu lösen.

Sie erfahren, wie Sie überprüfen, ob Python-Strings Palindrome oder Anagramme sind und sich im Titel befinden.

Python-Strings: Ein kurzer Überblick

In Python sind Zeichenfolgen leistungsstarke integrierte Datentypen. Sie können eine Folge von Zeichen speichern.

Indizierung in Python-Strings: Wie alle Python-Iterables sind auch Strings nullindiziert. Die gültigen Indizes für einen String der Länge N sind also 0, 1, 2 bis N – 1.

Python unterstützt auch die negative Indizierung, um auf Elemente vom Ende der Zeichenfolge zuzugreifen. -1 ist also der Index des letzten Zeichens in der Zeichenfolge, -2 ist der Index des vorletzten Zeichens in der Zeichenfolge und so weiter.

Unveränderlichkeit von Python-Strings: Darüber hinaus sind Strings in Python unveränderlich, sodass Sie sie nicht direkt ändern können. Sie können jedoch mehrere String-Methoden darauf aufrufen und Kopien von Strings mit dem gewünschten Ergebnis erhalten.

Nachdem wir nun die Grundlagen von Python-Strings überprüft haben, wollen wir damit fortfahren, einige einfache, aber interessante Probleme zu lösen.

Lasst uns beginnen.

Überprüfen Sie, ob ein Python-String ein Palindrom ist

Problem: Überprüfen Sie bei einem gegebenen Python-String, ob es sich um ein Palindrom handelt oder nicht.

Wenn ja, True zurückgeben; Andernfalls geben Sie False zurück.

Unser erstes Problem besteht also darin, zu überprüfen, ob eine bestimmte Zeichenfolge ein Palindrom ist oder nicht.

Ein Palindrom ist eine Zeichenfolge, die sowohl von links nach rechts als auch von rechts nach links gelesen wird. Lassen Sie uns ein paar Beispiele auflisten: racecar, refer, level, madam, radar und so weiter.

Hier sind die Schritte, um dieses Problem zu lösen:

• Erhalten Sie eine umgekehrte Kopie der Zeichenfolge und speichern Sie sie bei Bedarf in einer anderen Variablen.
• Vergleichen Sie die Werte der ursprünglichen Zeichenfolge und der umgekehrten Zeichenfolge.
• Wenn sie gleich sind, ist die Zeichenfolge ein Palindrom. Geben Sie also True zurück und hören Sie auf.
• Wenn die ursprüngliche und die umgekehrte Kopie nicht gleich sind, ist die Zeichenfolge kein Palindrom. Also sollten wir False zurückgeben.

Die Schlüsseloperation besteht darin, eine umgekehrte Kopie der Zeichenfolge zu erhalten. In Python gibt es verschiedene Möglichkeiten, dies zu tun.

Wir werden jedoch zwei Ansätze durchgehen:

• Verwenden von String-Slicing
• Verwenden der reversed()-Funktion und der join()-Methode

So kehren Sie einen Python-String mit Slicing um

Die Syntax [start: stop: step] gibt einen Teil des Strings vom Start bis zum Stopp (ohne Stopp) mit der Schrittweite step zurück.

• Wenn Sie start weglassen, beginnt das Slice am Anfang der Zeichenfolge.
• Wenn Sie den Stoppindex nicht angeben, erstreckt sich der Slice bis zum Ende der Zeichenfolge.
• Und negative Werte von step können verwendet werden, um Slices zurückzugeben, die am Ende der Zeichenfolge beginnen.

Also [::-1] gibt eine umgekehrte Kopie der Zeichenfolge zurück.

Die folgende Codezelle enthält die Definition der Funktion is_palindrome().

Es nimmt einen String als Argument und gibt True oder False zurück, je nachdem, ob es sich um ein Palindrom handelt oder nicht.

Hier haben wir String Slicing verwendet, um eine umgekehrte Kopie des Strings zu erhalten.

def is_palindrome(this_str):
  rev_str = this_str[::-1]
  if (this_str == rev_str):
    return True
  else:
    return False

▶️ Nachdem wir die Funktion definiert haben, können wir fortfahren und mit einer beliebigen gültigen Zeichenfolge als Argument aufrufen.

is_palindrome("racecar")
True

In der obigen Codezelle ist Rennwagen ein Palindrom. Die Funktion is_palindrome() gibt also wie erwartet True zurück.

Versuchen Sie nun, die Funktion mit einem beliebigen String aufzurufen, der kein Palindrom ist, z. B. river.

is_palindrome("river")
False

Und wie Sie sehen können, gibt es False zurück, was richtig ist. ✅

Wie man einen Python-String mit reversed() und join() umkehrt

In Python können Sie die Methode join() zusammen mit der Funktion reversed() verwenden, um einen String umzukehren.

• Die Funktion reversed() gibt einen umgekehrten Iterator durch die Zeichen in der Zeichenfolge zurück.
• Die Methode join() kann dann verwendet werden, um diese Zeichen in umgekehrter Reihenfolge zu verbinden.

Mit der obigen Methode können Sie die Funktion is_palindrome() wie in der Codezelle unten umschreiben.

def is_palindrome(this_str):
  rev_str="".join(reversed(this_str))
  if (this_str == rev_str):
    return True
  else:
    return False

Sie können auch die Funktion is_palindrome() innerhalb des Listenverständnisses verwenden, um alle Palindrome aus einer längeren Liste von Zeichenfolgen zu sammeln.

str_list = ["refer","blue","level","12321","dragon"]

palindromes = [string for string in str_list if is_palindrome(string)]
print(palindromes)
# Output
['refer', 'level', '12321']

So funktioniert der obige Code:

• Durchlaufen Sie str_list, rufen Sie is_palindrome() für jeden String auf.
• Wenn is_palindrome() True zurückgibt, fügen Sie die Zeichenfolge der Palindrome-Liste hinzu.

Wie Sie in der obigen Ausgabe sehen können, ist palindromes eine Liste aller palindromischen Zeichenfolgen in str_list.

Überprüfen Sie, ob zwei Python-Strings Anagramme sind

Eine weitere beliebte Frage, auf die Sie möglicherweise in Interviews stoßen, ist, zu überprüfen, ob ein Paar Zeichenfolgen str1 und str2 Anagramme sind oder nicht.

Zwei Zeichenfolgen werden als Anagramme bezeichnet, wenn die Anzahl der Zeichen in den beiden Zeichenfolgen genau gleich ist. Das bedeutet, dass Sie eine der Zeichenfolgen erhalten können, indem Sie die Zeichen in der anderen Zeichenfolge permutieren oder neu anordnen.

Beispiele für Anagramme sind State-Taste, Save-Vase, Elbow-Below und so weiter.

So suchen Sie mit Counter Object in Python nach Anagrammen

Eine einfache und intuitive Möglichkeit besteht darin, die Anzahl der Vorkommen jedes Zeichens in den beiden Zeichenfolgen zu berechnen. Und dann prüfen, ob die Zählungen gleich sind.

Dies geht umso einfacher mit dem Counter-Objekt aus dem itertools-Modul. Das Zähler Objekt gibt ein Python-Wörterbuch zurück: mit den Zeichen als Schlüssel und den entsprechenden Zählern als Werte.

Betrachten Sie die Zeichenfolgen „save“ und „vase“, wie unten gezeigt.

str1 = "save"
str2 = "vase"

Hier sind c1 und c2 Zählerobjekte, die die Zeichenzählungen der Zeichenfolgen str1 bzw. str2 enthalten.

from collections import Counter
c1 = Counter(str1)
c2 = Counter(str2)
print(c1)
print(c2)
c1 == c2

# Output
Counter({'s': 1, 'a': 1, 'v': 1, 'e': 1})
Counter({'v': 1, 'a': 1, 's': 1, 'e': 1})
True

c1 == c2 gibt True zurück, da str1 und str2 Anagramme sind.

Mit dieser Logik können wir nun fortfahren und die Funktion are_anagrams() mit zwei Parametern word1 und word2 definieren. Im Funktionsrumpf prüfen wir, ob Counter(word1) == Counter(word2).

def are_anagrams(word1, word2):
  if Counter(word1) ==  Counter(word2):
    return True
  else:
    return False

▶️ Rufen Sie zur Überprüfung are_anagrams() mit str1, str2 als Argument auf. Da str1 und str2 Anagramme sind („save“ und „vase“), gibt die Funktion True zurück, was korrekt ist.

are_anagrams(str1, str2)
True

So suchen Sie mit sortierten Kopien von Zeichenfolgen nach Anagrammen

Es gibt eine andere Möglichkeit, dies zu tun.

Wenn zwei Zeichenketten Anagramme sind, dann sind ihre sortierten Kopien gleich.

Wir können also die Funktion are_anagrams() umschreiben, um zu prüfen, ob die sortierte Version von str1 dieselbe ist wie die sortierte Kopie von str2. Wenn sie gleich sind, dann sind die beiden Zeichenketten Anagramme; sonst sind sie es nicht.

Wenn wir die obige Methode verwenden, um die Gleichheit sortierter Kopien zu überprüfen, können wir die Funktion are_anagrams() wie folgt umschreiben.

def are_anagrams(word1, word2):
  if sorted(word1) ==  sorted(word2):
    return True
  else:
    return False

Lassen Sie uns nun einige Funktionsaufrufe durchführen.

• Die Strings „elbow“ und „below“ sind Anagramme und die Funktion are_anagrams() gibt True zurück.
• Und „state“ und „tasted“ sind keine Anagramme, und die Funktion gibt False zurück.

are_anagrams("below","elbow")
True

are_anagrams("state","tasted")
False

Überprüfen Sie, ob ein Python-String in Title Case ist

Hier ist unsere letzte Frage für dieses Tutorial.

Problem: Gegeben sei ein String: der Name einer Person – mit Vor- und Nachname.

Sie müssen prüfen, ob der Anfangsbuchstabe sowohl des Vor- als auch des Nachnamens groß geschrieben wird.

Diese Art der Groß- und Kleinschreibung, bei der der erste Buchstabe jedes Wortes groß geschrieben wird, wird Titelfall genannt.

Sie müssen also prüfen, ob der Name im Titel geschrieben ist:

1. Wenn ja, gib eine Meldung aus, dass die Formatierung in Groß-/Kleinschreibung erfolgt.

2. Anderenfalls gib eine Kopie der Zeichenfolge zurück, die im Titelfall formatiert ist

• Python hat eine eingebaute String-Methode istitle(), die prüft, ob ein String im Title-Case steht.

.isttitle() gibt True zurück, wenn die Zeichenfolge im Titelformat formatiert ist, andernfalls gibt es False zurück.

• Und die String-Methode title() von Python gibt eine Kopie des Strings zurück, der in der Groß-/Kleinschreibung des Titels formatiert ist.

Jetzt können Sie diese beiden Methoden verwenden, um das Problem zu lösen.

Definieren Sie eine Funktion check_titlecase(), die name als Argument akzeptiert.

• Sie können die Methode istitle() für die Eingabezeichenfolge aufrufen, um zu prüfen, ob sie in Groß-/Kleinschreibung formatiert ist.
• Wenn True, können Sie ausgeben, dass die Zeichenfolge bereits in Groß-/Kleinschreibung ist.
• Andernfalls können Sie die title()-Methode aufrufen und eine Kopie der Zeichenfolge im Titelfall zurückgeben.

Die folgende Codezelle zeigt die Definition der Funktion check_titlecase().

def check_titlecase(name):
  if name.istitle():
    print(f"'{name}' is already formatted in title case.")
  else:
    return name.title()

Rufen wir nun die Methode check_titlecase() mit einem Argument auf.

check_titlecase("jane smith")

# Output
Jane Smith

In der obigen Ausgabe können Sie sehen, dass sich die Zeichenfolge „Jane Smith“ jetzt in der Groß-/Kleinschreibung des Titels befindet.

▶️ Nehmen wir ein weiteres Beispiel.

check_titlecase("agatha Christie")

# Output
Agatha Christie

Rufen wir die Funktion dieses Mal mit einem Titel-Case-String auf.

check_titlecase("Grace Hopper")

# Output
'Grace Hopper' is already formatted in title case.

Wir werden benachrichtigt, dass die Zeichenfolge im Titelformat formatiert ist und die Funktion wie erwartet funktioniert.

Fazit 👩‍🏫

Lassen Sie uns nun die Probleme zusammenfassen, die wir bisher besprochen haben.

• Um zu überprüfen, ob eine Zeichenfolge ein Palindrom ist, überprüfen Sie, ob die Zeichenfolge und ihre umgekehrte Version gleich sind. Sie können Stringslicing oder integrierte Methoden verwenden, um Strings umzukehren.
• Um zu überprüfen, ob zwei Zeichenfolgen Anagramme sind, überprüfen Sie, ob ihre sortierten Kopien gleich sind. Und um einen String zu sortieren, verwenden Sie die eingebaute Funktion sorted().
• Um zu überprüfen, ob ein Name im Titel geschrieben ist, verwenden Sie die .isttitle()-Methode zur Überprüfung und die .title()-Methode, um eine Kopie des Strings mit Titel zu erhalten.

Ich hoffe, Ihnen hat dieses Tutorial zu Python-Strings gefallen. Als nächsten Schritt lernen Sie, wie Sie Listenverständnisse in Python verwenden, oder lernen Sie den Ungleichheitsoperator in Python kennen.

Viel Spaß beim Lernen und Programmieren!🎉