So prüfen Sie, ob eine Zeichenkette in Python ein Palindrom ist

Einführung

In diesem Lab lernen Sie, wie Sie in Python prüfen können, ob eine Zeichenkette ein Palindrom ist. Ein Palindrom ist eine Zeichenfolge, die sowohl vorwärts als auch rückwärts gelesen gleich ist, wie beispielsweise "madam" oder "racecar".

Das Lab führt Sie durch die Erstellung eines Python-Skripts, das eine Funktion is_palindrome definiert, um Palindrome zu identifizieren. Dies umfasst die Verarbeitung des Eingabetexts, indem er in Kleinbuchstaben umgewandelt und Leerzeichen entfernt werden, und anschließend das Vergleichen des verarbeiteten Texts mit seiner umgekehrten Version. Sie werden auch lernen, wie Sie die Funktion mit Beispielwörtern testen können.

Palindrome definieren

In diesem Schritt werden wir das Konzept von Palindromen untersuchen und lernen, wie man sie mit Python identifiziert. Ein Palindrom ist ein Wort, eine Phrase, eine Zahl oder eine andere Zeichenfolge, die sowohl vorwärts als auch rückwärts gelesen gleich ist. Beispiele sind "madam", "racecar" und "level".

Um zu beginnen, erstellen wir ein Python-Skript, um zu definieren, was ein Palindrom ist.

Öffnen Sie den VS Code-Editor in der LabEx-Umgebung.
Erstellen Sie eine neue Datei mit dem Namen palindrome.py im Verzeichnis ~/project.

Sie können eine neue Datei erstellen, indem Sie mit der rechten Maustaste im Explorer-Bereich (normalerweise auf der linken Seite) klicken und "New File" auswählen. Stellen Sie sicher, dass Sie die Datei als palindrome.py im Verzeichnis ~/project speichern.
Fügen Sie den folgenden Python-Code zur Datei palindrome.py hinzu:
```
def is_palindrome(text):
    processed_text = ''.join(text.lower().split())
    return processed_text == processed_text[::-1]

## Example usage
word = "madam"
if is_palindrome(word):
    print(f"'{word}' is a palindrome")
else:
    print(f"'{word}' is not a palindrome")
```
Lassen Sie uns diesen Code analysieren:
- def is_palindrome(text):: Diese Zeile definiert eine Funktion namens is_palindrome, die eine Zeichenkette text als Eingabe nimmt.
- processed_text = ''.join(text.lower().split()): Diese Zeile bereitet den Eingabetext für die Palindromprüfung vor. Sie wandelt zunächst den Text in Kleinbuchstaben um, indem sie .lower() verwendet, und entfernt dann alle Leerzeichen, indem sie .split() verwendet, um die Zeichenkette in eine Liste von Wörtern aufzuteilen, und ''.join(), um die Wörter wieder zu einer einzigen Zeichenkette ohne Leerzeichen zusammenzufügen.
- return processed_text == processed_text[::-1]: Diese Zeile vergleicht den verarbeiteten Text mit seiner Umkehrung. processed_text[::-1] erstellt eine umgekehrte Kopie der Zeichenkette. Wenn der verarbeitete Text gleich seiner Umkehrung ist, gibt die Funktion True zurück (es handelt sich um ein Palindrom); andernfalls gibt sie False zurück.
- Die Zeilen nach der Funktionsdefinition sind ein Beispiel für die Verwendung. Sie ruft die Funktion is_palindrome mit dem Wort "madam" auf und gibt aus, ob es sich um ein Palindrom handelt oder nicht.
Jetzt lassen Sie uns das Skript ausführen. Öffnen Sie ein Terminal im WebIDE. Normalerweise finden Sie einen Terminal-Tab unten in der VS Code-Oberfläche, oder Sie können ein neues Terminal über das Menü öffnen: Terminal -> New Terminal.
Navigieren Sie im Terminal zum Verzeichnis ~/project (falls Sie nicht bereits dort sind):
```
cd ~/project
```
Führen Sie das Python-Skript aus:
```
python palindrome.py
```
Sie sollten die folgende Ausgabe sehen:
```
'madam' is a palindrome
```
Dies bestätigt, dass unser Skript "madam" korrekt als Palindrom identifiziert.

Umkehren und vergleichen

In diesem Schritt werden wir genauer untersuchen, wie die Funktion is_palindrome funktioniert, indem wir die Eingabezeichenkette explizit umkehren und sie dann mit der ursprünglichen Zeichenkette vergleichen. Dies gibt Ihnen ein besseres Verständnis des Palindrom-Identifizierungsprozesses.

Öffnen Sie die Datei palindrome.py im VS Code-Editor. Dies ist dieselbe Datei, die Sie im vorherigen Schritt erstellt haben.
Modifizieren Sie die Funktion is_palindrome in palindrome.py, um die Zeichenkette explizit umzukehren:
```
def is_palindrome(text):
    processed_text = ''.join(text.lower().split())
    reversed_text = processed_text[::-1]  ## Explicitly reverse the string
    return processed_text == reversed_text

## Example usage
word = "madam"
if is_palindrome(word):
    print(f"'{word}' is a palindrome")
else:
    print(f"'{word}' is not a palindrome")

word2 = "hello"
if is_palindrome(word2):
    print(f"'{word2}' is a palindrome")
else:
    print(f"'{word2}' is not a palindrome")
```
Hier ist, was sich geändert hat:
- reversed_text = processed_text[::-1]: Diese Zeile erstellt eine umgekehrte Kopie der Zeichenkette processed_text und weist sie der Variablen reversed_text zu.
- return processed_text == reversed_text: Diese Zeile vergleicht jetzt den ursprünglichen verarbeiteten Text mit dem explizit umgekehrten Text.
- Es wurde ein zweites Beispiel mit dem Wort "hello" hinzugefügt, um ein Nicht-Palindrom zu demonstrieren.
Speichern Sie die Änderungen an palindrome.py.
Führen Sie das Skript erneut im Terminal aus:
```
python palindrome.py
```
Sie sollten jetzt die folgende Ausgabe sehen:
```
'madam' is a palindrome
'hello' is not a palindrome
```
Diese Ausgabe bestätigt, dass das Skript sowohl Palindrome als auch Nicht-Palindrome korrekt identifiziert. Durch die explizite Umkehrung der Zeichenkette haben wir die Logik der Funktion is_palindrome transparenter gemacht.

Groß- und Kleinschreibung sowie Leerzeichen ignorieren

In diesem Schritt verbessern wir unsere is_palindrome-Funktion, um Phrasen zu verarbeiten, die Palindrome sind, aber Leerzeichen und gemischte Groß- und Kleinschreibung enthalten. Beispielsweise ist "A man, a plan, a canal: Panama" ein Palindrom, wenn wir Leerzeichen, Satzzeichen und die Groß- und Kleinschreibung ignorieren.

Öffnen Sie die Datei palindrome.py im VS Code-Editor.
Modifizieren Sie die is_palindrome-Funktion in palindrome.py, um Groß- und Kleinschreibung sowie Leerzeichen zu ignorieren:
```
import re

def is_palindrome(text):
    processed_text = re.sub(r'[^a-zA-Z]', '', text).lower()
    reversed_text = processed_text[::-1]
    return processed_text == reversed_text

## Example usage
word1 = "A man, a plan, a canal: Panama"
if is_palindrome(word1):
    print(f"'{word1}' is a palindrome")
else:
    print(f"'{word1}' is not a palindrome")

word2 = "Racecar"
if is_palindrome(word2):
    print(f"'{word2}' is a palindrome")
else:
    print(f"'{word2}' is not a palindrome")

word3 = "hello"
if is_palindrome(word3):
    print(f"'{word3}' is a palindrome")
else:
    print(f"'{word3}' is not a palindrome")
```
Lassen Sie uns die Änderungen analysieren:
- import re: Diese Zeile importiert das re-Modul, das Operationen mit regulären Ausdrücken (regular expressions) bereitstellt.
- processed_text = re.sub(r'[^a-zA-Z]', '', text).lower(): Diese Zeile verwendet jetzt einen regulären Ausdruck, um alle Zeichen, die keine Buchstaben (a-z, A-Z) sind, aus dem Eingabetext zu entfernen. re.sub(r'[^a-zA-Z]', '', text) ersetzt alle Nicht-Buchstaben-Zeichen durch eine leere Zeichenkette und entfernt sie somit effektiv. Dann wandelt .lower() die resultierende Zeichenkette in Kleinbuchstaben um.
- Wir haben Beispielverwendungen mit "A man, a plan, a canal: Panama", "Racecar" und "hello" hinzugefügt, um die aktualisierte Funktion zu testen.
Speichern Sie die Änderungen an palindrome.py.
Führen Sie das Skript erneut im Terminal aus:
```
python palindrome.py
```
Sie sollten jetzt die folgende Ausgabe sehen:
```
'A man, a plan, a canal: Panama' is a palindrome
'Racecar' is a palindrome
'hello' is not a palindrome
```
Diese Ausgabe bestätigt, dass das Skript jetzt Palindrome auch mit Leerzeichen, Satzzeichen und gemischter Groß- und Kleinschreibung korrekt identifiziert. Der reguläre Ausdruck bereinigt den Eingabetext effektiv und ermöglicht so eine genaue Palindromerkennung.

Zusammenfassung

In diesem Lab (Praktikum) haben wir zunächst das Konzept der Palindrome untersucht. Palindrome sind Zeichenketten, die vorwärts und rückwärts gleich lauten. Anschließend haben wir ein Python-Skript namens palindrome.py erstellt, das eine Funktion is_palindrome(text) enthält, um Palindrome zu identifizieren.

Die Funktion is_palindrome verarbeitet zunächst den Eingabetext, indem sie ihn in Kleinbuchstaben umwandelt und Leerzeichen entfernt. Anschließend vergleicht sie den verarbeiteten Text mit seiner umgekehrten Version, um zu bestimmen, ob es sich um ein Palindrom handelt. Sie gibt True zurück, wenn es ein Palindrom ist, und False sonst. Das Skript enthält auch Beispielverwendungen, die zeigen, wie man die Funktion aufruft und das Ergebnis ausgibt.