Expressions Regulieres en Python : Guide Complet pour Maitriser le Module re

Les expressions regulieres (regex) constituent l’un des outils les plus puissants pour manipuler, rechercher et valider des chaines de caracteres en Python. Que vous soyez en train de parser des logs, valider des emails, ou extraire des donnees structurees d’un texte brut, maitriser les regex vous fera gagner un temps considerable.

1. Introduction aux Expressions Regulieres

Les expressions regulieres sont un langage de pattern-matching universel, supporte par pratiquement tous les langages de programmation. En Python, le module re de la bibliotheque standard fournit toutes les fonctionnalites necessaires pour travailler avec les regex.

Pourquoi utiliser les expressions regulieres ?

Les regex excellent dans plusieurs domaines :

• Validation de donnees : verifier qu’un email, un numero de telephone ou un code postal respecte un format specifique
• Extraction d’informations : recuperer des URLs, des dates ou des montants dans un texte
• Transformation de texte : remplacer des patterns complexes de maniere flexible
• Parsing de fichiers : analyser des logs, des fichiers CSV mal formes ou des configurations

Importer le module re

import re

# Le module re est inclus dans la bibliotheque standard Python
# Aucune installation supplementaire n'est necessaire

Syntaxe de base des patterns

Voici les metacaracteres les plus utilises :

Pattern	Description
.	N’importe quel caractere sauf newline
\d	Un chiffre (equivalent a [0-9])
\w	Un caractere alphanumerique (equivalent a [a-zA-Z0-9_])
\s	Un espace blanc (espace, tab, newline)
^	Debut de chaine
$	Fin de chaine
*	Zero ou plus d’occurrences
+	Une ou plus d’occurrences
?	Zero ou une occurrence
{n,m}	Entre n et m occurrences

2. Recherche avec re.findall()

La fonction re.findall() permet de rechercher toutes les occurrences d’un pattern dans une chaîne et de renvoyer une liste de tous les matches trouvés.

import re

chaîne = "some 1 text 12 is 945 here 4445588899"
pattern = r"([0-9]{2,3})"

results = re.findall(pattern, chaîne)
print(results)  # ['12', '945', '444']

3. Recherche avec re.finditer()

La fonction re.finditer() permet de rechercher toutes les occurrences d’un pattern dans une chaîne et de renvoyer un itérateur sur tous les matches trouvés.

import re

chaîne = "some 1 text 12 is 945 here 4445588899"
pattern = r"([0-9]{2,3})"

for match in re.finditer(pattern, chaîne):
    print(match.group())  # imprime chaque match trouvé

4. Validation de chaînes avec des règles

Vous pouvez utiliser les expressions régulières pour valider la forme d’une chaîne. Par exemple, vous pouvez vérifier si une chaîne contient uniquement des caractères autorisés.

import re

def est_valide(chaîne):
    pattern = r"^[a-zA-Z0-9]+$"
    return bool(re.match(pattern, chaîne))

print(est_valide("abc123"))  # True
print(est_valide("#*@#$%^"))  # False

5. Séparation de chaînes avec des expressions régulières

Vous pouvez utiliser les expressions régulières pour séparer une chaîne en plusieurs parties.

import re

chaîne = "James 94 Samantha 417 Scarlett 74"
pattern = r"\s+"

parties = re.split(pattern, chaîne)
print(parties)  # ['James', '94', 'Samantha', '417', 'Scarlett', '74']

6. Groupe de résultats

Les expressions régulières permettent de capturer des groupes de résultat. Par exemple, vous pouvez utiliser les parenthèses pour capturer une partie d’une chaîne.

import re

chaîne = "This is a phone number 672-123-456-9910"
pattern = r".*(phone).*?([\d-]+)"

match = re.match(pattern, chaîne)
print(match.group(1))  # imprime le premier groupe de résultats

7. Échappement des caractères spéciaux

Les expressions régulières utilisent des caractères spéciaux pour spécifier les règles de recherche. Vous pouvez échapper ces caractères pour qu’ils soient traités littéralement.

import re

chaîne = "a[b]c"
pattern = r"\[b\]"

match = re.search(pattern, chaîne)
print(match.group())  # imprime le groupe de résultats

8. Recherche d’expressions dans des emplacements spécifiques

Vous pouvez utiliser les expressions régulières pour rechercher des expressions dans des emplacements spécifiques d’une chaîne.

import re

chaîne = "An apple a day keeps the doctor away (I eat an apple everyday)."
pattern = r"apple"

match = re.search(pattern, chaîne)
print(match.group())  # imprime le groupe de résultats

9. Iteration sur les matches avec re.finditer()

La fonction re.finditer() permet d’iterer sur tous les matches trouves dans une chaine.

import re

chaine = "You can try to find an ant in this string"
pattern = r"an?\w"

for match in re.finditer(pattern, chaine):
    print(match.group())  # imprime chaque match trouve

10. Remplacement avec re.sub()

La fonction re.sub() permet de remplacer toutes les occurrences d’un pattern par une chaine de remplacement.

import re

# Remplacement simple
texte = "Mon numero est 06-12-34-56-78"
pattern = r"(\d{2})-(\d{2})-(\d{2})-(\d{2})-(\d{2})"
nouveau_format = r"\1.\2.\3.\4.\5"

resultat = re.sub(pattern, nouveau_format, texte)
print(resultat)  # "Mon numero est 06.12.34.56.78"

# Remplacement avec fonction
def masquer_email(match):
    email = match.group()
    nom, domaine = email.split('@')
    return nom[0] + '***@' + domaine

texte = "Contactez-nous: admin@example.com ou support@example.com"
resultat = re.sub(r'\S+@\S+', masquer_email, texte)
print(resultat)  # "Contactez-nous: a***@example.com ou s***@example.com"

11. Compilation de patterns avec re.compile()

Pour des patterns utilises frequemment, il est recommande de les compiler pour ameliorer les performances.

import re

# Compiler le pattern une seule fois
email_pattern = re.compile(r'^[\w\.-]+@[\w\.-]+\.\w+$')

# Reutiliser le pattern compile
emails = ["user@example.com", "invalid-email", "test@domain.org"]

for email in emails:
    if email_pattern.match(email):
        print(f"{email} est valide")
    else:
        print(f"{email} est invalide")

Bonnes Pratiques

1. Utilisez toujours les raw strings

Prefixez vos patterns avec r pour eviter les problemes d’echappement.

# Mauvais - necessite double echappement
pattern = "\\d+\\.\\d+"

# Bon - raw string, plus lisible
pattern = r"\d+\.\d+"

2. Compilez les patterns reutilises

Si vous utilisez le meme pattern plusieurs fois, compilez-le pour gagner en performance.

import re

# Pour une utilisation unique, c'est OK
re.findall(r"\d+", texte)

# Pour des utilisations repetees, compilez
pattern = re.compile(r"\d+")
for ligne in fichier:
    pattern.findall(ligne)

3. Utilisez les groupes nommes

Les groupes nommes rendent votre code plus lisible et maintenable.

import re

# Sans groupes nommes
pattern = r"(\d{4})-(\d{2})-(\d{2})"
match = re.search(pattern, "Date: 2024-01-15")
print(match.group(1))  # Qu'est-ce que group(1) ?

# Avec groupes nommes
pattern = r"(?P<annee>\d{4})-(?P<mois>\d{2})-(?P<jour>\d{2})"
match = re.search(pattern, "Date: 2024-01-15")
print(match.group('annee'))  # Beaucoup plus clair !

4. Preferez les quantificateurs non-greedy

Par defaut, * et + sont greedy (gourmands). Utilisez *? et +? pour un comportement non-greedy.

import re

html = "<b>Premier</b> texte <b>Deuxieme</b>"

# Greedy - capture tout entre le premier <b> et le dernier </b>
print(re.findall(r"<b>.*</b>", html))
# ['<b>Premier</b> texte <b>Deuxieme</b>']

# Non-greedy - capture chaque element individuellement
print(re.findall(r"<b>.*?</b>", html))
# ['<b>Premier</b>', '<b>Deuxieme</b>']

Pieges Courants

1. Oublier le flag re.MULTILINE

Sans ce flag, ^ et $ ne matchent que le debut et la fin de la chaine entiere.

import re

texte = """Ligne 1
Ligne 2
Ligne 3"""

# Sans MULTILINE - ne trouve que "Ligne 1"
print(re.findall(r"^Ligne \d", texte))
# ['Ligne 1']

# Avec MULTILINE - trouve toutes les lignes
print(re.findall(r"^Ligne \d", texte, re.MULTILINE))
# ['Ligne 1', 'Ligne 2', 'Ligne 3']

2. Confusion entre match() et search()

match() ne cherche qu’au debut de la chaine, tandis que search() cherche partout.

import re

texte = "Le prix est 99 euros"

# match() echoue car "99" n'est pas au debut
print(re.match(r"\d+", texte))  # None

# search() trouve "99" n'importe ou dans la chaine
print(re.search(r"\d+", texte).group())  # "99"

3. Backtracking excessif (ReDoS)

Certains patterns peuvent causer des performances catastrophiques.

import re

# Pattern dangereux - peut causer un ReDoS
# pattern = r"(a+)+$"  # Ne jamais utiliser !

# Pattern securise
pattern = r"a+$"

4. Ne pas echapper les caracteres speciaux dans les donnees utilisateur

Utilisez re.escape() pour les donnees non fiables.

import re

# L'utilisateur entre une recherche
recherche_utilisateur = "prix (en euros)"

# Dangereux - les parentheses sont interpretees comme un groupe
# re.search(recherche_utilisateur, texte)  # Erreur potentielle !

# Securise - les caracteres speciaux sont echappes
pattern = re.escape(recherche_utilisateur)
re.search(pattern, texte)

Conclusion

Les expressions regulieres sont un outil indispensable dans la boite a outils de tout developpeur Python. Dans cet article, nous avons explore en profondeur les differentes fonctionnalites du module re, des recherches simples aux remplacements avances.

Points cles a retenir

• re.findall() : recupere toutes les occurrences sous forme de liste
• re.finditer() : iterateur sur les matches avec acces aux positions
• re.match() : verifie le debut de la chaine uniquement
• re.search() : recherche dans toute la chaine
• re.sub() : remplacement de patterns
• re.compile() : optimisation pour les patterns reutilises

Ressources pour aller plus loin

Pour tester et deboguer vos expressions regulieres, utilisez des outils en ligne comme regex101.com qui offrent une visualisation interactive et des explications detaillees de vos patterns.

N’hesitez pas a pratiquer regulierement : les regex peuvent sembler complexes au debut, mais une fois maitrisees, elles deviennent un outil extremement puissant pour traiter du texte de maniere efficace.

Prochain chapitre :

Le prochain chapitre sera consacre a la copie de donnees en Python. Nous verrons comment copier des objets, des listes et des dictionnaires en utilisant les fonctions copy() et deepcopy(), ainsi que les pieges lies a la copie superficielle.