Le module re (Expressions Régulières) en Python

@joekakone

Joseph Konka @joekakone

03/03/2026 · 12 min

Python ModuleRe Regex ExpressionsRégulières TextMining Validation

Maîtrisez les expressions régulières (Regex) en Python : métacaractères, classes (\d, \w, \s), fonctions search, findall, sub, capture de groupes nommés, compilation et validation de données textuelles.

re

Le module re (Expressions Régulières) en langage Python#

Les expressions régulières (souvent abrégées en Regex pour Regular Expressions) constituent un langage formel ultra-puissant dédié à la détection, à la validation et à l'extraction de motifs dans des chaînes de caractères.

En ingénierie logicielle et en science des données, le module standard re est l'outil indispensable pour : - Valider des formulaires (adresses e-mail, numéros de téléphone, codes postaux). - Nettoyer et standardiser des jeux de données textuels non structurés (Web Scraping). - Extraire des entités nommées (dates, identifiants, adresses IP) depuis des fichiers journaux (logs).

1. La règle d'or : Utiliser des chaînes brutes (Raw Strings r"...")#

En Python, le caractère antislash \ est utilisé pour les séquences d'échappement usuelles (\n pour un saut de ligne, \t pour une tabulation). Or, les expressions régulières utilisent abondamment l'antislash pour définir des métacaractères (\d, \w).

Pour éviter tout conflit d'interprétation, préfixez systématiquement vos motifs Regex de la lettre r :

import re

# Chaîne brute recommandée : l'antislash n'est pas interprété par Python
motif = r"\d{4}-\d{2}-\d{2}"

2. Les métacaractères et classes de caractères#

Symbole Description Exemple Correspondance
. N'importe quel caractère (sauf \n) c.t cat, cot, c#t
^ Début de chaîne ^Bonjour Doit commencer par "Bonjour"
$ Fin de chaîne fin$ Doit se terminer par "fin"
\d Un chiffre décimal [0-9] \d+ 1234
\D Tout caractère qui n'est pas un chiffre \D+ Lettres
\w Un caractère alphanumérique ou tiret bas [a-zA-Z0-9_] \w+ user_42
\W Tout caractère non alphanumérique \W @, !, espace
\s Un espace blanc (espace, tabulation, saut de ligne) \s+ Espaces consécutifs
[] Classe personnalisée de caractères [aeiouy] Une voyelle minuscule
[^] Négation d'une classe [^0-9] Tout sauf un chiffre
| Opérateur OU logique chat|chien "chat" ou "chien"

Les quantificateurs#

  • * : 0 ou plusieurs fois (gourmand).
  • + : 1 ou plusieurs fois.
  • ? : 0 ou 1 fois (optionnel).
  • {n} : exactement \(n\) fois.
  • {min,max} : entre \(min\) et \(max\) fois inclus.

3. Les fonctions majeures du module re#

flowchart TD
    A[Besoin de traitement Regex] --> B{Objectif ?}
    B -->|Premiere occurrence n'importe ou| C[re.search]
    B -->|Verification stricte au debut| D[re.match]
    B -->|Extraire toutes les occurrences| E[re.findall / re.finditer]
    B -->|Remplacer / Nettoyer du texte| F[re.sub]

A. Chercher la première occurrence : re.search()#

Recherche le motif n'importe où dans le texte et renvoie un objet Match ou None :

import re

texte = "Le colis #ABC-94021 a ete livre avec succes."
motif = r"[A-Z]{3}-\d{5}"

correspondance = re.search(motif, texte)

if correspondance:
    print("Code detecte :", correspondance.group())  # 'ABC-94021'
    print("Position     : de", correspondance.start(), "a", correspondance.end())

B. Extraire toutes les occurrences : re.findall() et re.finditer()#

  • re.findall() : renvoie une simple liste de chaînes de toutes les correspondances.
  • re.finditer() : renvoie un itérateur d'objets Match pour accéder aux positions exactes.
texte = "Prix : 15.50 EUR, Remise : 3.00 EUR, Total : 12.50 EUR"
montants = re.findall(r"\d+\.\d{2}", texte)
print("Tous les montants trouves :", montants)  # ['15.50', '3.00', '12.50']

C. Remplacer des motifs : re.sub()#

Idéal pour anonymiser des données personnelles ou reformater du texte :

texte = "Mon contact personnel est 06 12 34 56 78."
# Masquer les numéros de téléphone par [CONFIDENTIEL]
texte_masque = re.sub(r"\d{2}(?: \d{2}){4}", "[CONFIDENTIEL]", texte)
print(texte_masque)  # Mon contact personnel est [CONFIDENTIEL].

4. Groupes de capture et groupes nommés#

Les parenthèses (...) permettent d'isoler des sous-parties d'un motif complexe :

import re

# Découpage d'une date ISO AAAA-MM-JJ en groupes numérotés
date_texte = "Date de cloture : 2026-03-03"
motif_date = r"(\d{4})-(\d{2})-(\d{2})"

match = re.search(motif_date, date_texte)
if match:
    annee, mois, jour = match.groups()
    print(f"Jour={jour}, Mois={mois}, Annee={annee}")

Groupes nommés avec (?P<nom>...) (Recommandé)#

Les groupes nommés permettent de récupérer un dictionnaire lisible avec .groupdict() :

motif_nomme = r"(?P<annee>\d{4})-(?P<mois>\d{2})-(?P<jour>\d{2})"
match = re.search(motif_nomme, "2026-03-03")

if match:
    donnees = match.groupdict()
    print("Dictionnaire extrait :", donnees)
    # {'annee': '2026', 'mois': '03', 'jour': '03'}

5. Compilation de motifs : re.compile()#

Si votre application exécute une même expression régulière des milliers de fois dans une boucle, compilez-la au préalable pour un gain de performance notable :

# Compilation unique
regex_email = re.compile(r"^[\w\.-]+@[\w\.-]+\.[a-zA-Z]{2,}$", re.IGNORECASE)

emails_a_tester = ["contact@algojungle.com", "faux_email@", "admin@univ.edu"]

for email in emails_a_tester:
    valide = bool(regex_email.match(email))
    print(f"{email:<25} -> {'VALIDE' if valide else 'INVALIDE'}")

6. Mise en pratique : Analyseur de logs de serveur web#

Concevons un parseur de journal d'accès HTTP extrayant l'adresse IP, le verbe HTTP, le chemin URL et le code statut :

import re

logs = [
    '192.168.1.45 - [03/Mar/2026:10:14:02] "GET /api/v1/users HTTP/1.1" 200 4520',
    '10.0.0.12 - [03/Mar/2026:10:15:33] "POST /auth/login HTTP/1.1" 401 128',
    '172.16.0.8 - [03/Mar/2026:10:16:10] "GET /dashboard HTTP/1.1" 200 8920',
    '192.168.1.45 - [03/Mar/2026:10:17:45] "DELETE /api/v1/users/9 HTTP/1.1" 403 76'
]

# Motif avec groupes nommés
motif_log = re.compile(
    r'(?P<ip>\d{1,3}(?:\.\d{1,3}){3})\s-\s\[.*?\]\s"(?P<methode>[A-Z]+)\s(?P<url>[^\s]+)\s.*?"\s(?P<statut>\d{3})'
)

print(f"{'Adresse IP':<15} | {'Verbe':<6} | {'Statut':<6} | {'Ressource URL'}")
print("-" * 55)

for ligne in logs:
    m = motif_log.search(ligne)
    if m:
        data = m.groupdict()
        print(f"{data['ip']:<15} | {data['methode']:<6} | {data['statut']:<6} | {data['url']}")

7. Défi d'application#

Écrivez une fonction valider_mot_de_passe_fort(mdp: str) -> bool qui valide la robustesse d'un mot de passe à l'aide d'expressions régulières. Le mot de passe doit comporter : - Au moins 8 caractères au total. - Au moins une lettre majuscule [A-Z]. - Au moins une lettre minuscule [a-z]. - Au moins un chiffre [0-9]. - Au moins un caractère spécial parmi [@#$%^&+=!_].

Commentaires

Inscrivez-vous à une formation complète

Voir le catalogue