Expression régulière – Tribulation d'un Bernie perdu à Liège

Les expressions régulières (aussi appelées regex) sont des chaînes de caractères, souvent utilisées en programmation informatique, pour rechercher et valider des informations qui répondent à des critères précis.

Voici un exemple d’expression régulière qui vérifie la validité de la structure d’une adresse électronique.

/^(\w[-._+\w]*\w@\w[-._\w]*\w\.\w{2,9})$/

Exemple d’expression régulière qui permet de valider la syntaxe d’une adresse électronique

Standardisation

Comme souvent, la norme de départ a donné naissance à des déclinaisons plus ou moins différentes.

Dans un souci d’uniformisation, le standard POSIX contient une normalisation des expressions régulières. Malheureusement, il peut subsister des différences dans la mise en application de cette norme.

Il s’agit donc de se documenter suffisamment quand on utilise des expressions régulières, que ce soit en programmation ou dans l’utilisation d’applications, afin de connaître le standard utilisé et la manière dont il est mis en œuvre.

La syntaxe

Pour spécifier le format de l’information recherchée, on utilise une série de caractères spéciaux dont voici une liste non exhaustive.

/	Indique le début ou la fin de l’expression régulière.
( )	Permet de regrouper des caractères pour analyser des sous-chaînes.
\w	Correspond à un caractères alphanumérique (chiffre, lettre ou souligné _).
[ ]	Permet de renseigner des caractères autorisés.
*	Permet de spécifier le nombre de fois qu’une expression peut être trouvée. Ici 0 ou plusieurs fois.
Un caractère quelconque (par exemple m)	Permet de spécifier le caractère qui doit être trouvé à cet emplacement.
\.	Permet de spécifier le caractère point .
{2,9}	Permet de spécifier le nombre de fois que l’expression peut être trouvée. Ici, de 2 à 9 fois.
^ et $	Indique le début et la fin de la chaîne de caractères.
\s	Permet de spécifier la présence d’une espace (sous forme d’une espace, d’une tabulation ou de saut à la ligne).
\d	Permet de spécifier la présence d’un chiffre.

Exemple simple

Code python utilisant les regex pour Soit à trouver un nom propre commençant par une majuscule et composé de 5 lettres.

commencent par une majuscule,
ont exactement 5 lettres.

🔍 Règle regex :

On va utiliser : r'\b[A-Z][a-z]{4}\b'

\b : limite de mot
[A-Z] : une lettre majuscule
[a-z]{4} : exactement 4 lettres minuscules ensuite (donc 5 lettres en tout)
\b : fin de mot

import re

texte = """
Alice est allée au parc avec Simon. Bruce, le chien de Lucas, courait partout.
Ils ont croisé Marie et Jules, puis Clara, Ralph et Diane sont arrivés.
"""

# Regex pour trouver les noms propres de 5 lettres commençant par une majuscule
pattern = r'\b[A-Z][a-z]{4}\b'

resultats = re.findall(pattern, texte)

print("Noms propres trouvés (5 lettres) :", resultats)

Remarque :

Critère	`^[A-Z][a-z]{4}$`	`\b[A-Z][a-z]{4}\b`
Portée	Toute la chaîne	Mot à l’intérieur du texte
Usage typique	Validation stricte d’un seul mot	Recherche de tous les mots correspondants
Flexible dans un texte long	❌	✅
Idéal pour :	S’assurer qu’une entrée utilisateur est un nom propre de 5 lettres	Extraire tous les noms propres valides d’un texte

Exemple avec Adresse email à vérifier

import re

# Adresse email à vérifier
email = "exemple.utilisateur@domaine.com"

# Expression régulière simple pour valider un email
regex = r'^[\w\.-]+@[\w\.-]+\.\w+$'

# Vérification
if re.match(regex, email):
    print(f"✅ '{email}' est une adresse email valide.")
else:
    print(f"❌ '{email}' n'est pas une adresse email valide.")

🧩 Décomposition et signification

`^`

→ Début de la chaîne
Cela signifie qu’on commence à lire dès le début du texte (important pour s’assurer que toute la chaîne est une adresse email, pas juste une partie).

`[\w\.-]+`

→ C’est la partie avant le @ (le nom d’utilisateur)

\w : correspond à tout caractère alphanumérique ([a-zA-Z0-9_])
. : correspond au point (doit être échappé dans un [])
- : accepte le tiret
Le tout entre [] signifie : « on accepte un ou plusieurs (+) de ces caractères »

✅ Cela couvre des noms comme :

jean.doe
emma-martin
user_01

`@`

→ C’est tout simplement le caractère arobase obligatoire séparant l’utilisateur du domaine.

`[\w\.-]+`

→ C’est le nom de domaine, même structure que précédemment.

Exemple : gmail, proton-mail, openai-dev, etc.

✅ Autorise aussi des sous-domaines du style : mail.exemple

`\.`

→ Le point entre le domaine et le TLD (ex : le . de .com, .org, etc.)
On le doit l’échapper (\.) car un point seul signifie « n’importe quel caractère » en regex.

`\w+`

→ Le TLD (domaine de fin)

Exemples : com, fr, org, edu, etc.
\w = [a-zA-Z0-9_] → on accepte des lettres ou chiffres (pas le - ou le . ici)
+ : au moins un caractère, donc .c serait accepté (mais ce serait invalide techniquement – ici on pourrait améliorer ça avec {2,} si on veut un TLD de minimum 2 lettres)

`$`

→ Fin de la chaîne
Cela garantit que rien ne suit l’adresse email. On valide l’email complet uniquement.

✅ Exemple accepté :

jean.doe-42@mon-domaine.fr

❌ Exemple rejeté :

.invalide@truc.com       # commence par un caractère interdit
valid@domaine             # pas de TLD
nom@domaine..com          # double point non géré

Tester ses expressions régulières

Il existe de nombreux sites web qui permettent de vérifier l’efficacité des expressions régulières.

Parmi ceux-ci, je vous recommande https://regexr.com/(opens in a new tab).

La page d’accueil du site regexr.com(opens in a new tab).

La page de tests du site regexr.com(opens in a new tab).