Maîtriser les expressions régulières

Mise à jour : 02/09/2024

Les expressions régulières, ou regexp, sont un outil incontournable pour quiconque travaille avec des textes, que ce soit dans le cadre du développement logiciel, de l’administration système, ou même de l’analyse de données. Leur utilité réside dans leur capacité à rechercher, manipuler, et valider des chaînes de caractères avec une précision et une efficacité redoutables. Malgré leur apparence parfois déroutante, les expressions régulières suivent des règles logiques et consistent en un ensemble de symboles qui forment des modèles puissants.

Ce guide a pour objectif de vous faire découvrir les bases des regex, tout en vous proposant des exemples concrets en Python et Bash pour vous familiariser avec cet outil essentiel.

Historique des expressions régulières

Les expressions régulières trouvent leur origine dans les travaux du mathématicien américain Stephen Cole Kleene dans les années 1950. Kleene a développé le concept de langages réguliers dans le cadre de la théorie des automates et des langages formels, en utilisant une notation mathématique qu’il a appelée “événements réguliers”. Ces travaux visaient à modéliser des réseaux de neurones artificiels, mais ont rapidement trouvé des applications plus larges dans le domaine de l’informatique théorique.

Ce n’est que dans les années 1960 que les expressions régulières ont commencé à être utilisées dans des logiciels concrets. L’une des premières applications a été leur intégration dans un éditeur de texte par Ken Thompson, qui les a utilisées pour la correspondance de motifs dans le texte au sein de l’éditeur QED sur un système IBM. Ce travail a conduit au développement de l’éditeur ed dans le système UNIX, où les expressions régulières ont été popularisées, notamment par l’outil de recherche grep, dont le nom est dérivé de l’expression “Global Regular Expression Print”.

Dans les années 1980, les expressions régulières ont évolué avec l’apparition de nouvelles syntaxes, notamment celle de Perl, qui a introduit des fonctionnalités plus avancées. Ces syntaxes se sont standardisées, notamment avec la norme POSIX.2 en 1992, qui a défini un ensemble commun de fonctionnalités pour les expressions régulières dans les systèmes UNIX.

Aujourd’hui, les expressions régulières sont un outil omniprésent, utilisé dans de nombreux langages de programmation, éditeurs de texte, et outils de traitement de texte. Elles continuent d’évoluer avec les avancées technologiques, y compris des implémentations matérielles et des bibliothèques modernes comme PCRE (Perl Compatible Regular Expressions), qui étendent leurs capacités et améliorent leurs performances.

Qu’est-ce qu’une expression régulière ?

Une expression régulière (ou regex) est une séquence de caractères qui définit un modèle de recherche pour correspondre à des chaînes de caractères dans un texte. En termes simples, il s’agit d’un outil permettant de trouver, vérifier ou manipuler des fragments de texte en se basant sur des motifs préalablement définis. Les expressions régulières sont incroyablement puissantes et flexibles, mais elles peuvent également être complexes à maîtriser en raison de leur syntaxe et des règles spécifiques qui les régissent.

Le cœur d’une expression régulière repose sur le concept de motif. Un motif est une combinaison de caractères qui décrivent un ensemble de chaînes possibles. Par exemple, une regex simple comme abc correspond exactement à la chaîne “abc” dans un texte, mais la véritable puissance des expressions régulières réside dans leur capacité à manipuler des motifs plus complexes.

Prenons l’exemple d’une regex qui correspond à une adresse e-mail. L’expression suivante :

^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$

Ce motif est conçu pour correspondre à des chaînes qui suivent la structure générale d’une adresse e-mail, c’est-à-dire, une suite de caractères alphanumériques, suivie d’un ”@” et d’un domaine valide.

Quand et pourquoi utiliser des expressions régulières

Les expressions régulières sont un outil puissant pour la manipulation de texte, mais leur utilisation doit être bien pensée et justifiée en fonction du contexte.

Quand utiliser des expressions régulières ?

Les expressions régulières sont particulièrement utiles dans les situations suivantes :

Recherche complexe de texte : Les regex sont idéales lorsque vous devez rechercher des motifs complexes dans des chaînes de texte. Par exemple, si vous avez besoin de trouver toutes les adresses e-mail dans un document ou un flux de données, une expression régulière peut identifier les chaînes qui correspondent au format d’une adresse e-mail valide, quelle que soit sa position dans le texte.
Validation d’entrées utilisateur : Lors du développement d’applications web ou de scripts, il est souvent nécessaire de valider les entrées des utilisateurs. Les expressions régulières permettent de vérifier si les données saisies respectent un format spécifique, comme une adresse e-mail, un numéro de téléphone, ou un code postal. Par exemple, une regex peut être utilisée pour s’assurer qu’un utilisateur a bien entré un mot de passe complexe comprenant au moins une majuscule, un chiffre, et un caractère spécial.
Extraction de données : Les regex sont également très efficaces pour extraire des sous-chaînes spécifiques d’un texte plus long. Par exemple, vous pouvez extraire toutes les dates d’un document, ou isoler des morceaux spécifiques d’un fichier log, comme les adresses IP, les numéros de commande, ou les URL.
Substitution et transformation de texte : Les expressions régulières sont couramment utilisées pour rechercher et remplacer du texte dans des fichiers ou des chaînes. Par exemple, vous pourriez utiliser une regex pour convertir toutes les dates d’un format “MM/DD/YYYY” à “YYYY-MM-DD” dans un fichier texte, ou pour anonymiser des données en remplaçant des noms par des alias.
Nettoyage de données : Lorsque vous travaillez avec des données brutes, il est souvent nécessaire de nettoyer les données en supprimant les caractères non désirés, en corrigeant les formats, ou en supprimant les doublons. Les regex permettent de réaliser ces tâches de manière efficace, en automatisant des processus qui seraient autrement fastidieux et sujets à des erreurs manuelles.

Pourquoi utiliser des expressions régulières ?

L’utilisation des expressions régulières présente plusieurs avantages :

Efficacité : Les regex permettent de réaliser des opérations complexes sur des chaînes de texte avec un minimum de code. Ce qui pourrait prendre des dizaines de lignes de code en logique conditionnelle peut souvent être accompli en une seule ligne avec une expression régulière bien construite.
Flexibilité : Les regex sont extrêmement flexibles et peuvent être adaptées pour traiter presque n’importe quel type de motif de texte. Elles peuvent gérer des cas d’utilisation variés, du simple au très complexe, sans nécessiter des modifications majeures.
Interopérabilité : Les expressions régulières sont supportées dans de nombreux langages de programmation (comme Python, JavaScript, Java, Perl) et outils (comme grep, sed, awk), ce qui en fait une compétence transférable. Une fois que vous maîtrisez les regex, vous pouvez les appliquer dans divers environnements de travail.
Manipulation avancée de texte : Les regex sont particulièrement utiles pour des tâches de manipulation avancée, comme le traitement du texte à la volée, la génération de rapports à partir de fichiers log, ou l’analyse de données textuelles. Elles offrent une précision et un contrôle sur le texte qui seraient difficiles à obtenir autrement.

Quand ne pas utiliser des expressions régulières ?

Il est important de noter que les regex ne sont pas toujours la solution idéale. Elles peuvent parfois être difficiles à lire et à maintenir, surtout lorsqu’elles deviennent très complexes. Voici quelques situations où il vaut mieux envisager d’autres approches :

Cas simples : Si la tâche est simple, comme vérifier si une chaîne contient un certain mot, une condition if ou une méthode de recherche native pourrait être plus claire et plus facile à maintenir qu’une regex.
Complexité excessive : Pour des motifs extrêmement complexes, une expression régulière peut devenir difficile à comprendre, même pour ceux qui l’ont écrite. Dans ces cas, il peut être préférable de découper le problème en plusieurs étapes ou d’utiliser des méthodes de traitement de texte plus traditionnelles.
Performance : Les regex peuvent être performantes pour des tâches simples et modérées, mais pour des traitements très volumineux ou en temps réel, elles peuvent devenir un goulot d’étranglement. Dans ces cas, des approches plus optimisées peuvent être nécessaires.

Les bases des expressions régulières

Les expressions régulières sont construites à partir de divers éléments de base qui, combinés, permettent de créer des motifs puissants pour rechercher et manipuler du texte.

Littéraux

Le composant le plus simple d’une expression régulière est le littéral. Un littéral correspond simplement à lui-même dans le texte. Par exemple, l’expression régulière abc correspondra exactement à la chaîne “abc” dans le texte recherché. Les littéraux sont utiles pour des recherches simples où vous savez précisément ce que vous cherchez.

abc

Métacaractères

Les métacaractères sont des caractères spéciaux qui ont une signification particulière dans une expression régulière. Contrairement aux littéraux, ils ne sont pas interprétés comme eux-mêmes, mais comme des commandes qui modifient le comportement de l’expression. Voici quelques métacaractères courants :

. : Correspond à n’importe quel caractère sauf un retour à la ligne.
^ : Indique le début d’une ligne.
$ : Indique la fin d’une ligne.
* : Correspond à zéro ou plusieurs occurrences du caractère précédent.
+ : Correspond à une ou plusieurs occurrences du caractère précédent.
? : Correspond à zéro ou une occurrence du caractère précédent.
\ : Sert à échapper un métacaractère pour qu’il soit interprété comme un littéral.

Par exemple, l’expression régulière a.b correspondra à n’importe quelle chaîne de trois caractères où le premier est “a”, le dernier est “b”, et où le caractère du milieu peut être n’importe quoi sauf un retour à la ligne.

a.b

Classes de caractères

Les classes de caractères permettent de spécifier un ensemble de caractères possibles à un emplacement donné dans le texte. Une classe de caractères est définie par des crochets [], et elle correspond à un seul caractère parmi ceux listés dans les crochets.

[abc] : Correspond à “a”, “b”, ou “c”.
[a-z] : Correspond à n’importe quelle lettre minuscule de “a” à “z”.
[A-Z] : Correspond à n’importe quelle lettre majuscule de “A” à “Z”.
[0-9] : Correspond à n’importe quel chiffre de 0 à 9.

Les classes de caractères peuvent aussi être négatives, ce qui signifie qu’elles correspondent à n’importe quel caractère qui n’est pas dans la liste. Pour cela, on utilise le caractère ^ au début des crochets :

[^abc] : Correspond à n’importe quel caractère sauf “a”, “b”, ou “c”.

Par exemple, l’expression régulière [0-9] correspondra à n’importe quel chiffre dans le texte.

[0-9]

Les quantificateurs

Les quantificateurs sont utilisés pour indiquer combien de fois un élément doit apparaître dans le texte pour correspondre au motif. Ils sont placés directement après le caractère ou le groupe qu’ils quantifient.

* : Correspond à zéro ou plusieurs occurrences.
+ : Correspond à une ou plusieurs occurrences.
? : Correspond à zéro ou une occurrence.
{n} : Correspond exactement à n occurrences.
{n,} : Correspond à au moins n occurrences.
{n,m} : Correspond à entre n et m occurrences.

Par exemple, l’expression régulière a{2,4} correspondra à “aa”, “aaa”, ou “aaaa”.

a{2,4}

Groupes et Captures

Les groupes permettent de capturer des parties spécifiques du texte correspondant à une expression régulière. Les groupes sont définis par des parenthèses (). Ces groupes peuvent être utilisés pour extraire des sous-chaînes ou pour appliquer des quantificateurs à des sous-ensembles d’une regex.

(abc) : Correspond à “abc” et capture cette sous-chaîne.
(?:abc) : Correspond à “abc” sans capturer la sous-chaîne (groupe non capturant).
(a|b) : Correspond à “a” ou “b” (alternance).

Les captures sont particulièrement utiles pour extraire des informations spécifiques d’une chaîne de texte. Par exemple, l’expression régulière (abc)+ correspondra à une ou plusieurs répétitions de “abc” et capturera chaque occurrence.

(abc)+

Les assertions (Lookahead et Lookbehind)

Les assertions permettent de faire des correspondances conditionnelles sans consommer de caractères dans la chaîne de texte. Les deux types d’assertions principales sont lookahead (regard en avant) et lookbehind (regard en arrière).

Lookahead positif : (?=abc) correspond à une position suivie de “abc”, sans inclure “abc” dans le résultat.
Lookahead négatif : (?!abc) correspond à une position non suivie de “abc”.
Lookbehind positif : (?<=abc) correspond à une position précédée de “abc”.
Lookbehind négatif : (?<!abc) correspond à une position non précédée de “abc”.

Par exemple, l’expression (?<=@)\w+ correspondra à un mot qui suit immédiatement un ”@” sans inclure le ”@” dans la correspondance.

(?<=@)\w+

Les classes de caractères prédéfinies

Les classes de caractères prédéfinies sont des raccourcis pour des classes de caractères courantes. Elles rendent les regex plus lisibles et plus faciles à écrire.

\d : Correspond à n’importe quel chiffre, équivalent à [0-9].
\D : Correspond à n’importe quel caractère qui n’est pas un chiffre, équivalent à [^0-9].
\w : Correspond à n’importe quel caractère alphanumérique ou underscore, équivalent à [a-zA-Z0-9_].
\W : Correspond à n’importe quel caractère qui n’est pas alphanumérique ou underscore, équivalent à [^a-zA-Z0-9_].
\s : Correspond à n’importe quel espace blanc (espace, tabulation, retour à la ligne).
\S : Correspond à n’importe quel caractère qui n’est pas un espace blanc.

Par exemple, l’expression régulière \d{3} correspondra à exactement trois chiffres consécutifs dans le texte.

\d{3}

Exercices pratiques sur les expressions régulières

La meilleure façon de maîtriser les expressions régulières est de pratiquer. Dans ce chapitre, je vais vous proposer une série d’exercices pratiques qui vous permettront de vous familiariser avec les différents concepts que nous avons abordés. Ces exercices couvrent des cas d’utilisation courants que vous pourriez rencontrer dans le développement de logiciels, l’administration système, ou même lors du traitement de données. Pour chaque exercice, je vous fournirai une explication de la solution ainsi que la regex correspondante.

Valider une adresse e-mail

Objectif : Écrire une expression régulière qui valide si une chaîne de caractères est une adresse e-mail.

Exemple d’entrée :

valide : exemple@domaine.com
invalide : exemple@domaine

Solution : Une adresse e-mail valide comprend généralement une combinaison de caractères alphanumériques, éventuellement des points ou des tirets, suivie du symbole @, puis d’un nom de domaine avec un suffixe comme .com ou .org.

^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$

Explication :

^[a-zA-Z0-9._%+-]+ : La partie avant le @ accepte des lettres, chiffres, points, underscores, pourcentages, plus ou tirets.
@[a-zA-Z0-9.-]+ : Le @ suivi d’une combinaison de lettres, chiffres, points ou tirets pour le domaine.
\.[a-zA-Z]{2,}$ : Un point suivi de deux lettres ou plus pour le suffixe du domaine.

Extraire les numéros de téléphone d’un texte

Objectif : Écrire une regex qui extrait tous les numéros de téléphone au format (xxx) xxx-xxxx ou xxx-xxx-xxxx d’un texte.

Exemple d’entrée :

Texte : “Vous pouvez me contacter au (123) 456-7890 ou 987-654-3210.”

Solution : Nous devons créer une regex qui capture les deux formats mentionnés.

\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}

Explication :

\(? : Une parenthèse gauche optionnelle pour le code régional.
\d{3} : Trois chiffres pour le code régional.
\)? : Une parenthèse droite optionnelle pour le code régional.
[-.\s]? : Un tiret, point ou espace optionnel entre les groupes de chiffres.
\d{3} : Trois chiffres pour la première partie du numéro.
[-.\s]? : Un tiret, point ou espace optionnel.
\d{4} : Quatre chiffres pour la dernière partie du numéro.

Trouver des URLs dans un texte

Objectif : Écrire une regex qui identifie toutes les URLs dans un texte.

Exemple d’entrée :

Texte : “Visitez https://www.exemple.com ↗ ou http://exemple.org ↗ pour plus d’informations.”

Solution : Les URLs commencent généralement par http:// ou https:// suivis d’un nom de domaine et éventuellement d’un chemin.

https?:\/\/[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}([\/\w.-]*)*\/?

Explication :

https?:// : Capture http:// ou https://.
[a-zA-Z0-9.-]+\.[a-zA-Z]{2,} : Capture le nom de domaine et son suffixe.
([\/\w.-]*)* : Capture les chemins possibles après le nom de domaine.
\/? : Un slash optionnel à la fin.

Valider un mot de passe fort

Objectif : Écrire une regex qui valide si un mot de passe est fort (au moins 8 caractères, avec au moins une lettre majuscule, une lettre minuscule, un chiffre et un caractère spécial).

Exemple d’entrée :

valide : P@ssw0rd!
invalide : password

Solution :

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$

Explication :

(?=.*[a-z]) : Assure la présence d’au moins une lettre minuscule.
(?=.*[A-Z]) : Assure la présence d’au moins une lettre majuscule.
(?=.*\d) : Assure la présence d’au moins un chiffre.
(?=.*[@$!%*?&]) : Assure la présence d’au moins un caractère spécial.
[A-Za-z\d@$!%*?&]{8,} : Accepte au moins 8 caractères comprenant les critères précédents.

Nettoyer des fichiers logs

Objectif : Remplacer toutes les adresses IP dans un fichier log par XXX.XXX.XXX.XXX pour anonymiser les données.

Exemple d’entrée :

Log : “User connected from 192.168.1.1 at 12:34:56.”

Solution : Pour anonymiser les adresses IP, il suffit de détecter les motifs correspondants.

\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b

Puis utiliser cette regex pour remplacer les correspondances par XXX.XXX.XXX.XXX.

Explication :

\b : Assure que nous capturons l’IP en entier.
\d{1,3} : Capture un octet (1 à 3 chiffres).
\. : Un point littéral entre les octets.
Le motif est répété pour capturer les quatre parties d’une adresse IP.

Utilisation des expressions régulières en Bash

Les expressions régulières sont un outil essentiel pour les administrateurs systèmes et les développeurs qui travaillent avec des scripts en Bash. Elles permettent de rechercher, de manipuler, et de transformer du texte de manière très efficace directement depuis la ligne de commande.

`grep` : Rechercher des motifs dans des fichiers

L’outil grep est probablement l’une des utilisations les plus courantes des expressions régulières en Bash. grep permet de rechercher des lignes dans un fichier ou un flux de données qui correspondent à une expression régulière donnée.

Exemple simple : Recherche d’un motif spécifique

grep "motif" fichier.txt

Cet exemple recherche toutes les lignes du fichier fichier.txt contenant le mot “motif”.

Utilisation d’expressions régulières avancées

Par défaut, grep utilise des expressions régulières basiques (BRE). Pour utiliser des expressions régulières étendues (ERE), il faut utiliser l’option -E ou utiliser egrep, qui est un alias pour grep -E.

grep -E "[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}" fichier.txt

Cet exemple recherche des adresses e-mail dans fichier.txt.

Recherche insensible à la casse

Vous pouvez rendre la recherche insensible à la casse avec l’option -i.

grep -i "motif" fichier.txt

Recherche récursive dans les répertoires

Pour rechercher un motif dans tous les fichiers d’un répertoire et ses sous-répertoires, utilisez l’option -r.

grep -r "motif" /chemin/vers/repertoire

`sed` : Modifier du texte à la volée

sed (stream editor) est un outil de manipulation de texte qui utilise les regex pour rechercher et remplacer du texte, insérer ou supprimer des lignes, et effectuer d’autres transformations complexes directement dans un flux de texte.

Exemple simple : Remplacer un motif dans un fichier

sed 's/motif/remplacement/g' fichier.txt

Cet exemple remplace toutes les occurrences de “motif” par “remplacement” dans fichier.txt. Le g à la fin de la commande indique que la substitution doit se faire globalement sur chaque ligne (c’est-à-dire remplacer toutes les occurrences du motif sur une ligne, pas seulement la première).

Utilisation de regex pour des substitutions avancées

Vous pouvez utiliser des regex plus complexes pour effectuer des substitutions avancées. Par exemple, pour anonymiser des adresses e-mail dans un fichier :

sed -E 's/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/[email protected]/g' fichier.txt

Cette commande remplace toutes les adresses e-mail par [email protected].

Modifier directement le fichier

L’option -i permet de modifier le fichier directement sans avoir à rediriger la sortie vers un nouveau fichier.

sed -i 's/motif/remplacement/g' fichier.txt

Suppression de lignes correspondant à un motif

Pour supprimer toutes les lignes qui contiennent un motif spécifique :

sed '/motif/d' fichier.txt

`awk` : Manipuler et formater des données structurées

awk est un langage de programmation spécialisé dans le traitement de texte, souvent utilisé pour analyser et transformer des fichiers texte ou des flux de données. awk utilise des regex pour rechercher des motifs dans les lignes de texte et effectuer des actions spécifiques.

Exemple simple : Imprimer des lignes correspondant à un motif

awk '/motif/ {print $0}' fichier.txt

Cet exemple imprime toutes les lignes de fichier.txt contenant “motif”. $0 représente la ligne entière dans awk.

Extraire des champs spécifiques

awk est particulièrement puissant pour travailler avec des fichiers structurés comme les fichiers CSV. Par exemple, pour extraire et afficher le deuxième champ de chaque ligne correspondant à un motif :

awk -F, '/motif/ {print $2}' fichier.csv

Dans cet exemple, -F, définit la virgule comme séparateur de champs, et $2 représente le deuxième champ.

Utilisation de regex pour des transformations avancées

Vous pouvez utiliser des regex complexes pour extraire ou transformer des données spécifiques. Par exemple, pour extraire des adresses IP d’un fichier log :

awk '/[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+/ {print $1}' fichier.log

Combiner les outils : Un exemple pratique

Souvent, il est nécessaire de combiner plusieurs outils pour réaliser des tâches plus complexes. Par exemple, pour rechercher toutes les occurrences d’une adresse e-mail dans un ensemble de fichiers, les remplacer par un texte générique, puis extraire les lignes modifiées, vous pourriez combiner grep, sed, et awk comme suit :

grep -rl "exemple@domaine.com" /chemin/vers/repertoire | xargs sed -i 's/exemple@domaine.com/[email protected]/g'

Cet exemple :

Utilise grep -rl pour rechercher récursivement tous les fichiers contenant l’adresse e-mail.
Utilise xargs pour passer ces fichiers à sed pour effectuer la substitution.

Utilisation des expressions régulières en Python

Python est l’un des langages de programmation les plus populaires pour la manipulation de texte, et il intègre nativement le support des expressions régulières via le module re. Ce module offre une gamme complète de fonctionnalités permettant de rechercher, remplacer, et manipuler des chaînes de caractères en utilisant des regex.

Le module re est le module Python dédié aux expressions régulières. Il doit être importé avant de pouvoir être utilisé dans votre code.

import re

Fonctions principales du module `re`

`re.search()`

La fonction re.search() recherche le premier emplacement où l’expression régulière correspond dans une chaîne de caractères. Elle retourne un objet de type Match si une correspondance est trouvée, sinon None.

Exemple :

import re

pattern = r"\b\d{3}-\d{2}-\d{4}\b"
text = "Mon numéro de sécurité sociale est 123-45-6789."
match = re.search(pattern, text)

if match:
    print(f"Trouvé : {match.group()}")

Explication :

r"\b\d{3}-\d{2}-\d{4}\b" est une regex qui correspond à un numéro de sécurité sociale (SSN) dans le format “123-45-6789”.
re.search() cherche cette correspondance dans la chaîne text.
Si une correspondance est trouvée, elle est affichée.

`re.match()`

re.match() vérifie si l’expression régulière correspond au début de la chaîne de caractères. Contrairement à re.search(), re.match() ne cherche que le début de la chaîne.

Exemple :

import re

pattern = r"\d{3}-\d{2}-\d{4}"
text = "123-45-6789 est mon numéro."
match = re.match(pattern, text)

if match:
    print(f"Trouvé au début : {match.group()}")

Explication :

re.match() ne retournera une correspondance que si le motif apparaît dès le début de la chaîne.

`re.findall()`

re.findall() retourne une liste de toutes les correspondances trouvées dans la chaîne. C’est utile pour extraire toutes les occurrences d’un motif dans un texte.

Exemple :

import re

pattern = r"\b\w+@\w+\.\w+\b"
text = "Contactez-nous à [email protected] ou [email protected]."
emails = re.findall(pattern, text)

print(f"Emails trouvés : {emails}")

Explication :

re.findall() trouve toutes les adresses e-mail présentes dans le texte.

`re.sub()`

re.sub() est utilisé pour rechercher un motif et le remplacer par une autre chaîne de caractères. C’est un outil puissant pour modifier du texte de manière automatisée.

Exemple :

import re

pattern = r"\b\d{3}-\d{2}-\d{4}\b"
text = "Mon numéro est 123-45-6789."
result = re.sub(pattern, "XXX-XX-XXXX", text)

print(f"Texte modifié : {result}")

Explication :

re.sub() remplace toutes les occurrences d’un numéro de sécurité sociale par “XXX-XX-XXXX”.

`re.compile()`

Pour des performances accrues, vous pouvez compiler une expression régulière avec re.compile() si vous avez l’intention de l’utiliser plusieurs fois. Cela précompile la regex et la rend plus rapide à exécuter.

Exemple :

import re

pattern = re.compile(r"\b\d{3}-\d{2}-\d{4}\b")
text = "Numéro 1 : 123-45-6789, Numéro 2 : 987-65-4321."
matches = pattern.findall(text)

print(f"Numéros trouvés : {matches}")

Explication :

re.compile() crée un objet regex réutilisable, ce qui améliore la performance lors de l’utilisation répétée du même motif.

Groupes et Captures

Les groupes en Python permettent de capturer des sous-chaînes spécifiques au sein d’une correspondance. Cela se fait en plaçant la partie de la regex à capturer entre parenthèses ().

Exemple :

import re

pattern = r"(\d{3})-(\d{2})-(\d{4})"
text = "Numéro de sécurité sociale : 123-45-6789."
match = re.search(pattern, text)

if match:
    print(f"Code de région : {match.group(1)}")
    print(f"Groupement : {match.group(2)}")
    print(f"Numéro : {match.group(3)}")

Explication :

match.group(1) retourne le premier groupe capturé, match.group(2) le deuxième, etc.

Les Flags dans les expressions régulières

Les flags sont des options supplémentaires qui modifient le comportement des expressions régulières. Ils sont souvent passés en deuxième argument des fonctions re.

re.IGNORECASE ou re.I : Ignore la casse.
re.MULTILINE ou re.M : Permet à ^ et $ de correspondre au début et à la fin de chaque ligne.
re.DOTALL ou re.S : Permet à . de correspondre à tous les caractères, y compris les retours à la ligne.

Exemple :

import re

pattern = r"^bonjour"
text = "Bonjour tout le monde\nbonjour tout le monde"
matches = re.findall(pattern, text, re.IGNORECASE | re.MULTILINE)

print(f"Occurrences trouvées : {matches}")

Explication :

re.IGNORECASE permet à la regex de correspondre à “Bonjour” et “bonjour” sans tenir compte de la casse.
re.MULTILINE permet à ^ de correspondre au début de chaque ligne.

Exercices pratiques

Valider une adresse IP

Créez une regex qui valide une adresse IP de la forme “192.168.1.1”.

import re

pattern = r"^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$"
text = "192.168.1.1"
match = re.match(pattern, text)

if match:
    print(f"Adresse IP valide : {match.group()}")

Extraire les hashtags d’un texte

Utilisez re.findall() pour extraire tous les hashtags d’une chaîne de caractères.

import re

text = "Suivez-nous sur #Python #regex #coding!"
hashtags = re.findall(r"#\w+", text)

print(f"Hashtags trouvés : {hashtags}")

Quelques sites utiles sur les expressions régulières

Lorsque vous apprenez ou travaillez avec des expressions régulières, plusieurs outils en ligne peuvent vous faciliter la tâche. Ces sites vous permettent de tester, déboguer, et affiner vos regex en temps réel, ce qui est extrêmement utile pour comprendre comment elles fonctionnent et pour résoudre des problèmes spécifiques. Voici quelques-uns des sites les plus populaires et utiles.

Regex101

Regex101 est l’un des outils les plus complets pour travailler avec les expressions régulières. Il offre un environnement interactif où vous pouvez entrer une expression régulière et un texte, et voir immédiatement les correspondances et les groupes capturés.

Fonctionnalités principales :
- Prise en charge des syntaxes PCRE, Python, et JavaScript.
- Explication détaillée de chaque partie de la regex.
- Débogueur intégré pour identifier les erreurs dans vos regex.
- Partage de vos regex via des liens.

Lien : regex101.com ↗

RegExr

RegExr est un autre outil populaire pour apprendre, tester, et partager des expressions régulières. Il est particulièrement bien adapté aux débutants grâce à son interface conviviale et ses explications claires.

Fonctionnalités principales :
- Bibliothèque de regex couramment utilisées, avec des explications.
- Recherche interactive qui montre les correspondances en temps réel.
- Tutoriels intégrés et communauté active.

Lien : regexr.com ↗

RegexPal

RegexPal est un outil simple mais efficace pour tester vos expressions régulières en JavaScript. Il est moins complexe que Regex101 ou RegExr, ce qui en fait un bon choix pour des tests rapides.

Fonctionnalités principales :
- Interface simple pour tester des regex en JavaScript.
- Mise en évidence des correspondances en temps réel.

Lien : regexpal.com ↗

RegexPlanet

RegexPlanet est un outil polyvalent en français qui prend en charge plusieurs langages de programmation. C’est un excellent choix si vous travaillez avec des regex dans des environnements multiples et que vous voulez voir comment elles se comportent dans différents contextes.

Fonctionnalités principales :
- Support pour plusieurs langages (Java, Python, JavaScript, etc.).
- Générateur de code pour intégrer les regex dans divers langages.
- Tests de performance des regex.

Lien : regexplanet.com ↗

Conclusion

Les expressions régulières sont un outil puissant et flexible pour manipuler du texte, qu’il s’agisse de recherche, de validation ou de transformation. Que vous travailliez avec des fichiers texte en Bash, des données en Python, ou que vous souhaitiez simplement valider des entrées utilisateur, maîtriser les regex vous permettra d’aborder ces tâches avec efficacité et précision. Avec des ressources en ligne comme Regex101, RegExr, et d’autres, vous avez tout ce qu’il vous faut pour apprendre, tester, et affiner vos compétences en expressions régulières. En pratiquant régulièrement et en utilisant ces outils, vous deviendrez rapidement un expert dans ce domaine essentiel du développement et de l’administration système.

Maîtriser les expressions régulières

Historique des expressions régulières

Qu’est-ce qu’une expression régulière ?

Quand et pourquoi utiliser des expressions régulières

Quand utiliser des expressions régulières ?

Pourquoi utiliser des expressions régulières ?

Quand ne pas utiliser des expressions régulières ?

Les bases des expressions régulières

Littéraux

Métacaractères

Classes de caractères

Les quantificateurs

Groupes et Captures

Les assertions (Lookahead et Lookbehind)

Les classes de caractères prédéfinies

Exercices pratiques sur les expressions régulières

Valider une adresse e-mail

Extraire les numéros de téléphone d’un texte

Trouver des URLs dans un texte

Valider un mot de passe fort

Nettoyer des fichiers logs

Utilisation des expressions régulières en Bash

grep : Rechercher des motifs dans des fichiers

Utilisation d’expressions régulières avancées

Recherche insensible à la casse

Recherche récursive dans les répertoires

sed : Modifier du texte à la volée

Utilisation de regex pour des substitutions avancées

Modifier directement le fichier

Suppression de lignes correspondant à un motif

awk : Manipuler et formater des données structurées

Extraire des champs spécifiques

Utilisation de regex pour des transformations avancées

Combiner les outils : Un exemple pratique

Utilisation des expressions régulières en Python

Fonctions principales du module re

re.search()

re.match()

re.findall()

re.sub()

re.compile()

Groupes et Captures

Les Flags dans les expressions régulières

Exercices pratiques

Valider une adresse IP

Extraire les hashtags d’un texte

Quelques sites utiles sur les expressions régulières

Regex101

RegExr

RegexPal

RegexPlanet

Conclusion

`grep` : Rechercher des motifs dans des fichiers

`sed` : Modifier du texte à la volée

`awk` : Manipuler et formater des données structurées

Fonctions principales du module `re`

`re.search()`

`re.match()`

`re.findall()`

`re.sub()`

`re.compile()`