Contactez-nous

Fonctions du module re (search, match, findall, sub...)

Explorez les fonctions clés du module 're' en Python pour travailler avec les expressions régulières : search, match, findall, finditer, sub, split, et compile. Apprenez à rechercher, extraire, remplacer et diviser des chaînes de caractères.

re.search() : rechercher la première occurrence d'un motif

La fonction `re.search()` recherche la *première* occurrence du motif spécifié dans la chaîne de caractères.

Syntaxe :

import re

resultat = re.search(motif, chaine, flags=0)
  • `motif` : L'expression régulière à rechercher (une chaîne de caractères, généralement une chaîne brute).
  • `chaine` : La chaîne de caractères dans laquelle effectuer la recherche.
  • `flags` : (Optionnel) Des options qui modifient le comportement de la recherche (voir plus loin).
  • `re.search()` retourne :
    • Un objet *Match* si le motif est trouvé.
    • `None` si le motif n'est pas trouvé.

Exemple :

import re

texte = "J'aime les pommes et les poires."
motif = r"pommes"

resultat = re.search(motif, texte)

if resultat:
    print("Motif trouvé !")
    print("Position de départ :", resultat.start())  # 11
    print("Position de fin :", resultat.end())    # 17
    print("Partie correspondante :", resultat.group(0))  # pommes
else:
    print("Motif non trouvé.")

L'objet `Match` contient des informations sur la correspondance :

  • `start()` : Retourne la position de départ de la correspondance dans la chaîne.
  • `end()` : Retourne la position de fin de la correspondance dans la chaîne.
  • `group(0)` : Retourne la partie de la chaîne qui correspond au motif complet.
  • `group(n)` : Retourne la partie de la chaîne qui correspond au n-ième groupe capturant (si le motif contient des parenthèses).
  • `groups()` : Retourne un tuple contenant toutes les parties de la chaîne qui correspondent aux groupes capturants.

`re.search()` recherche le motif n'importe où dans la chaîne. Si vous voulez rechercher le motif uniquement au *début* de la chaîne, utilisez `re.match()`.

re.match() : rechercher au début de la chaîne

La fonction `re.match()` est similaire à `re.search()`, mais elle recherche le motif *uniquement au début* de la chaîne.

Syntaxe :

import re

resultat = re.match(motif, chaine, flags=0)
  • `motif` : L'expression régulière.
  • `chaine` : La chaîne de caractères.
  • `flags` : (Optionnel) Des options.
  • `re.match()` retourne :
    • Un objet *Match* si le motif est trouvé au début de la chaîne.
    • `None` si le motif n'est pas trouvé au début de la chaîne.

Exemple :

import re

texte = "Bonjour le monde"
motif = r"Bonjour"

print(re.match(motif, texte))  # Trouve (car le motif est au début)
print(re.search(motif, texte)) # Trouve

motif = r"monde"
print(re.match(motif, texte))  # None (car le motif n'est pas au début)
print(re.search(motif, texte)) # Trouve

`re.match()` est équivalent à `re.search()` avec un motif qui commence par `^`.

re.findall() : trouver toutes les occurrences (non chevauchantes)

La fonction `re.findall()` recherche *toutes* les occurrences du motif dans la chaîne et retourne une *liste* de toutes les correspondances (non chevauchantes).

Syntaxe :

import re

resultats = re.findall(motif, chaine, flags=0)
  • `motif` : L'expression régulière.
  • `chaine` : La chaîne de caractères.
  • `flags` : (Optionnel) Des options.
  • `re.findall()` retourne :
    • Une liste de chaînes de caractères, où chaque chaîne est une partie de la chaîne d'origine qui correspond au motif.
    • Si le motif contient des groupes capturants, la liste contiendra des tuples, où chaque tuple contient les correspondances pour chaque groupe.
    • Une liste vide si le motif n'est trouvé nulle part.

Exemple :

import re

texte = "J'ai 2 pommes, 3 poires et 5 bananes."
motif = r"\d+"

resultats = re.findall(motif, texte)
print(resultats)  # Affiche ['2', '3', '5'] (tous les nombres)

texte = "rouge, vert, bleu, vert"
motif = r"(vert)" #Avec un groupe
resultats = re.findall(motif,texte)
print(resultats) #Affiche ['vert', 'vert']

`re.findall()` est utile pour extraire toutes les occurrences d'un motif dans une chaîne.

re.finditer() : trouver toutes les occurrences (itérateur)

La fonction `re.finditer()` est similaire à `re.findall()`, mais au lieu de retourner une liste, elle retourne un *itérateur* qui produit des objets *Match* pour chaque correspondance (non chevauchante).

Syntaxe :

import re

iterateur = re.finditer(motif, chaine, flags=0)
  • `motif` : L'expression régulière.
  • `chaine` : La chaîne de caractères.
  • `flags` : (Optionnel) Des options.
  • `re.finditer()` retourne un itérateur qui produit des objets `Match` pour chaque correspondance.

Exemple :

import re

texte = "J'ai 2 pommes, 3 poires et 5 bananes."
motif = r"\d+"

for correspondance in re.finditer(motif, texte):
    print(f"Trouvé '{correspondance.group(0)}' à la position {correspondance.start()}")

# Affiche :
# Trouvé '2' à la position 6
# Trouvé '3' à la position 16
# Trouvé '5' à la position 29

`re.finditer()` est utile lorsque vous voulez traiter chaque correspondance individuellement (par exemple, pour obtenir des informations sur la position de la correspondance), ou lorsque vous travaillez avec de très grandes chaînes où vous ne voulez pas stocker toutes les correspondances en mémoire en même temps.

re.sub() : remplacer les occurrences d'un motif

La fonction `re.sub()` (substitution) permet de remplacer toutes les occurrences d'un motif dans une chaîne par une autre chaîne.

Syntaxe :

import re

nouvelle_chaine = re.sub(motif, remplacement, chaine, count=0, flags=0)
  • `motif` : L'expression régulière à rechercher.
  • `remplacement` : La chaîne de remplacement (peut contenir des références aux groupes capturants, voir plus loin). Peut aussi être une fonction.
  • `chaine` : La chaîne d'origine.
  • `count` : (Optionnel) Le nombre maximum de remplacements à effectuer. Par défaut (`count=0`), toutes les occurrences sont remplacées.
  • `flags` : (Optionnel) Des options.
  • `re.sub()` retourne une *nouvelle* chaîne de caractères avec les remplacements effectués. La chaîne d'origine n'est pas modifiée.

Exemple :

import re

texte = "J'aime les pommes et les poires."
motif = r"pommes|poires"
remplacement = "fruits"

nouvelle_chaine = re.sub(motif, remplacement, texte)
print(nouvelle_chaine)  # Affiche : J'aime les fruits et les fruits.

Vous pouvez utiliser des références arrières (`\1`, `\2`, etc.) dans la chaîne de remplacement pour faire référence aux groupes capturants du motif. `\g` peut aussi être utilisé si les groupes ont des noms.

Exemple (avec des groupes capturants) :

import re

texte = "Le prix est de 20 euros."
motif = r"(\d+) euros"
remplacement = r"\1 dollars"  # \1 fait référence au premier groupe capturant (les chiffres)

nouvelle_chaine = re.sub(motif, remplacement, texte)
print(nouvelle_chaine) # Affiche : Le prix est de 20 dollars.

Le remplacement peut aussi être une fonction. Dans ce cas, elle est appelée pour chaque correspondance, et elle reçoit en argument l'objet `Match`. La valeur de retour de la fonction est utilisée comme chaîne de remplacement.

import re

def majuscules(match):
    return match.group(0).upper() # Met en majuscule

texte = "bonjour le monde"
motif = r"\w+"

nouvelle_chaine = re.sub(motif, majuscules, texte) #On passe la fonction, pas le résultat de son appel
print(nouvelle_chaine) # Affiche BONJOUR LE MONDE

re.split() : diviser une chaîne selon un motif

La fonction `re.split()` permet de diviser une chaîne de caractères en une liste de sous-chaînes, en utilisant un motif d'expression régulière comme séparateur.

Syntaxe :

import re

sous_chaines = re.split(motif, chaine, maxsplit=0, flags=0)
  • `motif` : L'expression régulière qui sert de séparateur.
  • `chaine` : La chaîne à diviser.
  • `maxsplit` : (Optionnel) Le nombre maximum de divisions à effectuer. Par défaut (`maxsplit=0`), la chaîne est divisée à chaque occurrence du motif.
  • `flags` : (Optionnel) Des options.
  • `re.split()` retourne une liste de sous-chaînes.

Exemple :

import re

texte = "un, deux, trois,quatre, cinq"
motif = r",\s*"  # Virgule suivie de zéro ou plusieurs espaces

sous_chaines = re.split(motif, texte)
print(sous_chaines)  # Affiche ['un', 'deux', 'trois', 'quatre', 'cinq']

texte = "rouge,  vert  ,  bleu"
motif = r",\s*" #Virgule suivie de zéro ou plusieurs espaces
sous_chaines = re.split(motif, texte, maxsplit=1) # Division en deux maximum
print(sous_chaines) # ['rouge', 'vert  ,  bleu']

Si le motif contient des groupes capturants, les correspondances des groupes sont également incluses dans la liste résultante.

re.compile() : compiler une expression régulière

Si vous utilisez la même expression régulière plusieurs fois, il peut être plus efficace de la *compiler* une seule fois, puis de réutiliser l'objet compilé.

La fonction `re.compile()` compile une expression régulière et retourne un objet *expression régulière compilée* (un objet de type `re.Pattern`).

Syntaxe :

import re

motif_compile = re.compile(motif, flags=0)
  • `motif` : L'expression régulière (sous forme de chaîne).
  • `flags` : (Optionnel) Des options.
  • `re.compile()` retourne un objet expression régulière compilée.

Cet objet a des méthodes similaires aux fonctions du module `re` (`match`, `search`, `findall`, `sub`, etc.), mais vous n'avez plus besoin de spécifier le motif à chaque fois.

Exemple :

import re

# Compiler l'expression régulière
motif = r"\d+"
motif_compile = re.compile(motif)

# Utiliser l'objet compilé
texte1 = "Il y a 123 pommes."
texte2 = "Il y a 456 poires."

resultat1 = motif_compile.search(texte1)  # Au lieu de re.search(motif, texte1)
resultat2 = motif_compile.findall(texte2) # Au lieu de re.findall(motif, texte2)

print(resultat1.group(0))  # Affiche 123
print(resultat2) # Affiche ['456']

La compilation d'une expression régulière peut améliorer les performances si vous l'utilisez de manière répétée, car l'analyse et la compilation du motif ne sont effectuées qu'une seule fois.

Options (flags) : modifier le comportement des regex

Plusieurs fonctions du module `re` (et les méthodes équivalentes des objets expressions régulières compilées) acceptent un argument optionnel `flags` qui permet de modifier le comportement de la recherche.

Voici quelques options courantes :

  • `re.IGNORECASE` (ou `re.I`) : Effectue une recherche insensible à la casse (ignore la différence entre majuscules et minuscules).
  • `re.MULTILINE` (ou `re.M`) : Traite la chaîne comme plusieurs lignes. `^` correspond au début de chaque ligne (et pas seulement au début de la chaîne), et `$` correspond à la fin de chaque ligne (et pas seulement à la fin de la chaîne).
  • `re.DOTALL` (ou `re.S`) : Fait en sorte que le point `.` corresponde à *n'importe quel* caractère, y compris un saut de ligne (normalement, `.` ne correspond pas à un saut de ligne).
  • `re.VERBOSE` (ou `re.X`) : Permet d'écrire des expressions régulières plus lisibles, en ignorant les espaces blancs et en autorisant les commentaires (commençant par `#`).

Vous pouvez combiner plusieurs options en utilisant l'opérateur `|` (OU binaire).

Exemple :

import re

texte = "Bonjour le MONDE" 
motif = r"monde"

# Recherche insensible à la casse
resultat = re.search(motif, texte, re.IGNORECASE)  # Trouve "MONDE"
print(resultat.group())

Exemple (avec `re.VERBOSE` et `re.IGNORECASE`):

import re

motif = r"""(?x)   # Option VERBOSE (commentaire possible, espaces ignorés)
    \d+      # un ou plusieurs chiffres
    \s+      # un ou plusieurs espaces
    [a-z]+    # une ou plusieurs lettres minuscules
"""

print(re.search(motif, "123   abc", re.VERBOSE | re.IGNORECASE))