Comment vérifier si une liste est un palindrome en Python

Introduction

Dans ce labo, vous apprendrez à déterminer si une liste est un palindrome en Python. Un palindrome est une séquence qui se lit de la même manière de gauche à droite et de droite à gauche. Ce labo vous guide dans la création d'un script Python pour identifier les palindromes de liste.

Vous allez explorer deux méthodes : comparer une liste avec sa version inversée en utilisant le slicing, et inverser explicitement la liste pour la comparer. Le labo fournit des exemples de code et des instructions sur la façon d'exécuter le script et d'interpréter la sortie, montrant si les listes données sont des palindromes ou non.

Comprendre les palindromes de listes

Dans cette étape, vous allez apprendre ce qu'est un palindrome de liste et comment les identifier en Python. Un palindrome est une séquence qui se lit de la même manière de gauche à droite et de droite à gauche. Par exemple, le mot "madam" est un palindrome. Dans le contexte des listes, un palindrome de liste est une liste dont les éléments sont les mêmes lorsqu'on les lit du début à la fin ou de la fin au début.

Commençons par créer un script Python pour explorer les palindromes de liste.

Ouvrez votre éditeur VS Code.
Créez un nouveau fichier nommé palindrome.py dans le répertoire ~/project.
```
touch ~/project/palindrome.py
```
Ouvrez le fichier palindrome.py dans l'éditeur.

Maintenant, ajoutons un peu de code au fichier palindrome.py pour comprendre comment vérifier si une liste est un palindrome.

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

## 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)}")

Dans ce code :

Nous définissons une fonction is_palindrome(lst) qui prend une liste lst en entrée.
À l'intérieur de la fonction, nous comparons la liste avec sa version inversée en utilisant le slicing lst[::-1].
La fonction retourne True si la liste est un palindrome et False sinon.
Nous créons deux listes d'exemple, list1 qui est un palindrome et list2 qui ne l'est pas.
Nous utilisons la fonction print() pour afficher si chaque liste est un palindrome ou non.

Pour exécuter le script, exécutez la commande suivante dans le terminal :

python ~/project/palindrome.py

Vous devriez voir la sortie suivante :

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

Cette sortie confirme que list1 est un palindrome et que list2 ne l'est pas.

Comparer avec une liste inversée

Dans cette étape, vous allez explorer une autre méthode pour vérifier si une liste est un palindrome en inversant explicitement la liste et en la comparant avec la liste originale. Cette approche offre une compréhension plus détaillée de la vérification des palindromes.

Modifions le fichier palindrome.py que vous avez créé à l'étape précédente.

Ouvrez le fichier palindrome.py dans votre éditeur VS Code.
Modifiez le contenu du fichier palindrome.py comme suit :

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)}")

Dans ce code modifié :

À l'intérieur de la fonction is_palindrome(lst), nous créons une copie inversée de la liste d'entrée lst en utilisant le slicing lst[::-1] et nous la stockons dans la variable reversed_lst.
Nous comparons ensuite la liste originale lst avec la liste inversée reversed_lst en utilisant l'opérateur d'égalité ==.
La fonction retourne True si la liste originale est égale à la liste inversée (c'est-à-dire si c'est un palindrome) et False sinon.

Pour exécuter le script, exécutez la commande suivante dans le terminal :

python ~/project/palindrome.py

Vous devriez voir la même sortie que dans l'étape précédente :

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

Cette sortie confirme que list1 est un palindrome et que list2 ne l'est pas, en utilisant la méthode d'inversion explicite. Cette approche rend la logique plus explicite et plus facile à comprendre.

Utiliser le découpage pour l'inversion

Dans cette étape, vous allez vous concentrer spécifiquement sur la manière dont le slicing (tranchage) est utilisé pour inverser une liste en Python. Le slicing est une fonctionnalité puissante qui vous permet d'extraire des parties d'une liste, et il peut également être utilisé pour créer une copie inversée de la liste.

Revoyons le fichier palindrome.py et examinons plus en détail la technique de slicing.

Ouvrez le fichier palindrome.py dans votre éditeur VS Code.
Assurez-vous que le contenu du fichier palindrome.py est le suivant :

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)}")

La partie clé de ce code est lst[::-1]. Il s'agit d'une opération de slicing qui crée une copie inversée de la liste. Décortiquons-la :

lst[:] créerait une copie de l'ensemble de la liste.
lst[start:end] créerait une tranche de l'index start à end - 1.
lst[start:end:step] vous permet de spécifier un step (pas). Un pas de -1 signifie d'itérer en arrière dans la liste.
En omettant start et end et en utilisant un pas de -1 (c'est-à-dire lst[::-1]), vous créez une copie inversée de l'ensemble de la liste.

Pour illustrer cela plus en détail, ajoutons quelques instructions d'impression pour voir l'effet du slicing :

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)}")

Maintenant, exécutez le script à nouveau :

python ~/project/palindrome.py

Vous verrez les listes originales et inversées affichées avant le résultat de la vérification du palindrome :

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

Cela démontre comment le slicing avec [::-1] inverse efficacement la liste, qui est ensuite utilisée pour déterminer si la liste originale est un palindrome.

Résumé

Dans ce laboratoire, vous avez appris à identifier les palindromes de listes en Python, c'est-à-dire les listes qui se lisent de la même manière de gauche à droite et de droite à gauche. Vous avez créé un script palindrome.py contenant une fonction is_palindrome(lst) qui utilise le slicing (lst[::-1]) pour inverser efficacement une liste et la comparer à l'originale, renvoyant True si c'est un palindrome et False sinon.

Le script a été testé avec deux listes d'exemple, list1 (un palindrome) et list2 (pas un palindrome), et la sortie a confirmé la capacité de la fonction à identifier correctement les palindromes. Le laboratoire a également introduit le concept d'inversion explicite de la liste pour la comparaison, bien que le contenu fourni ait été tronqué.