So überprüfen Sie, ob eine Liste in Python ein Palindrom ist

Einführung

In diesem Lab lernen Sie, wie Sie in Python feststellen können, ob eine Liste ein Palindrom ist. Ein Palindrom ist eine Sequenz, die vorwärts und rückwärts gleich gelesen wird. Das Lab führt Sie durch die Erstellung eines Python-Skripts zur Identifizierung von Listen-Palindromen.

Sie werden zwei Methoden untersuchen: das Vergleichen einer Liste mit ihrer umgekehrten Version mithilfe von Slicing und das explizite Umkehren der Liste zum Vergleich. Das Lab bietet Codebeispiele und Anweisungen dazu, wie Sie das Skript ausführen und die Ausgabe interpretieren können, um zu zeigen, ob die angegebenen Listen Palindrome sind oder nicht.

Skills Graph

Verständnis von Listen-Palindromen

In diesem Schritt lernen Sie über Listen-Palindrome und wie Sie sie in Python identifizieren können. Ein Palindrom ist eine Sequenz, die vorwärts und rückwärts gleich gelesen wird. Beispielsweise ist das Wort "madam" ein Palindrom. Im Zusammenhang mit Listen ist ein Listen-Palindrom eine Liste, deren Elemente gleich sind, wenn sie von Anfang bis Ende oder von Ende bis Anfang gelesen werden.

Beginnen wir damit, ein Python-Skript zu erstellen, um Listen-Palindrome zu untersuchen.

1. Öffnen Sie Ihren VS Code-Editor.

2. Erstellen Sie eine neue Datei mit dem Namen palindrome.py im Verzeichnis ~/project.

   touch ~/project/palindrome.py

3. Öffnen Sie die Datei palindrome.py im Editor.

Jetzt fügen wir der Datei palindrome.py etwas Code hinzu, um zu verstehen, wie man prüft, ob eine Liste ein Palindrom ist.

def is_palindrome(lst):
    return lst == lst[::-1]

## Beispiel-Listen
list1 = [1, 2, 3, 2, 1]
list2 = [1, 2, 3, 4, 5]

## Prüfen, ob die Listen Palindrome sind
print(f"{list1} ist ein Palindrom: {is_palindrome(list1)}")
print(f"{list2} ist ein Palindrom: {is_palindrome(list2)}")

In diesem Code:

• Wir definieren eine Funktion is_palindrome(lst), die eine Liste lst als Eingabe nimmt.
• Innerhalb der Funktion vergleichen wir die Liste mit ihrer umgekehrten Version mithilfe von Slicing lst[::-1].
• Die Funktion gibt True zurück, wenn die Liste ein Palindrom ist, und False sonst.
• Wir erstellen zwei Beispiel-Listen, list1, die ein Palindrom ist, und list2, die kein Palindrom ist.
• Wir verwenden die Funktion print(), um anzuzeigen, ob jede Liste ein Palindrom ist oder nicht.

Um das Skript auszuführen, führen Sie den folgenden Befehl im Terminal aus:

python ~/project/palindrome.py

Sie sollten die folgende Ausgabe sehen:

[1, 2, 3, 2, 1] ist ein Palindrom: True
[1, 2, 3, 4, 5] ist ein Palindrom: False

Diese Ausgabe bestätigt, dass list1 ein Palindrom ist und list2 kein Palindrom ist.

Vergleich mit umgekehrter Liste

In diesem Schritt werden Sie eine weitere Methode untersuchen, um zu prüfen, ob eine Liste ein Palindrom ist, indem Sie die Liste explizit umkehren und sie mit der ursprünglichen Liste vergleichen. Dieser Ansatz bietet ein detaillierteres Verständnis der Palindromprüfung.

Lassen Sie uns die Datei palindrome.py ändern, die Sie im vorherigen Schritt erstellt haben.

1. Öffnen Sie die Datei palindrome.py in Ihrem VS Code-Editor.

2. Ändern Sie den Inhalt der Datei palindrome.py wie folgt:

def is_palindrome(lst):
    reversed_lst = lst[::-1]
    return lst == reversed_lst

## Beispiel-Listen
list1 = [1, 2, 3, 2, 1]
list2 = [1, 2, 3, 4, 5]

## Prüfen, ob die Listen Palindrome sind
print(f"{list1} ist ein Palindrom: {is_palindrome(list1)}")
print(f"{list2} ist ein Palindrom: {is_palindrome(list2)}")

In diesem geänderten Code:

• Innerhalb der Funktion is_palindrome(lst) erstellen wir eine umgekehrte Kopie der Eingabeliste lst mithilfe von Slicing lst[::-1] und speichern sie in der Variable reversed_lst.
• Anschließend vergleichen wir die ursprüngliche Liste lst mit der umgekehrten Liste reversed_lst mithilfe des Gleichheitsoperators ==.
• Die Funktion gibt True zurück, wenn die ursprüngliche Liste gleich der umgekehrten Liste ist (d. h., es handelt sich um ein Palindrom), und False sonst.

Um das Skript auszuführen, führen Sie den folgenden Befehl im Terminal aus:

python ~/project/palindrome.py

Sie sollten die gleiche Ausgabe wie im vorherigen Schritt sehen:

[1, 2, 3, 2, 1] ist ein Palindrom: True
[1, 2, 3, 4, 5] ist ein Palindrom: False

Diese Ausgabe bestätigt, dass list1 ein Palindrom ist und list2 kein Palindrom ist, indem die Methode der expliziten Umkehrung verwendet wird. Dieser Ansatz macht die Logik deutlicher und leichter verständlich.

Verwendung von Slicing zur Umkehrung

In diesem Schritt werden Sie sich speziell darauf konzentrieren, wie Slicing in Python verwendet wird, um eine Liste umzukehren. Slicing ist ein leistungsfähiges Feature, das es Ihnen ermöglicht, Teile einer Liste zu extrahieren, und es kann auch verwendet werden, um eine umgekehrte Kopie der Liste zu erstellen.

Lassen Sie uns die Datei palindrome.py erneut betrachten und die Slicing-Technik genauer untersuchen.

1. Öffnen Sie die Datei palindrome.py in Ihrem VS Code-Editor.

2. Stellen Sie sicher, dass der Inhalt der Datei palindrome.py wie folgt ist:

def is_palindrome(lst):
    reversed_lst = lst[::-1]
    return lst == reversed_lst

## Example lists
list1 = [1, 2, 3, 2, 1]
list2 = [1, 2, 3, 4, 5]

## Check if the lists are palindromes
print(f"{list1} is a palindrome: {is_palindrome(list1)}")
print(f"{list2} is a palindrome: {is_palindrome(list2)}")

Der Schlüsselteil dieses Codes ist lst[::-1]. Dies ist eine Slicing-Operation, die eine umgekehrte Kopie der Liste erstellt. Lassen Sie uns es aufschlüsseln:

• lst[:] würde eine Kopie der gesamten Liste erstellen.
• lst[start:end] würde einen Schnitt von Index start bis end-1 erstellen.
• lst[start:end:step] ermöglicht es Ihnen, einen Schritt anzugeben. Ein Schritt von -1 bedeutet, rückwärts durch die Liste zu iterieren.
• Indem Sie start und end weglassen und einen Schritt von -1 verwenden (d. h. lst[::-1]), erstellen Sie eine umgekehrte Kopie der gesamten Liste.

Um dies weiter zu veranschaulichen, fügen wir einige Print-Anweisungen hinzu, um die Wirkung des Slicings zu sehen:

def is_palindrome(lst):
    reversed_lst = lst[::-1]
    print(f"Original list: {lst}")
    print(f"Reversed list: {reversed_lst}")
    return lst == reversed_lst

## Example lists
list1 = [1, 2, 3, 2, 1]
list2 = [1, 2, 3, 4, 5]

## Check if the lists are palindromes
print(f"{list1} is a palindrome: {is_palindrome(list1)}")
print(f"{list2} is a palindrome: {is_palindrome(list2)}")

Jetzt führen Sie das Skript erneut aus:

python ~/project/palindrome.py

Sie werden die ursprüngliche und die umgekehrte Liste vor dem Ergebnis der Palindromprüfung sehen:

Original list: [1, 2, 3, 2, 1]
Reversed list: [1, 2, 3, 2, 1]
[1, 2, 3, 2, 1] is a palindrome: True
Original list: [1, 2, 3, 4, 5]
Reversed list: [5, 4, 3, 2, 1]
[1, 2, 3, 4, 5] is a palindrome: False

Dies zeigt, wie Slicing mit [::-1] effektiv die Liste umkehrt, die dann verwendet wird, um zu bestimmen, ob die ursprüngliche Liste ein Palindrom ist.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie in Python Palindromlisten identifizieren können. Palindromlisten sind Listen, die von vorne und von hinten gelesen gleich sind. Sie haben ein Skript namens palindrome.py erstellt, das eine Funktion is_palindrome(lst) enthält. Diese Funktion nutzt Slicing (lst[::-1]), um eine Liste effizient umzukehren und sie mit der ursprünglichen Liste zu vergleichen. Sie gibt True zurück, wenn es sich um ein Palindrom handelt, und False sonst.

Das Skript wurde mit zwei Beispiel-Listen getestet: list1 (ein Palindrom) und list2 (kein Palindrom). Die Ausgabe hat bestätigt, dass die Funktion Palindrome korrekt identifizieren kann. Das Lab hat auch das Konzept der expliziten Umkehrung einer Liste zum Vergleich eingeführt, obwohl der bereitgestellte Inhalt abgeschnitten war.