Aller au contenu principal

Les expressions régulières en Python

Les expressions régulières (ou regex) permettent de rechercher, valider ou manipuler facilement des chaînes de caractères. En Python, le module re est utilisé pour travailler avec les regex.

Pourquoi utiliser des expressions régulières?​

Sans regex, vérifier si un texte respecte un certain format peut être fastidieux :

# Exemple : valider un courriel simple sans regex
email = "jean-dupont@gmail.com"
if (
    "@" in email and
    email.count("@") == 1 and
    "." in email.split("@")[1] and
    len(email.split("@")[0]) > 0 and
    len(email.split("@")[1].split(".")[0]) > 0 and
    len(email.split("@")[1].split(".")[-1]) > 1 and
    "-" in email.split("@")[0]
):
    print("Courriel valide")
else:
    print("Courriel invalide")

Cet exemple montre que le code devient vite complexe et difficile à maintenir dès que l'on souhaite vérifier plusieurs contraintes (présence d'un tiret, d'un point, longueur minimale, etc.).

Avec des regex, on simplifie grandement ces tâches complexes. En plus, le module re est inclus dans Python, aucune installation n’est nécessaire :

Les bases : rechercher une chaîne simple​

re.search() permet de rechercher une expression simple dans une chaîne :

import re

texte = "Le soleil brille"
if re.search("soleil", texte):
    print("Trouvé !")
else:
    print("Non trouvé.")

La syntaxe des Regex​

Une expression régulière (regex) est une chaîne de caractères qui décrit un motif à rechercher dans un texte. Elle combine des caractères "normaux" (lettres, chiffres) et des caractères spéciaux qui servent à définir des règles de recherche très précises.

Voici les principaux éléments à connaître :

Caractères spéciaux de base :

  • . : correspond à n'importe quel caractère (sauf retour à la ligne)
  • ^ : début de la chaîne
  • $ : fin de la chaîne
  • + : une ou plusieurs répétitions
  • * : zéro ou plusieurs répétitions
  • ? : zéro ou une répétition
  • {min,max} : nombre précis de répétitions

Classes de caractères :

  • [abc] : un caractère parmi a, b ou c
  • [a-z] : une lettre minuscule
  • [A-Z] : une lettre majuscule
  • [0-9] : un chiffre

Séquences spéciales :

  • \d : un chiffre (équivalent à [0-9])
  • \D : tout sauf un chiffre
  • \w : un caractère alphanumérique (lettre, chiffre ou _)
  • \W : tout sauf un caractère alphanumérique
  • \s : un espace (espace, tabulation, saut de ligne)
  • \S : tout sauf un espace

Remarques :

  • Le caractère \ sert à échapper un caractère spécial si on veut le chercher littéralement (ex : \. pour un point).
  • Les crochets [] définissent une classe de caractères, les parenthèses () servent à regrouper ou capturer des sous-motifs.
  • À l'intérieur des crochets, les caractères spéciaux perdent leur signification (ex : [$+*] correspond à un caractère parmi $, + ou *).

Grâce à ces éléments, on peut construire des motifs très puissants pour valider, extraire ou remplacer des parties de texte. Nous allons maintenant voir quelques exemples pratiques d'utilisation des regex en Python.

Exemples courants​

Vérifier la taille minimale d'une chaîne​

Regex : .{5,} signifie au moins 5 caractères :

import re

texte = "Salut"
if re.match(r".{5,}", texte):
    print("Longueur valide")
else:
    print("Trop court")

Vérifier qu'une chaîne contient uniquement des lettres (a-z, A-Z) sans accents​

Regex : ^[a-zA-Z]+$

import re

texte = "Bonjour"
if re.match(r"^[a-zA-Z]+$", texte):
    print("Uniquement des lettres sans accent")
else:
    print("Caractère invalide trouvé")

Testez avec des accents :

texte = "Café"
if re.match(r"^[a-zA-Z]+$", texte):
    print("Valide")
else:
    print("Invalide : accents ou autres caractères")

Vérifier si une chaîne contient un espace, un tiret ou un point​

Regex : [ -.] signifie espace, tiret ou point :

import re

texte = "Jean-Pierre"
if re.search(r"[ -.]", texte):
    print("Contient un espace, un tiret ou un point")
else:
    print("Ne contient ni espace, ni tiret, ni point")

Valider des courriels simples avec regex​

Par exemple, pour des courriels du style (nom-prenom@domain.extension)

import re

courriel = "jean-dupont@gmail.com"
if re.match(r"^[a-zA-Z]+-[a-zA-Z]+@[a-zA-Z]+\.[a-zA-Z]+$", courriel):
    print("Courriel simple valide")
else:
    print("Courriel invalide")

Exemple invalide :

courriel = "jean.dupont@gmail.com"
# point invalide ici

Expressions régulières pour mots de passe :​

Vérifier la présence d'un caractère spécial​

Par exemple, vérifier qu'un mot de passe contient au moins un caractère spécial (!@#$%^&*()):

import re

mot_de_passe = "Abcdef1!"

regex_special = r"[!@#$%^&*()]"
if re.search(regex_special, mot_de_passe):
    print("Mot de passe contient un caractère spécial.")
else:
    print("Mot de passe manque un caractère spécial.")

Ainsi, ce mot de passe est valide :

mot_de_passe = "Password123"

Valider un mot de passe robuste​

Pour vérifier qu'il contient obligatoirement au moins :

  • une lettre majuscule ([A-Z])
  • une lettre minuscule ([a-z])
  • un chiffre ([0-9])
  • un caractère spécial ([!@#$%^&*()])
  • minimum 8 caractères

Regex avancée avec lookahead :

import re

regex_complet = r"^(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])(?=.*[!@#$%^&*()]).{8,}$"

mot_de_passe = "Abc123!@"
if re.match(regex_complet, mot_de_passe):
    print("Mot de passe robuste !")
else:
    print("Mot de passe non conforme")

ou simplement une série de conditions :

import re
def valider_mot_de_passe(mot_de_passe):
    if (len(mot_de_passe) >= 8 and
        re.search(r"[A-Z]", mot_de_passe) and
        re.search(r"[a-z]", mot_de_passe) and
        re.search(r"[0-9]", mot_de_passe) and
        re.search(r"[!@#$%^&*()]", mot_de_passe)):
        return True
    return False

Ressources complémentaires​