Expressions régulières Python

Expressions Régulières Python (module re)

Les expressions régulières (regex ou RE) sont des séquences de caractères puissantes qui définissent un motif de recherche. Elles sont utilisées pour la recherche de motifs dans les chaînes de caractères, permettant des tâches comme la recherche de formats de texte spécifiques (e-mails, URL), la validation, la recherche et le remplacement de sous-chaînes.

Le module intégré re de Python fournit un support complet pour les expressions régulières, largement compatible avec la syntaxe de Perl. Si une erreur se produit lors de la compilation ou de l’utilisation d’une regex, le module re lève l’exception re.error.

Il est fortement recommandé d’utiliser la notation de chaîne brute de Python (r"...") pour les motifs d’expressions régulières. Cela évite que les barres obliques inverses (\) à l’intérieur du motif regex ne soient interprétées comme des séquences d’échappement de chaînes Python.

Fonctions Clés : match() vs search()

Le module re offre plusieurs fonctions pour la recherche de motifs. Deux d’entre elles sont fondamentales : match() et search().

1. re.match(pattern, string, flags=0)

Tente de faire correspondre le pattern uniquement au début de la string. Si le motif correspond au début de la chaîne, il renvoie un objet match ; sinon, il renvoie None.

Paramètres :

Paramètre	Description
pattern	La chaîne d’expression régulière (utilisez des chaînes brutes r'').
string	La chaîne dans laquelle rechercher.
flags	Modificateurs facultatifs (par exemple, re.IGNORECASE, re.MULTILINE) combinés à l’aide de l’opérateur OU binaire (|). La valeur par défaut est 0.

2. re.search(pattern, string, flags=0)

Analyse toute la string à la recherche du premier emplacement où le pattern produit une correspondance. Si une correspondance est trouvée n’importe où dans la chaîne, elle renvoie un objet match ; sinon, elle renvoie None.

Les paramètres sont les mêmes que pour re.match().

Objets Match

Les fonctions match() et search() renvoient toutes deux un objet Match en cas de succès. Les objets Match ont des méthodes utiles :

Méthode	Description
group(num=0)	Renvoie toute la chaîne correspondante, ou un groupe de capture spécifique num (indice basé sur 1). group(0) ou group() renvoie la correspondance entière.
groups()	Renvoie un tuple contenant tous les sous-groupes capturés (tuple vide si aucun).
start(num=0)	Renvoie l’indice de début de la correspondance (ou du sous-groupe num).
end(num=0)	Renvoie l’indice de fin (exclusif) de la correspondance (ou du sous-groupe num).
span(num=0)	Renvoie un tuple (start, end) pour la correspondance (ou le sous-groupe num).

Exemple : match() vs search()

import re

text = "The quick brown fox jumps over the lazy dog."
pattern = r"fox"

# match() - Échoue car 'fox' n'est pas au début
match_obj = re.match(pattern, text)
if match_obj:
    print(f"match() found: '{match_obj.group()}' at index {match_obj.start()}")
else:
    print("match() found nothing.")

# search() - Réussit car 'fox' est trouvé dans la chaîne
search_obj = re.search(pattern, text)
if search_obj:
    print(f"search() found: '{search_obj.group()}' at index {search_obj.start()}")
else:
    print("search() found nothing.")

# Exemple avec des groupes de capture
line = "Cats are smarter than dogs"
pattern_groups = r'(.*) are (.*?) .*' # Groupes de capture avec ()
search_groups = re.search(pattern_groups, line, re.IGNORECASE)

if search_groups:
    print(f"\nFull match: {search_groups.group(0)}")
    print(f"Group 1: {search_groups.group(1)}")
    print(f"Group 2: {search_groups.group(2)}")
    print(f"All groups: {search_groups.groups()}")
else:
    print("Pattern with groups not found!")

Output:

match() found nothing.
search() found: 'fox' at index 16

Full match: Cats are smarter than dogs
Group 1: Cats
Group 2: smarter
All groups: ('Cats', 'smarter')

Autres Fonctions Utiles de re

re.findall(pattern, string, flags=0)

Trouve toutes les correspondances non chevauchantes du pattern dans la string et les renvoie sous forme de liste de chaînes de caractères. Si le motif inclut des groupes de capture, elle renvoie une liste de tuples, où chaque tuple contient le(s) groupe(s) capturé(s) pour une correspondance.

re.finditer(pattern, string, flags=0)

Similaire à findall(), mais renvoie un itérateur produisant des objets Match pour chaque correspondance. C’est plus économe en mémoire pour un grand nombre de correspondances.

re.sub(pattern, repl, string, count=0, flags=0)

Remplace les occurrences du pattern dans la string par repl. repl peut être une chaîne (permettant les rétro-références comme \1, \g<name>) ou une fonction qui prend un objet match et renvoie la chaîne de remplacement. Si count est spécifié et non nul, seules les premières count occurrences sont remplacées. Renvoie la chaîne modifiée.

Exemple : findall() et sub()

import re

text = "Contact us at info@example.com or support@example.org for help."

# Trouver toutes les adresses e-mail
email_pattern = r'[\w.-]+@[\w.-]+\.\w+'
emails = re.findall(email_pattern, text)
print(f"Emails found: {emails}")

# Remplacer les noms de domaine
phone = "Call 2004-959-559 for support # This is a Phone Number"

# Supprimer les commentaires
num_no_comment = re.sub(r'#.*$', '', phone).strip()
print(f"Phone without comment: '{num_no_comment}'")

# Supprimer les non-chiffres
num_digits_only = re.sub(r'\D', '', phone)
print(f"Phone digits only: '{num_digits_only}'")

Output:

Emails found: ['info@example.com', 'support@example.org']
Phone without comment: 'Call 2004-959-559 for support'
Phone digits only: '2004959559'

Drapeaux d’Expressions Régulières

Les drapeaux modifient la façon dont les motifs sont interprétés :

Drapeau	Alias	Description
re.IGNORECASE	re.I	Effectue une correspondance insensible à la casse.
re.MULTILINE	re.M	Fait correspondre ^ au début de chaque ligne (après un saut de ligne) et $ à la fin de chaque ligne (avant un saut de ligne), en plus du début/fin de la chaîne entière.
re.DOTALL	re.S	Fait correspondre le caractère spécial point (.) à n’importe quel caractère, y compris un saut de ligne ; sans ce drapeau, . correspond à tout sauf un saut de ligne.
re.VERBOSE	re.X	Permet d’écrire des motifs regex plus lisibles en ignorant les espaces blancs (sauf lorsqu’ils sont échappés ou dans des jeux de caractères) et en traitant # comme un marqueur de commentaire.
re.ASCII	re.A	Fait en sorte que \w, \W, \b, \B, \s, \S, \d, \D effectuent une correspondance ASCII uniquement au lieu d’une correspondance Unicode complète (par défaut en Python 3).
re.UNICODE	re.U	Obsolète en Python 3, car la correspondance Unicode est le comportement par défaut. Inclus pour le contexte de compatibilité ascendante.

Métacaractères et Syntaxe Regex Courants

Les motifs Regex sont construits à l’aide de caractères littéraux et de métacaractères spéciaux :

Motif	Description
.	Correspond à n’importe quel caractère sauf le saut de ligne (sauf si re.DOTALL est utilisé).
^	Correspond au début de la chaîne (ou de la ligne si re.MULTILINE).
$	Correspond à la fin de la chaîne (ou de la ligne si re.MULTILINE).
*	Correspond à 0 ou plusieurs répétitions de l’expression précédente (glouton).
+	Correspond à 1 ou plusieurs répétitions de l’expression précédente (glouton).
?	Correspond à 0 ou 1 répétition de l’expression précédente (glouton).
*?, +?, ??	Versions non gloutonnes (paresseuses) de *, +, ?. Correspondent au moins de caractères possible.
{m}	Correspond à exactement m répétitions de l’expression précédente.
{m,n}	Correspond entre m et n répétitions (inclusif, glouton).
{m,n}?	Version non gloutonne de {m,n}.
[...]	Jeu de Caractères : Correspond à n’importe quel caractère unique à l’intérieur des crochets. [aeiou] correspond à n’importe quelle voyelle. Des plages comme [a-z] ou [0-9] peuvent être utilisées.
[^...]	Jeu de Caractères Négatif : Correspond à n’importe quel caractère unique PAS à l’intérieur des crochets.
\	Caractère d’Échappement : Échappe les caractères spéciaux (par exemple, \., \*, \\) ou signale des séquences spéciales.
\d	Correspond à n’importe quel chiffre décimal Unicode (équivalent à [0-9] si re.ASCII).
\D	Correspond à n’importe quel caractère qui n’est pas un chiffre décimal.
\s	Correspond à n’importe quel caractère d’espace blanc Unicode (espace, tabulation, saut de ligne, etc.).
\S	Correspond à n’importe quel caractère qui n’est pas un espace blanc.
\w	Correspond aux caractères de mot Unicode (alphanumériques plus le tiret bas).
\W	Correspond à n’importe quel caractère qui n’est pas un caractère de mot.
\b	Correspond à une chaîne vide au début ou à la fin d’un mot (limite de mot).
\B	Correspond à une chaîne vide qui n’est pas à une limite de mot.
(...)	Groupe de Capture : Correspond à l’expression à l’intérieur et capture le texte correspondant. Peut être récupéré avec group(n).
(?:...)	Groupe Non Capturant : Regroupe les expressions mais ne capture pas la correspondance.
|	Alternance (OU) : Correspond soit à l’expression avant, soit à l’expression après le |. cat|dog correspond à ‘cat’ ou ‘dog’.
(?P<name>...)	Groupe de Capture Nommé : Capture la correspondance et lui assigne un nom. Accès via group('name').
(?=...)	Assertion Lookahead Positive : Correspond si le sous-motif correspond ensuite, mais ne consomme aucun caractère.
(?!...)	Assertion Lookahead Négative : Correspond si le sous-motif ne correspond pas ensuite.
(?<=...)	Assertion Lookbehind Positive : Correspond si le sous-motif correspond immédiatement avant la position actuelle.
(?<!...)	Assertion Lookbehind Négative : Correspond si le sous-motif ne correspond pas immédiatement avant.

Pour plus de détails et des motifs avancés, consultez la documentation officielle du module re de Python.