Comment vérifier si une chaîne de caractères est un palindrome en Python

Introduction

Dans ce labo, vous apprendrez à vérifier si une chaîne de caractères est un palindrome en Python. Un palindrome est une séquence de caractères qui se lit de la même manière de l'avant vers l'arrière et de l'arrière vers l'avant, comme "madam" ou "racecar".

Ce labo vous guide dans la création d'un script Python qui définit une fonction is_palindrome pour identifier les palindromes. Cela implique de traiter le texte d'entrée en le convertissant en minuscules et en supprimant les espaces, puis de comparer le texte traité avec sa version inversée. Vous apprendrez également à tester la fonction avec des mots d'exemple.

Définir les palindromes

Dans cette étape, nous allons explorer le concept de palindromes et comment les identifier à l'aide de Python. Un palindrome est un mot, une phrase, un nombre ou toute autre séquence de caractères qui se lit de la même manière de l'avant vers l'arrière et de l'arrière vers l'avant. Des exemples incluent "madam", "racecar" et "level".

Pour commencer, créons un script Python pour définir ce qu'est un palindrome.

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

Vous pouvez créer un nouveau fichier en cliquant avec le bouton droit dans le panneau de l'explorateur (généralement sur le côté gauche) et en sélectionnant "New File". Assurez-vous d'enregistrer le fichier sous le nom palindrome.py dans le répertoire ~/project.
Ajoutez le code Python suivant au fichier palindrome.py :
```
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")
```
Analysons ce code :
- def is_palindrome(text): : Cette ligne définit une fonction nommée is_palindrome qui prend une chaîne de caractères text en entrée.
- processed_text = ''.join(text.lower().split()) : Cette ligne prépare le texte d'entrée pour la vérification de palindrome. Elle convertit d'abord le texte en minuscules à l'aide de .lower(), puis supprime tous les espaces en utilisant .split() pour diviser la chaîne en une liste de mots, et ''.join() pour recombiner les mots en une seule chaîne sans espaces.
- return processed_text == processed_text[::-1] : Cette ligne compare le texte traité avec sa version inversée. processed_text[::-1] crée une copie inversée de la chaîne. Si le texte traité est identique à sa version inversée, la fonction retourne True (c'est un palindrome) ; sinon, elle retourne False.
- Les lignes après la définition de la fonction sont des exemples d'utilisation. Elle appelle la fonction is_palindrome avec le mot "madam" et affiche si c'est un palindrome ou non.
Maintenant, exécutons le script. Ouvrez un terminal dans le WebIDE. Vous trouverez généralement un onglet de terminal en bas de l'interface VS Code, ou vous pouvez en ouvrir un nouveau via le menu : Terminal -> New Terminal.
Dans le terminal, accédez au répertoire ~/project (si vous n'y êtes pas déjà) :
```
cd ~/project
```
Exécutez le script Python :
```
python palindrome.py
```
Vous devriez voir la sortie suivante :
```
'madam' is a palindrome
```
Cela confirme que notre script identifie correctement "madam" comme un palindrome.

Inverser et comparer

Dans cette étape, nous allons approfondir le fonctionnement de la fonction is_palindrome en inversant explicitement la chaîne de caractères d'entrée, puis en la comparant à l'original. Cela vous donnera une compréhension plus claire du processus d'identification des palindromes.

Ouvrez le fichier palindrome.py dans l'éditeur VS Code. C'est le même fichier que vous avez créé à l'étape précédente.
Modifiez la fonction is_palindrome dans le fichier palindrome.py pour inverser explicitement la chaîne de caractères :
```
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")
```
Voici ce qui a changé :
- reversed_text = processed_text[::-1] : Cette ligne crée une copie inversée de la chaîne processed_text et l'assigne à la variable reversed_text.
- return processed_text == reversed_text : Cette ligne compare maintenant le texte traité original avec le texte explicitement inversé.
- Un deuxième exemple avec le mot "hello" a été ajouté pour démontrer un mot qui n'est pas un palindrome.
Enregistrez les modifications apportées au fichier palindrome.py.
Exécutez à nouveau le script dans le terminal :
```
python palindrome.py
```
Vous devriez maintenant voir la sortie suivante :
```
'madam' is a palindrome
'hello' is not a palindrome
```
Cette sortie confirme que le script identifie correctement à la fois les palindromes et les non-palindromes. En inversant explicitement la chaîne de caractères, nous avons rendu la logique de la fonction is_palindrome plus transparente.

Ignorer la casse et les espaces

Dans cette étape, nous allons améliorer notre fonction is_palindrome pour gérer les phrases qui sont des palindromes mais qui contiennent des espaces et des lettres en majuscules et minuscules. Par exemple, "A man, a plan, a canal: Panama" est un palindrome si nous ignorons les espaces, la ponctuation et la casse.

Ouvrez le fichier palindrome.py dans l'éditeur VS Code.
Modifiez la fonction is_palindrome dans le fichier palindrome.py pour ignorer la casse et les espaces :
```
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")
```
Analysons les modifications :
- import re : Cette ligne importe le module re, qui fournit des opérations de expressions régulières.
- processed_text = re.sub(r'[^a-zA-Z]', '', text).lower() : Cette ligne utilise maintenant une expression régulière pour supprimer tous les caractères qui ne sont pas des lettres (a-z, A-Z) du texte d'entrée. re.sub(r'[^a-zA-Z]', '', text) remplace tous les caractères non-lettres par une chaîne vide, les supprimant ainsi. Ensuite, .lower() convertit la chaîne résultante en minuscules.
- Nous avons ajouté des exemples d'utilisation avec "A man, a plan, a canal: Panama", "Racecar" et "hello" pour tester la fonction mise à jour.
Enregistrez les modifications apportées au fichier palindrome.py.
Exécutez à nouveau le script dans le terminal :
```
python palindrome.py
```
Vous devriez maintenant voir la sortie suivante :
```
'A man, a plan, a canal: Panama' is a palindrome
'Racecar' is a palindrome
'hello' is not a palindrome
```
Cette sortie confirme que le script identifie maintenant correctement les palindromes même avec des espaces, de la ponctuation et des lettres en majuscules et minuscules. L'expression régulière nettoie efficacement le texte d'entrée, permettant une détection précise des palindromes.

Résumé

Dans ce laboratoire (lab), nous avons commencé par explorer le concept de palindromes, qui sont des chaînes de caractères qui se lisent de la même manière de l'avant vers l'arrière et de l'arrière vers l'avant. Nous avons ensuite créé un script Python nommé palindrome.py contenant une fonction is_palindrome(text) pour identifier les palindromes.

La fonction is_palindrome prétraite d'abord le texte d'entrée en le convertissant en minuscules et en supprimant les espaces. Elle compare ensuite le texte traité avec sa version inversée pour déterminer s'il s'agit d'un palindrome, renvoyant True si c'est le cas et False sinon. Le script inclut également des exemples d'utilisation montrant comment appeler la fonction et afficher le résultat.