Leçon 8 – Les expressions régulières

Des exemples pour démarrer

Trouver un motif simple :

Rechercher une chaine qui débute par un U majuscule.

Exemple : Chercher dans une liste de 4 chaines celles qui débutent par un U majuscule.

Remarquez dans le code ci-dessous l'expression régulière '^U' :
On emploie l'accent circonflexe en début de RegExp pour signifier "débute par"
re.search( '^U' , ch ) retourne true si la chaine ch débute par 'U' et false sinon.

Lancez le code et vérifiez que les deux chaines de caractères qui débutent par 'U' sont bien :
- Un beau paysage
- U123456789

import re # le module re gère les expressions régulières

# la liste des 4 chaines à tester
L = [ \
"Un beau paysage", \
"Tu comptes ? Un, deux, trois...", \
"une voiture rouge", \
"U123456789" ]

for ch in L : # Pour chaque chaine ch de la liste ...
    if re.search( '^U' , ch ) : # ... si la chaine ch débute par U ...
        print (ch) # ... on l'affiche.

Rechercher une chaine qui termine par un e minuscule.

Exemple : Chercher dans une liste de 4 chaines celles qui terminent par un e minuscule.

Remarquez dans le code ci-dessous l'expression régulière 'e$' :
On emploie le symbole $ (dollar) en fin de RegExp pour signifier "termine par"
re.search( 'e$' , ch ) retourne true si la chaine ch termine par 'e' et false sinon.

Lancez le code et vérifiez que les deux chaines de caractères qui terminent par 'e' sont bien :
- Un beau paysage
- une voiture rouge

import re # le module re gère les expressions régulières

# la liste des 4 chaines à tester
L = [ \
"Un beau paysage", \
"Tu comptes ? Un, deux, trois...", \
"une voiture rouge", \
"U123456789" ]

for ch in L : # Pour chaque chaine ch de la liste ...
    if re.search( 'e$' , ch ) : # ... si la chaine ch termine par e...
        print (ch) # ... on l'affiche.

Le point (.) est un joker, il représente n'importe quel caractère.

Exemple : Chercher dans une liste de 4 chaines celles contiennent un d et un t séparés par un caractère quelconque.

Remarquez dans le code ci-dessous l'expression régulière 'd.t'
On emploie le caractère point (.) pour admettre n'importe quel caractère
re.search( 'd.t' , ch ) retourne true si la chaine ch contient un d et un t séparés par un caractère quelconque et false sinon.

Lancez le code et vérifiez que les deux chaines de caractères qui matchent sont bien :
- Il apprend très vite # l'espace est un caractère comme un autre
- Il m'a dit de prendre le train
- Nous avons pris date

import re # le module re gère les expressions régulières

# la liste des 4 chaines à tester
L = [ \
"Je bois du thé", \
"Il apprend très vite", \
"Il m'a dit de prendre le train", \
"Nous avons pris date" ]

for ch in L : # Pour chaque chaine ch de la liste ...
    if re.search( 'd.t' , ch ) : # ... si la chaine ch contient un d et un t séparés par un caractère quelconque  ...
        print (ch) # ... on l'affiche.

Protéger des caractères spéciaux.

Vous l'avez compris, certains caractères ont des rôles spéciaux. On vient d'en voir 3 : ^, $ et .

Si on cherche ces caractères dans une chaine, il faut donc les protéger. Pour cela on utilise \

Exemple : Chercher dans une liste de 4 chaines celles qui contiennent un $.

Remarquez dans le code ci-dessous l'expression régulière '\$' :
On emploie l'antislach (\) quand on cerhce un caractère qui joue un rôle spécial dans les expressions régulières
re.search( '\$' , ch ) retourne true si la chaine ch contient '$' et false sinon.

Lancez le code et vérifiez que les trois chaines de caractères qui contiennent un '$' sont bien :
- C'est 400 $
- 1 $ = 0.98 €
- Tout à moins de un $. Si vous trouvez moins cher...

import re # le module re gère les expressions régulières

# la liste des 4 chaines à tester
L = [ \
"C'est 400 $", \
"1 $ = 0.98 €", \
"Tout à moins de un $. Si vous trouvez moins cher...", \
"£ n'est pas le symbole du dollar." ]

for ch in L : # Pour chaque chaine ch de la liste ...
    if re.search( '\$' , ch ) : # ... si la chaine ch contient $ ...
        print (ch) # ... on l'affiche.

Quelques petites questions avant d'aller plus loin :

Exercice à choix multiple : Chaines qui débutent par un point

Quelle est l'expression régulière pour chercher les chaines qui débutent par un point ?

Votre choix :

Bien !

Exercice à réponse courte : Chaines qui contiennent un a et un b séparés par deux caractères quelconques

Quelle est la bonne expression régulière pour chercher les chaines qui contiennent un a et un b séparés par deux caractères quelconques ?
Votre réponse:

Bien !

Exercice à réponse courte : Chaines qui terminent par un point

Quelle est la bonne expression régulière pour chercher les chaines qui terminent par un point ?
Votre réponse:

Bien !

Ressources utiles

Apprendre Ptyhon // Excellente page sur le sujet !!!! Simple, ludique et conviviale.
Regex101.com // Génial pour tester ses RegExp !!!!!!
Un site de l'INSERM
La doc Python
Wikibooks
Openclassrooms
Developpez.com
Tutorialpoints

L'ESSENTIEL AVEC DES EXEMPLES DE BASE

Les expressions régulières représentent des motifs qu'on recherche dans une chaîne de caractères.

Chercher un motif simple :

Exemple : Chercher dans une liste de 4 chaines celles qui contiennent la syllabe 'eau'

Remarquez dans le code ci-dessous la méthode search du module re :
re.search( 'eau' , ch ) retourne true si la chaine ch contient l'expression régulière 'eau' et false sinon.

Lancez le code et vérifiez que les deux chaines de caractères qui contiennent 'eau' sont bien :
- J'ai un chapeau
- Un beau soleil

Remarquez la sensibilité à la casse : Eau minérale ne matche pas puisque le E est en majuscule.

import re   # le module re gère les expressions régulières

# la liste des 4 chaines à tester
L = [ \
"J'ai un chapeau", \
"Un beau soleil", \
"Un chaud soleil", \
"Eau minérale" ]

for ch in L : # Pour chaque chaine ch de la liste ...
    if re.search( 'eau' , ch ) : # ... si la chaine ch contient 'eau' ...
        print (ch) # ... on l'affiche.

Rechercher au début.

Pour chercher un motif en début de chaine, on utilise l'accent circonflexe : ^.

Exemple : Chercher dans une liste de 4 chaines celles qui débutent par un 0 (chiffre 0).

Remarquez dans le code ci-dessous l'expression régulière '^0' :
On emploie l'accent circonflexe en début de RegExp pour signifier "débute par"
re.search( '^0' , ch ) retourne true si la chaine ch débute par '0' et false sinon.

Lancez le code et vérifiez que les deux chaines de caractères qui débutent par '0' sont bien :
- 01 23 45 67 89
- 007, my name is Bond, James Bond

import re # le module re gère les expressions régulières

# la liste des 4 chaines à tester
L = [ \
"01 23 45 67 89", \
"Je suis né le 01/12/50", \
"007, my name is Bond, James Bond", \
"Homer est un 0"
]

for ch in L : # Pour chaque chaine ch de la liste ...
    if re.search( '^0' , ch ) : # ... si la chaine ch débute par 0 ...
        print (ch) # ... on l'affiche.

Rechercher à la fin.

Pour chercher un motif en fin de chaine, on utilise le dollar : $.

Exemple : Chercher dans une liste de 4 chaines celles qui terminent par un r minuscule.

Remarquez dans le code ci-dessous l'expression régulière 'r$' :
On emploie le symbole $ (dollar) en fin de RegExp pour signifier "termine par"
re.search( 'r$' , ch ) retourne true si la chaine ch termine par 'r' et false sinon.

Lancez le code et vérifiez que la seule chaine de caractères qui termine par 'r' est bien :
- Laissez passer

import re # le module re gère les expressions régulières

# la liste des 4 chaines à tester
L = [ \
"Laissez passer", \
"J'ai démarré", \
"Un air de fête", \
"J'envoie cette lettre en recommandé avec AR" ]

for ch in L : # Pour chaque chaine ch de la liste ...
    if re.search( 'r$' , ch ) : # ... si la chaine ch termine par r...
        print (ch) # ... on l'affiche.

Rechercher un caractère spécial.

Les caractères spéciaux des expressions régulières sont ^ $ / . \ ? + * ( ) [ ] { } |
Pour chercher un de ces caractères, il faut le précéder d'un \

Exemple : Chercher dans une liste de 4 chaines celles qui contiennent le signe +.

Remarquez dans le code ci-dessous l'expression régulière '\+' :
Quand on cherche un caractère spécial dans une expression régulière, il faut le protéger grâce à l'antislash : \
re.search( '\+' , ch ) retourne true si la chaine ch contient + et false sinon.

Lancez le code et vérifiez que les 3 chaines de caractères qui contiennent + sont bien :
- C'est + ou - bien
- 3 + 4 = 7
- @+

import re # le module re gère les expressions régulières

# la liste des 4 chaines à tester
L = [ \
"C'est + ou - bien", \
"J'en veux plus", \
"3 + 4 = 7", \
"@+" ]

for ch in L : # Pour chaque chaine ch de la liste ...
    if re.search( '\+' , ch ) : # ... si la chaine ch contient +...
        print (ch) # ... on l'affiche.

Rechercher un motif OU un autre.

Le OU, c'est |

Exemple : Chercher dans une liste de 4 chaines celles qui contiennent "ce" OU "se".

Remarquez dans le code ci-dessous l'expression régulière 'ce|se':
Elle signifie qu'on cherche les chaines qui contiennent ce ou se.
re.search( 'ce|se' , ch ) retourne true si la chaine ch contient ce OU se et false sinon.

Lancez le code et vérifiez que les 3 chaines de caractères qui contiennent ce OU se sont bien :
- Laisse tomber !
- J'aime cet endroit
- Cochez la bonne case

import re # le module re gère les expressions régulières

# la liste des 4 chaines à tester
L = [ \
"Laisse tomber !", \
"Ce code respecte les bonnes pratiques", \
"J'aime cet endroit", \
"Cochez la bonne case" ]

for ch in L : # Pour chaque chaine ch de la liste ...
    if re.search( 'ce|se' , ch ) : # ... si la chaine ch contient ce OU se...
        print (ch) # ... on l'affiche.

Ignorer la casse.

Si on veur ignorer la casse dans une recherche, c'est à dire ne pas se préoccuper des majuscules et des minuscules, il faut utiliser re.IGNORECASE

Exemple : Chercher dans une liste de 4 chaines celles qui contiennent "ce" en ignorant la casse.

Remarquez dans le code ci-dessous l'instruction re.search( 'ce' , ch , re.IGNORECASE) :
Elle signifie qu'on cherche les chaines qui contiennent ce en ignorant la casse, c'est à dire ce OU Ce ou cE ou CE.
re.search( 'ce' , ch , re.IGNORECASE) retourne true si la chaine ch contient ce en ignorant la casse et false sinon.

Lancez le code et vérifiez que les 3 chaines de caractères qui contiennent ce en ignorant la casse sont bien :
- Ce code respecte les bonnes pratiques
- J'aime cet endroit
- La CEE est la Communauté Economique Européenne

import re # le module re gère les expressions régulières

# la liste des 4 chaines à tester
L = [ \
"Laisse tomber !", \
"Ce code respecte les bonnes pratiques", \
"J'aime cet endroit", \
"La CEE est la Communauté Economique Européenne" ]

for ch in L : # Pour chaque chaine ch de la liste ...
    if re.search( 'ce' , ch ,  re.IGNORECASE) : # ... si la chaine ch contient ce OU Ce ou cE ou CE...
        print (ch) # ... on l'affiche.

Autoriser plusieurs choix pour un même caractère.

On dispose des crochets [ ] qui permettent de donner la liste des caractères autorisés.

Exemple : Chercher dans une liste de 4 chaines celles qui contiennent une voyelle quelconque entourée par un s et un t.

Remarquez dans le code ci-dessous l'instruction re.search( 's[aeiouy]t' , ch ) :
Elle signifie qu'on cherche les chaines qui contiennent une voyelle quelconque entourée par un s et un t.
Notez bien [aeiouy] qui autorise un caractère parmi les 6 voyelles proposées.
re.search( 's[aeiouy]t' , ch ) retourne true si la chaine ch contient une voyelle quelconque entourée par un s et un t et false sinon.

Lancez le code et vérifiez que les 2 chaines de caractères qui matchent sont bien :
- L'autoroute est saturée
- Ce site est vraiment bien fait

import re # le module re gère les expressions régulières

# la liste des 4 chaines à tester
L = [ \
"La soute est pleine !", \
"L'autoroute est saturée", \
"Saturne est une planète hostile", \
"Ce site est vraiment bien fait" ]

for ch in L : # Pour chaque chaine ch de la liste ...
    if re.search( 's[aeiouy]t' , ch ) : # ... si la chaine ch contient une voyelle quelconque entourée par un s et un t...
        print (ch) # ... on l'affiche.

Autoriser plusieurs choix pour un même caractère, des listes déjà toutes prêtes.

Dans les crochets [ ], on peut faire référence à des listes pré-établies :

[A-Z] signifie "toutes les majuscules autorisées"
[a-z] signifie "toutes les minuscules autorisées"
[0-9] signifie "tous les chiffres autorisés"
mais aussi : [B-F] signifie "toutes les majuscules de B à F autorisées"
ou bien entendu : [A-Za-z], "toutes les lettres utilisées" (liste de listes)
... etc...

Exemple : Chercher dans une liste de 4 chaines celles qui débutent par une majuscule suivie d'un chiffre.

Remarquez dans le code ci-dessous l'instruction re.search( '^[A-Z][0-9]' , ch ) :
Elle signifie qu'on cherche les chaines qui débutent par une majuscule suivie d'un chiffre.
- ^ pour débute.
- [A-Z] pour une majuscule comme premier caractère.
- [0-9] pour un chiffre en deuxième caractère.

Lancez le code et vérifiez que les 2 chaines de caractères qui matchent sont bien :
- E15 est une autoroute européenne !
- H2O est le symbole chimique de l'eau

import re # le module re gère les expressions régulières

# la liste des 4 chaines à tester
L = [ \
"E15 est une autoroute européenne !", \
"H2O est le symbole chimique de l'eau", \
"L'airbus A320 est un gros avion....", \
"x1E23bn456 est ma clé de cryptage" ]

for ch in L : # Pour chaque chaine ch de la liste ...
    if re.search( '^[A-Z][0-9]' , ch ) : # ... si la chaine ch débute par une majuscule suivie d'un chiffre...
        print (ch) # ... on l'affiche.

Des raccourcis pour certaines listes très utilisées.

Dans les crochets [ ], on peut faire référence à des listes pré-établies :

\d n'importe quel chiffre <-> [0-9]
\D tout sauf un chiffre
\s un espace, une tabulation ou un retour à la ligne
\S tout sauf un espace, une tabulation ou un retour à la ligne
\w un mot : toute suite de caractères délimitée par des espaces, tabulation ou retour à la ligne

Exemple : Chercher dans une liste de 4 chaines celles qui contiennent 2 chiffres séparés par un caractère qui n'est pas un chiffre.

Remarquez dans le code ci-dessous l'instruction re.search( '\d\D\d' , ch ) :
Elle signifie qu'on cherche les chaines qui contiennent 2 chiffres séparés par un caractère qui n'est pas un chiffre.
- \d le premier chiffre,
- suivi \D, tout sauf un chiffre,
- et de \d, encore un chiffre.

Lancez le code et vérifiez que les 3 chaines de caractères qui matchent sont bien :
- Le virus H1N1 est redoutable
- Nous sommes le 10 09 2015
- x1E23bn456 est une bonne clé de cryptage

import re # le module re gère les expressions régulières

# la liste des 4 chaines à tester
L = [ \
"Le virus H1N1 est redoutable", \
"Nous sommes le 10 09 2015", \
"x1EF3bn456 n'est pas une bonne clé de cryptage", \
"x1E23bn456 est une bonne clé de cryptage" ]

for ch in L : # Pour chaque chaine ch de la liste ...
    if re.search( '\d\D\d' , ch ) : # ... si la chaine ch contient 2 chiffres séparés par un caractère qui n'est pas un chiffre...
        print (ch) # ... on l'affiche.

Eviter un caractère, l'opérateur sauf : [^].

Quand les crochets [ ] débutent par ^, la liste des caractères suivants représente les caractères non autorisés :

Exemple : Chercher dans une liste de 4 chaines celles qui contiennent un o qui n'est pas suivi d'un i.

Remarquez dans le code ci-dessous l'instruction re.search( 'o[^i]' , ch ) :
Elle signifie qu'on cherche les chaines qui contiennent un o qui n'est pas suivi d'un i.

Lancez le code et vérifiez que les 3 chaines de caractères qui matchent sont bien :
- Les oiseaux volent dans le ciel
- Allo, qui est à l'appareil ? C'est toi ?
- il n'est ni gros ni maigre

On a surligné les sous-chaines qui assurent la correspondance. Remarquez bien au passage que d'un point de vue linguistique, "contenir un o qui n'est pas suivi d'un i" n'est pas équivalent à "ne pas contenir la syllabe oi".

import re # le module re gère les expressions régulières

# la liste des 4 chaines à tester
L = [ \
"Les oiseaux volent dans le ciel", \
"Allo, qui est à l'appareil ? C'est toi ?", \
"il n'est ni gros ni maigre", \
"La voiture est blanche" ]

for ch in L : # Pour chaque chaine ch de la liste ...
    if re.search( 'o[^i]' , ch ) : # ... si la chaine ch contient un o qui n'est pas suivi d'un i ...
        print (ch) # ... on l'affiche.

Les quantificateurs :
Comme leur nom l'indique, les quantificateurs s'intéressent au nombre de fois qu'on va trouver tel ou tel caractère (ou groupe de caractères), il y en a quatre.

Le ? signifiera "au plus une fois".
Le + signifiera "au moins une fois".
Le * signifiera "0, une ou plusieurs fois".
Grâce aux accolades, on va fixer un nombre minimum ou maximum d'apparitions.

Le quantificateur ?, il signifie "au plus une fois".

Exemple : Chercher dans une liste de 4 chaines celles qui contiennent deux chiffres encadrant une lettre majuscule au plus.

Le titre de l'exemple signifie qu'on cherche dans la chaine une séquence de 2 chiffres ou une séquence de 2 chiffres séparés par une seule majuscule.

Remarquez dans le code ci-dessous l'instruction re.search( '\d[A-Z]?\d' , ch ) :
Elle signifie qu'on cherche les chaines qui contiennent deux chiffres encadrant une lettre majuscule au plus.
- \d, le premier chiffre de la séquence
- [A-Z]? : il est suivi de zéro ou d'une majuscule
- \d, puis d'un deuxième chiffre

Lancez le code et vérifiez que les 3 chaines de caractères qui matchent sont bien :
- Nous sommes le 10 novembre
- Le virus H1N1 est redoutable
- La référence 4i52E est valable

import re # le module re gère les expressions régulières

# la liste des 4 chaines à tester
L = [ \
"Nous sommes le 10 novembre", \
"Le virus H1N1 est redoutable", \
"La référence 4i52E est valable", \
"La référence 4i1-4FEZ3-3 n'est pas valable" ]

for ch in L : # Pour chaque chaine ch de la liste ...
    if re.search( '\d[A-Z]?\d' , ch ) : # ... si la chaine ch contient deux chiffres encadrant une lettre majuscule au plus ...
        print (ch) # ... on l'affiche.

Les quantificateurs quantifient ce qui les précède et non ce qui les suit !!!
Dans l'exemple précédent, le ? donne une information sur [A-Z].
Donc on commence à découvrir ici des RegExp un peu complexes. D'un point de vue linguistique, on n'a pas l'habitude qu'une information d'un phrase vienne modifier ce qui la précède.
Ceci nous force à faire des retour arrière auxquels notre esprit de lecteur n'est pas habitué.

Le quantificateur +, il signifie "au moins une fois".

Exemple : Chercher dans une liste de 4 chaines celles qui contiennent deux chiffres encadrant une lettre majuscule au moins.

Remarquez dans le code ci-dessous l'instruction re.search( '\d[A-Z]+\d' , ch ) :
Elle signifie qu'on cherche les chaines qui contiennent deux chiffres séparés par une ou plusieurs majuscules .
- \d, le premier chiffre de la séquence
- [A-Z]+ : il est suivi de une ou plusieurs majuscules
- \d, puis d'un deuxième chiffre

Lancez le code et vérifiez que les 2 chaines de caractères qui matchent sont bien :
- Le virus H1N1 est redoutable
- La référence 4i1-4FEZ3-3 est valable

import re # le module re gère les expressions régulières

# la liste des 4 chaines à tester
L = [ \
"Nous sommes le 10 novembre", \
"Le virus H1N1 est redoutable", \
"La référence 4i52E n'est pas valable", \
"La référence 4i1-4FEZ3-3 est valable" ]

for ch in L : # Pour chaque chaine ch de la liste ...
    if re.search( '\d[A-Z]+\d' , ch ) : # ... si la chaine ch contient deux chiffres séparés par une ou plusieurs majuscules ...
        print (ch) # ... on l'affiche.

Le quantificateur *, il signifie "zéro, une ou plusieurs fois".

Exemple : Chercher dans une liste de 4 chaines celles qui contiennent une minuscule et un chiffre dans cet ordre séparés par zéro, un ou plusieurs tirets.

Remarquez dans le code ci-dessous l'instruction re.search( '[a-z]-*\d' , ch ) :
Elle signifie qu'on cherche les chaines qui contiennent une minuscule et un chiffre séparés par zéro, un ou plusieurs tirets.
- [a-z], la minuscule
- -* : zéro, un ou plusieurs tirets
- \d, le chiffre

Lancez le code et vérifiez que les 3 chaines de caractères qui matchent sont bien :
- La référence 4i52E est valable
- La référence 4i-52E est valable
- La référence 4i------52E est valable

import re # le module re gère les expressions régulières

# la liste des 4 chaines à tester
L = [ \
"La référence 4i52E est valable", \
"La référence 4i-52E est valable", \
"La référence 4i------52E est valable", \
"La référence 4I1-4FEZ3-3 n'est pas valable" ]

for ch in L : # Pour chaque chaine ch de la liste ...
    if re.search( '[a-z]-*\d' , ch ) : # ... si la chaine ch contient une minuscule et un chiffre séparés par zéro, un ou plusieurs tirets ...
       print (ch) # ... on l'affiche.

Les quantificateurs accolades :
Le quantificateur { } indique un nombre de répétitions cherchées dans la chaîne

{k} : on cherche k fois le caractère précédent :
'ba{2}d' → on va trouver baad, mais pas bd, bad, baaad etc...
{k, } : on cherche au moins k fois le caractère précédent :
'ba{2,}d' → on va trouver baad, baaad, baaaad mais pas bd ni bad
{ ,k} : on cherche au plus k fois le caractère :
'ba{,2}d' → on va trouver bd, bad, baad, mais pas baaad...
{k,l} : on cherche entre k et l fois le caractère :
'ba{2,4}d' → on va trouver baad, baaad, baaaad mais pas bd, bad, baaaaad...

Exemple : Chercher dans une liste de 6 chaines celles qui contiennent une séquence de 2 à 4 chiffres encadrée par des @.

Remarquez dans le code ci-dessous l'instruction re.search( '@\d{2,4}@ , ch ) :
Elle signifie qu'on cherche les chaines qui contiennent une minuscule et un chiffre séparés par zéro, un ou plusieurs tirets.
- @, la première arobase
- \d{2,4}, une séquence de 2 à 4 chiffres
- @, la deuxième arobase

Lancez le code et vérifiez que les 3 chaines de caractères qui matchent sont bien :
- La référence @12@ est valable
- La référence @123@ est valable
- La référence @1234@ est valable

import re # le module re gère les expressions régulières

# la liste des 6 chaines à tester
L = [ \
"La référence @1@ n'est pas valable", \
"La référence @12@ est valable", \
"La référence @123@ est valable", \
"La référence @1234@ est valable", \
"La référence @12345@ n'est pas valable", \
"La référence @1@2@3@ n'est pas valable", ]

for ch in L : # Pour chaque chaine ch de la liste ...
   if re.search( '@\d{2,4}@' , ch ) : # ... si la chaine ch contient une séquence de 2 à 4 chiffres encadrée par des @ ...
       print (ch) # ... on l'affiche.

Le point (.) est un joker, il représente n'importe quel caractère.

Exemple : Chercher dans une liste de 6 chaines celles qui débutent par une majuscule et qui terminent par une minuscule.

Il faut comprendre l'implicite du titre : la chaîne débute par une majuscule et termine par une minuscule. Donc, entre les deux, on a n'importe quoi, en n'importe quelle quantité.

Remarquez dans le code ci-dessous l'expression régulière '^[A-Z].*[a-z]$'
- ^[A-Z] : on débute par une majuscule
- .* : n'importe quoi (le .), en n'importe quelle quantité (le *)
- [a-z]$ : on termine par une minuscule

Lancez le code et vérifiez que les 4 chaines de caractères qui matchent sont bien :
- Il apprend très vite
- Ton tel est le 01-23-45-67-89. Je le note
- Ho
- Nous avons pris date

import re # le module re gère les expressions régulières

# la liste des 6 chaines à tester
L = [ \
"Je bois du thé", \
"Il apprend très vite", \
"Ton tel est le 01-23-45-67-89. Je le note", \
"Ho", \
"le soleil se lève", \
"Nous avons pris date" ]

for ch in L : # Pour chaque chaine ch de la liste ...
    if re.search( '^[A-Z].*[a-z]$' , ch ) : # ... si la chaine ch débute par une majuscule et termine par une minuscule.  ...
        print (ch) # ... on l'affiche.

Les prenthèses servent à grouper les caractères.

Exemple : Chercher dans une liste de 4 chaines celles qui contiennent au moins 2 syllabes "to" successives.

Remarquez dans le code ci-dessous l'expression régulière '(to){2,}'
- (to) : un groupe de 2 caractères
- {2,} : quantifié au moins 2 fois

Lancez le code et vérifiez que les 2 chaines de caractères qui matchent sont bien :
- il est content toto
- Le cirque tototo vous accueille !

import re # le module re gère les expressions régulières

# la liste des 4 chaines à tester
L = [ \
"On est dans la stratosphère", \
"Toujours content ?", \
"il est content toto", \
"Le cirque tototo vous accueille !"]

for ch in L : # Pour chaque chaine ch de la liste ...
    if re.search( '(to){2,}' , ch ) : # ... si la chaine ch contient au moins 2 syllabes "to" successives.  ...
        print (ch) # ... on l'affiche.

Quelques exemples plus poussés

Chercher un numéro de téléphone.

Exemple : Chercher dans une liste de 6 chaines celles qui contiennent un numéro de téléphone au format 01 23 45 67 89.

Remarquez dans le code ci-dessous l'expression régulière '(\d\d ){4}\d\d'
- (\d\d ){4} : un groupe composé de 2 chiffres et un espace répété 4 fois.
- \d\d : les deux derniers chiffre

Lancez le code et vérifiez que les 4 chaines de caractères qui matchent sont bien :
- Ton tel est le 01 23 45 67 89. Je le note
- Ton tel est le 01 23 45 67 89 10. Bizarre !
- 01 23 45 67 89, OK !
- Voilà son tel : 01 23 45 67 89

Remarquez qu'on matche bien les chaines débutant et terminant par des numéros au bon format. C'est une bonne habitude à prendre de tester ses RegExp sur des débuts ou fin de chaine. C'est souvent là que ça bugue.

import re # le module re gère les expressions régulières

# la liste des 6 chaines à tester
L = [ \
"Je bois du thé", \
"Il apprend très vite", \
"Ton tel est le 01-23-45-67-89. Je le note", \
"Ton tel est le 01 23 45 67 89. Je le note", \
"Ton tel est le 01 23 45 67 89 10. Bizarre !", \
"01 23 45 67 89, OK !", \
"Voilà son tel : 01 23 45 67 89", \
"Voilà son tel mais il me manque 2 chiffres : 01 23 45 67", \
"le soleil se lève", \
"Nous avons pris date" ]

for ch in L : # Pour chaque chaine ch de la liste ...
    if re.search( '(\d\d ){4}\d\d' , ch ) : # ... si la chaine contient un numéro au format demandé  ...
        print (ch) # ... on l'affiche.

Des pièges à éviter

Oublier de protéger les caractères spéciaux

Exemple : Mal chercher les adresses mail du domaine iutsf.org

Dans la RegExp 'iutsf.org', on n'a pas protégé le point qui est un joker. On laisse donc passer les deux dernières fausses adresses du domaine iutsf.org

import re # le module re gère les expressions régulières

# la liste des adresses à tester
L = [ \
"gb@iutsf.org", \
"gb@gmail.com", \
"gb@free.fr", \
"gb@iutsfcorg", \
"gb@iutsfborg" ]

for ad in L : # Pour chaque adresse ad de la liste ...
    if re.search( 'iutsf.org' , ad ) : # ... si l'adresse est dans le domaine iutsf.org
                                       # sauf qu'on se trompe : le point est un joker
                                       # donc on accepte n'importe quel caractère entre
                                       # le f et le o
        print (ad) # ... on l'affiche.
    else :
        print ("Pas de correspondance")

Exemple : Bien chercher les adresses mail du domaine iutsf.org

En protégeant le joker . c'est mieux !
La bonne RegExp est donc 'iutsf\.org'

import re # le module re gère les expressions régulières

# la liste des adresses à tester
L = [ \
"gb@iutsf.org", \
"gb@gmail.com", \
"gb@free.fr", \
"gb@iutsfcorg", \
"gb@iutsfborg" ]

for ad in L : # Pour chaque adresse ad de la liste ...
    if re.search( 'iutsf\.org' , ad ) : # ... si l'adresse est dans le domaine iutsf.org
                                       # sauf qu'on se trompe : le point est un joker
                                       # donc on accepte n'importe quel caractère entre
                                       # le f et le o
        print (ad) # ... on l'affiche.
    else :
        print ("Pas de correspondance")

Le rôle de p dans le quantificateur {n,p}

Exemple : Attention au rôle de p dans le quantificateur {n,p}

On peut penser que la chaine "100000001" ne va pas correspondre à la RegExp '0{3,5}'. Mais comme le montre le premier affichage de cet exemple, il n'en est rien. Dès que le système rencontre les 3 premiers zéros en bleu, il ne lit plus la suite et sait que la chaîne matche.

Idem pour les deux chaines suivantes

import re # le module re gère les expressions régulières

# la liste des 3 chaines à tester
L = [ \
"100000001", \
"00007 Je suis le double James Bond", \
"A00000B58 est un bon identifiant" ]

for ch in L : # Pour chaque chaine ch de la liste ...
    if re.search( '0{3,5}' , ch ) : # ... si la chaine contient entre 3 et 5 zéros
        print (ch) # ... on l'affiche.
    else :
        print ("Pas de correspondance")

Exemple : Attention au rôle de p dans le quantificateur {n,p}

Si on veut utiliser le p du quantificateur {n,p}, c'est à dire le max, il faut que les caractères cherchés soient encadrés par d'autres caractères que la RegExp interdit, par exemple la regExp \D0{3,5}\D cherche une chaine contenant de 3 à 5 fois le chiffre 0 encadrés par un caractère qui n'est pas un chiffre. C'est pour cela que le deuxième affichage montre que la chaine ne matche pas (7 est un chiffre).

Avec la chaine "A00000B58 est un bon identifiant", ça matche. On a bien entre 3 et 5 zéros (5) et ils sont encadrés par des caractères qui ne sont pas des chiffres A et B.

import re # le module re gère les expressions régulières

# la liste des 3 chaines à tester
L = [ \
"100000001", \
"00007 Je suis le double James Bond", \
"A00000B58 est un bon identifiant" ]

for ch in L : # Pour chaque chaine ch de la liste ...
    if re.search( '\D0{3,5}\D' , ch ) : # ... si la chaine contient entre 3 et 5 zéros encadrés par un caractère
                                          # qui n'est pas un chiffre ...
        print (ch) # ... on l'affiche.
    else :
        print ("Pas de correspondance")

Chercher une chaine qui ne contient pas de r

Exemple : Vraie recherche de chaines sans r

Il faut bien mesurer que d'un point de vue sémantique, chercher une chaine qui ne contient pas de r est différent de chercher une chaine qui contient un caractère autre que r.
Pour chercher une chaine sans r, il faut chercher une chaine qui commence et qui finit par des caractères autres que r, en nombre quelconque : '^[^r]*$'

import re # le module re gère les expressions régulières

# la liste des 4 chaines à tester
L = [ \
"Brrrrrrrrrrr, il fait froid", \
"00007 Je suis le double James Bond", \
"Le roi est mort", \
"Rodin sculptait des statues" ]

for ch in L : # Pour chaque chaine ch de la liste ...
    if re.search( '^[^r]*$' , ch ) : # ... si la chaine débute et finit par autant de caractères qu'on veut excepté le r
        print (ch) # ... on l'affiche.
    else :
        print ("Pas de correspondance")

Mettre des espaces dans les expressions régulières pour les rendre plus lisibles

Exemple : Space bug

Pensez qu'insérer un espace dans une RegExp c'est chercher cet espace !
Donc, en général, il faut "tout laisser collé", ce qui rend le décryptage assez malaisé... Mais c'est comme ça.
Voyez ce qui arrive quand on insère un espace. Ici on cherchait les chaines contenant au moins 2 chiffres suivis du caractère a.
En insérant un espace entre les 2 chiffres et le a, c'est à dire en écrivant '\\d{2,} a' au lieu de '\\d{2,}a', on ne trouve pas les deux premières chaines qui correspondaient alors qu'on trouve la 3 ème qui ne correspond pas..

import re # le module re gère les expressions régulières

# la liste des 3 chaines à tester
L = [ \
"125a kzert", \
"mon code est le 14587a", \
"j'ai 17 ans" ]

for ch in L : # Pour chaque chaine ch de la liste ...
   if re.search( '\d{2,} a' , ch ) : # ... si la chaine contient au moins 2 chiffres suivis du caractère a
                                      # ... mais on a inséré malencontreusement un espace !
       print (ch) # ... on l'affiche.
   else :
       print ("Pas de correspondance")

Bon à savoir

La méthode group.

Quand on cherche des groupes dans une regexp, c'est à dire qu'on a utilisé des parenthèses, les groupes trouvés sont numérotés et réutilisables par la suite via la méthode group.

Vite un exemple !

Exemple : Découper une date et récupérer ses constituants.

La méthode search retourne un objet qu'on peut utiliser.
Cet objet possède notamment la méthode group qui permet de retrouver les groupes qu'on a isolés avec des parenthèses, comme ci-dessous.

import re # le module re gère les expressions régulières

ch = "je suis né le 12-04-2007 à 10 heures"

# avec une regexp, on cherche la date de naissance au format jj-mm-aaaa

retour = re.search('(\d\d)-(\d\d)-(\d\d)(\d\d)',ch) # récupération du résultat de la regexp dans l'objet retour

print (retour.group(0))
    # group(0) retourne la correspondance complète, c'est à dire la date 12-04-2007

print (retour.group(1))
    # group(1) retourne le premier groupe, c'est à dire le jour : 12

print (retour.group(2))
    # group(2) retourne le deuxième groupe, c'est à dire le mois : 04

print (retour.group(3))
    # group(3) retourne le troisième groupe, c'est à dire les deux premiers chiffres de l'année : 20

print (retour.group(4))
    # group(4) retourne le quatrième groupe, c'est à dire les deux derniers chiffres de l'année : 07

La méthode sub.

La méthode sub permet de remplacer une regexp par une autre dans une chaine de caractères.

Un exemple simple :

Un exemple plus élaboré :

Plus fort avec sub : remplacer des tirets pas des slash dans une date.

Il faut savoir que les groupes déterminés par des parenthèses sont numérotés, même sans utiliser la méthode group.
Les groupes sont référencés \1 \2 \3 ...par ordre d'apparition.
Vous allez comprendre avec l'exemple suivant.

Encore plus fort.... :

On peut ne pas utiliser les numéros des groupes mais donner nos propres noms à nos groupes, ça rend le code plus lisible !
Pour nommer un groupe, il faut faire suivre la parenthèse ouvrant le groupe :

d'un point d'interrogation,

d'un P majuscule

et du nom du groupe entre chevrons <>.

Dans l'expression de remplacement, il faut précéder le nom du groupe entre chevrons par \g (pour groupe)

La méthode findall.

Comme son nom l'indique, elle retourne la liste de toutes les occurrences de la regexp rencontrée dans une chaine de caractères.

Compiler une regexp.

On peut compiler une regexp avec la méthode compile, c'est utile quand elle doit resservir.

Cela permet de lui donner un nom pour alléger le code.

C'est bien expliqué sur Openclassrooms

Le quizz

Exercice à réponse courte : Chercher un motif simple

Donner la RegExp pour chercher le motif "oui".
Donner la réponse entre quotes.
Votre réponse:

Bien !

Exercice à réponse courte : Chercher un motif au début

Donner la RegExp pour chercher les chaines qui débutent par une majuscule.
Donner la réponse entre quotes.
Votre réponse:

Bien !

Exercice à réponse courte : Chercher un motif à la fin

Donner la RegExp pour chercher les chaines qui terminent par un point.
Donner la réponse entre quotes.
Votre réponse:

Bien !

Exercice à réponse courte : Chercher un caractère spécial

Donner la RegExp pour chercher les chaines qui terminent par un point d'interrogation.
Donner la réponse entre quotes.
Votre réponse:

Bien !

Exercice à réponse courte : Chercher un caractère spécial

Donner la RegExp pour chercher les chaines qui contiennent le motif "\$Linux\$".
Donner la réponse en quotes.
Votre réponse:

Bien !

Exercice à choix multiple : Chercher un caractère spécial

Donner la RegExp pour chercher les chaines qui terminent par le motif "[...]".

Votre choix :

Bien !

Exercice à choix multiple : Chercher un motif ou un autre

Donner la RegExp pour chercher les chaines qui débutent par B ou D.

Votre choix :

Bien !

Exercice à choix multiple : Ignorer la casse

Quelle est la bonne syntaxe pour savoir si la chaine L termine par jpg ou JPG ou Jpg ou plus généralement, par les 8 combinaisons possibles de jpg en acceptant majuscules ou minuscules ?

Votre choix :

Bien !

Exercice à choix multiple : Autoriser plusieurs caractères

Quelle est la bonne syntaxe pour savoir si la chaine L contient un "ou" ou un "oi" ou un "on" ou un "om" ?

Votre choix :

Bien !

Exercice à choix multiple : Les listes standards

Quelle chaine matche l'expression régulière '^[A-Z]|[0-9]$' ?

Votre choix :

Bien !

Exercice à choix multiple : Des raccourcis classiques

Quelle chaine matche l'expression régulière '\s\d\D\d\s' ?

Votre choix :

Bien !

Exercice à choix multiple : L'opérateur sauf

Quelle chaine ne matche pas l'expression régulière '^[^a-z]' ?

Votre choix :

Bien !

Exercice à choix multiple : Le quantificateur ?

Quelle chaine matche l'expression régulière 'html?$' ?

Votre choix :

Bien !

Exercice à choix multiple : Le quantificateur +

Quelle chaine matche l'expression régulière '^[A-Z][0-9]+' ?

Votre choix :

Bien !

Exercice à choix multiple : Le quantificateur *

Quelle chaine ne matche pas l'expression régulière '\d\D*\d' ?

Votre choix :

Bien !

Exercice à choix multiple : Les accolades

Quelle chaine ne matche pas l'expression régulière '[A-Z]\d{3,5}\s' ?

Votre choix :

Bien !

Exercice à choix multiple : La caractère .

Quelle chaine ne matche pas l'expression régulière '^[A-Z].*\.$' ?

Votre choix :

Bien !

Exercice à choix multiple : Grouper des caractères

Quelle chaine matche l'expression régulière '\D(\d-\d){3}\D' ?

Votre choix :

Bien !

Questions souvent posées

J'ai vu sur des sites des chaines de caractères débutant pas la lettre r avant les guillemets, c'est quoi ?

Il s'agit des raw-strings, des chaines brutes dans lesquelles tous les caractères sont traités pour ce qu'ils sont. Les caractères d'échappement sont ignorés.

C'est assez bien expliqué ici : http://sametmax.com/comment-marchent-les-raw-strings-en-python/

Cela n'a pas de rapport direct avec les RegExp mais ça simplifie leur écriture....

Je ne sais pas comment dire "qui ne contiennent que ..."

Il faut remplacer l'expression par "commencent et terminent par..."

Exemples de questions de cours

Décrire le but des expressions régulières.
Décrire l'intérêt des expressions régulières pour l'ASSR.
Donner 5 règles.

Des exercices pour s'entraîner

Exercice de code : Chercher des chaines blanches

Codez la RegExp entre quottes pour ne faire apparaître que les deux chaines blanches de la liste, c'est à dire celles qui contiennent un ou plusieurs espaces entre les guillemets.
Vous devrez obtenir la sortie suivante :

 La chaine "      " est une chaine blanche
 La chaine " " est une chaine blanche



# Codez la RegExp entre quottes pour ne faire apparaître que les deux chaines blanches de la liste
import re
L=['.568' , '23,54' , 'pi/4' , 'a23.47' , 'B52' , '' , '      ' , ' ', 'toto va à la plage']
for ch in L :
    if re.search('',ch) :
        print("La chaine \"" + ch + "\" est une chaine blanche")

Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : Chercher des chaines contenant 6 fois la lettre e, pas nécessairement contiguës

Codez la RegExp entre quottes pour ne faire apparaître que les chaines qui contiennent exactement 6 fois la lettre e.

 ate  errt e ttu e rrtee rt
 eeeeee
 etuureee ko ee rty
 sqdsrgeeeee rte
 eeeeee gtry
 dsdfqs eeeeee



# Codez la RegExp entre quottes pour ne faire apparaître que les 6 chaines qui contiennent
# exactement 6 fois la lettre e
import re
L=['atre etre naitre' , \
'ate  errt e ttu e rrtee rt' , \
'eeeeee' , \
'etuureee ko ee rty' , \
'sqdsrgeeeee rte' , \
'eeeeee gtry' , \
'dsdfqs eeeeee' , \
' ', \
'toto va à la plage']

for ch in L :
   if re.search('',ch) :
      print(ch)

Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.