Expressions régulières (module re)

Introduction aux expressions régulières : un langage pour rechercher et manipuler du texte

Les expressions régulières (également appelées regex ou regexp) sont un outil puissant pour rechercher, extraire et manipuler du texte. Elles vous permettent de définir des motifs (patterns) qui décrivent des ensembles de chaînes de caractères, et de les utiliser pour effectuer des opérations sur du texte.

Une expression régulière est une séquence de caractères qui forme un motif de recherche. Ce motif peut être aussi simple qu'un seul caractère, ou aussi complexe qu'une combinaison de caractères spéciaux, de quantificateurs, de classes de caractères, etc.

Les expressions régulières sont utilisées dans de nombreux domaines, comme la validation de données (vérifier si une adresse e-mail, un numéro de téléphone, une date, etc., a un format valide), l'extraction d'informations (extraire toutes les adresses e-mail d'un texte, extraire les liens d'une page web, etc.), la recherche et le remplacement de texte (remplacer toutes les occurrences d'un mot par un autre, modifier le format d'une date, etc.), et l'analyse syntaxique (parser) de fichiers de configuration ou de code source.

Nous verrons des exemples d'utilisation d'expressions régulières dans différents contextes.

Syntaxe des expressions régulières : caractères spéciaux, quantificateurs, etc.

La syntaxe des expressions régulières peut sembler intimidante au premier abord, mais elle est en fait assez logique. Elle est basée sur un ensemble de caractères spéciaux qui ont une signification particulière :

• `.` (point) : correspond à n'importe quel caractère (sauf le retour à la ligne).
• `^` (circonflexe) : correspond au début de la chaîne (ou au début de la ligne, en mode multiligne).
• `$` (dollar) : correspond à la fin de la chaîne (ou à la fin de la ligne, en mode multiligne).
• `*` (astérisque) : correspond à 0 ou plusieurs répétitions de l'expression précédente.
• `+` (plus) : correspond à 1 ou plusieurs répétitions de l'expression précédente.
• `?` (point d'interrogation) : correspond à 0 ou 1 répétition de l'expression précédente (rend une expression "non-greedy" lorsqu'il suit un quantificateur).
• `{m,n}` : correspond à entre `m` et `n` répétitions de l'expression précédente.
• `[]` (crochets) : définit une classe de caractères (un ensemble de caractères possibles). Par exemple, `[a-z]` correspond à n'importe quelle lettre minuscule.
• `|` (pipe) : représente l'alternative (OU logique). Par exemple, `a|b` correspond à `a` ou `b`.
• `()` (parenthèses) : définit un groupe de capture (une partie de l'expression que vous pouvez extraire séparément).
• `\` (backslash) : permet d'échapper un caractère spécial (pour qu'il soit interprété littéralement), ou de représenter des séquences spéciales (comme `\d` pour un chiffre, `\w` pour un caractère alphanumérique, `\s` pour un espace blanc).

Nous verrons comment utiliser ces caractères spéciaux, comment les combiner pour former des expressions régulières complexes, et comment utiliser des quantificateurs pour spécifier le nombre de répétitions d'une expression.

Fonctions du module `re` : `search`, `match`, `findall`, `sub`, etc.

En Python, vous utilisez les expressions régulières avec le module `re`. Ce module fournit des fonctions pour rechercher, extraire et manipuler du texte en utilisant des expressions régulières.

Les fonctions les plus importantes du module `re` sont :

• `re.search(motif, chaine)` : recherche la première occurrence du motif dans la chaîne. Renvoie un objet `Match` si une correspondance est trouvée, `None` sinon.
• `re.match(motif, chaine)` : recherche une correspondance du motif au début de la chaîne. Renvoie un objet `Match` si une correspondance est trouvée, `None` sinon.
• `re.findall(motif, chaine)` : recherche toutes les occurrences du motif dans la chaîne, et les renvoie sous forme d'une liste de chaînes de caractères (ou d'une liste de tuples, si le motif contient des groupes de capture).
• `re.finditer(motif, chaine)`: recherche toutes les occurrences du motif et renvoie un itérateur sur les objets `Match`.
• `re.sub(motif, remplacement, chaine)` : remplace toutes les occurrences du motif dans la chaîne par le remplacement. Le remplacement peut être une chaîne de caractères, ou une fonction qui prend un objet `Match` en argument et renvoie la chaîne de remplacement.
• `re.split(motif, chaine)`: Divise la chaine à chaque correspondance avec le motif.

L'objet `Match` contient des informations sur la correspondance, comme la position de la correspondance dans la chaîne, la partie de la chaîne qui correspond au motif, et les groupes de capture.

Nous verrons comment utiliser ces fonctions, comment accéder aux informations de l'objet `Match`, et comment utiliser des groupes de capture pour extraire des parties spécifiques de la chaîne.

Utilisations courantes : validation de données, extraction d'informations, etc.

Nous verrons des exemples concrets d'utilisation des expressions régulières pour résoudre des problèmes courants :

• Vérifier si une chaîne de caractères est une adresse e-mail valide.
• Vérifier si une chaîne de caractères est un numéro de téléphone valide.
• Vérifier si une chaîne de caractères est une date valide.
• Vérifier si une chaîne de caractères est un mot de passe fort (contient au moins une majuscule, une minuscule, un chiffre et un caractère spécial).

• Extraire toutes les adresses e-mail d'un texte.
• Extraire tous les liens d'une page web.
• Extraire les noms et les numéros de téléphone d'un fichier de contacts.
• Extraire les données d'un fichier CSV ou d'un fichier de log.

• Formater un numéro de téléphone.
• Remplacer des mots interdits.
• Convertir des dates.

Ces exemples vous montreront comment utiliser les expressions régulières de manière pratique, et comment les adapter à vos propres besoins.