Module re de Python

Celui de Pythonremodule est un module de bibliothèque standard pour gérer les expressions régulières.

Les expressions régulières (Regular Expression, abrégé en regex ou regexp) sont un outil puissant pour faire correspondre, rechercher et manipuler du texte.

En utilisantrele module, vous pouvez utiliser les expressions régulières en Python pour traiter les chaînes de caractères.

Pourquoi utiliser le module re ?

Dans le traitement de texte, nous avons souvent besoin de trouver des motifs spécifiques ou de remplacer certains caractères. Par exemple, valider des adresses e-mail, extraire des liens de pages web ou formater du texte. Écrire du code manuellement pour accomplir ces tâches peut être très fastidieux, alors que les expressions régulières offrent un moyen concis et efficace de résoudre ces problèmes.

Utilisation de base du module re

1. Importer le module re

Avant d'utiliserrele module, vous devez d'abord l'importer :

import re

2. Fonctions courantes du module re

2.1 re.match()

re.match()La fonction est utilisée pour faire correspondre une expression régulière depuis le début d'une chaîne. Si la correspondance réussit, elle renvoie un objet de correspondance ; sinon, elle renvoieNone。

Exemple

import re

pattern = r"hello"
text = "hello world"

match = re.match(pattern, text)
if match:
    print("Match successful:", match.group())
else:
    print("Match failed")

Sortie :

匹配成功: hello

2.2 re.search()

re.search()La fonction est utilisée pour rechercher la première correspondance d'une expression régulière dans une chaîne. Contrairement àre.match()différent,re.search()n'exige pas que la correspondance commence au début de la chaîne.

Exemple

import re

pattern = r"world"
text = "hello world"

match = re.search(pattern, text)
if match:
    print("Match successful:", match.group())
else:
    print("Match failed")

Sortie :

匹配成功: world

2.3 re.findall()

re.findall()La fonction est utilisée pour trouver toutes les sous-chaînes d'une chaîne qui correspondent à l'expression régulière, et renvoie une liste.

Exemple

import re

pattern = r"\d+"
text = "Il y a 3 pommes et 5 oranges."

matches = re.findall(pattern, text)
print("Nombres trouvés :", matches)

Sortie :

找到的数字: ['3', '5']

2.4 re.sub()

re.sub()La fonction est utilisée pour remplacer les parties d'une chaîne qui correspondent à l'expression régulière.

Exemple

import re

pattern = r"pomme"
text = "J'ai une pomme."

new_text = re.sub(pattern, "banane", text)
print("Texte remplacé :", new_text)

Sortie :

替换后的文本: I have an banana.

Syntaxe de base des expressions régulières

1. Caractères ordinaires

Les caractères ordinaires (tels que les lettres, les chiffres) correspondent directement à eux-mêmes.

Exemple

import re

pattern = r"chat"
text = "Le chat est sur le tapis."

match = re.search(pattern, text)
if match:
    print("Match successful:", match.group())

Sortie :

匹配成功: cat

2. Caractères spéciaux

Il existe certains caractères spéciaux dans les expressions régulières qui ont une signification particulière. Par exemple :

  • .: Correspond à un seul caractère quelconque (sauf un saut de ligne).
  • *: Correspond au caractère précédent zéro ou plusieurs fois.
  • +: Correspond au caractère précédent une ou plusieurs fois.
  • ?: Correspond au caractère précédent zéro ou une fois.
  • \d: Correspond à tout caractère chiffre (équivalent à[0-9]）。
  • \w: Correspond à toute lettre, tout chiffre ou le caractère de soulignement (équivalent à[a-zA-Z0-9_]）。

Exemple

import re

pattern = r"\d+"
texte = "Le prix est de 100 dollars."

match = re.search(pattern, text)
if match:
    print("Match successful:", match.group())

Sortie :

匹配成功: 100

3. Ensembles de caractères

Les ensembles de caractères servent à faire correspondre n'importe quel caractère d'un ensemble. Par exemple,[abc]matchesa、bouc。

Exemple

import re

motif = r"[aeiou]"
text = "Bonjour le monde !"

matches = re.findall(pattern, text)
print("Voyelles trouvées :", matches)

Sortie :

找到的元音字母: ['e', 'o', 'o']

4. Groupement

Le groupement vous permet de combiner plusieurs caractères ensemble et d'opérer sur eux. Par exemple,(abc)matchesabc。

Exemple

import re

pattern = r"(ab)+"
text = "ababab"

match = re.search(pattern, text)
if match:
    print("Match successful:", match.group())

Sortie :

匹配成功: ababab

Exercices pratiques

Exercice 1 : Valider des adresses e-mail

Écrivez une expression régulière pour valider le format d'une adresse e-mail.

Exemple

import re

pattern = r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$"
email = "[email protected]"

if re.match(pattern, email):
    print("Adresse e-mail valide")
else:
    print("Adresse e-mail invalide")

Exercice 2 : Extraire des numéros de téléphone

Écrire une expression régulière pour extraire les numéros de téléphone d'un texte.

Exemple

import re

pattern = r"\d{3}-\d{3}-\d{4}"
text = "Mon numéro de téléphone est 123-456-7890."

match = re.search(pattern, text)
if match:
    print("Numéros de téléphone trouvés:", match.group())

1. Fonctions de base

Méthode Description Exemple
re.compile(pattern) Précompiler une expression régulière (améliore les performances de réutilisation) pat = re.compile(r'\d+')
re.search(pattern, string) Rechercher la première correspondance dans une chaîne re.search(r'\d+', 'a1b2')→ correspondances'1'
re.match(pattern, string) Correspondance depuis le début de la chaîne re.match(r'\d+', '123a')→ correspondances'123'
re.fullmatch(pattern, string) La chaîne entière correspond entièrement re.fullmatch(r'\d+', '123')→ correspondances'123'
re.findall(pattern, string) Retourner une liste de toutes les correspondances non chevauchantes re.findall(r'\d+', 'a1b22c') → ['1', '22']
re.finditer(pattern, string) Retourner un itérateur de toutes les correspondances (y compris les informations de position) for m in re.finditer(r'\d+', 'a1b2'): print(m.group())
re.sub(pattern, repl, string) Remplacer les correspondances re.sub(r'\d+', 'X', 'a1b2') → 'aXbX'
re.split(pattern, string) Diviser la chaîne par les correspondances re.split(r'\d+', 'a1b2c') → ['a', 'b', 'c']
re.escape() Échapper les caractères spéciaux re.escape("C:\\Users\\test.txt")
re.purge() Vider le cache re.purge()

2. Objet Match (Match) méthodes/attributs

Méthode/Attribut Description Exemple
group() Renvoie toute la chaîne correspondante m.group() → 'abc'
group(n) Renvoie le contenu du n-ième groupe de capture m = re.search(r'(\d)(\d)', '12'); m.group(1) → '1'
groups() Renvoie un tuple de tous les groupes de capture m.groups() → ('1', '2')
start()/end() Position de début/fin de la correspondance m.start() → 0
span() Renvoie la plage de correspondance(start, end) m.span() → (0, 2)

3. Métacaractères d'expression régulière (partiel)

Métacaractère Description Exemple de correspondance
. Correspond à n'importe quel caractère (sauf saut de ligne) a.c → 'abc'
\d Correspond à un chiffre \d+ → '123'
\D Correspond à un caractère autre qu'un chiffre \D+ → 'abc'
\w Correspond à un caractère de mot (lettre, chiffre, tiret bas) \w+ → 'Ab_1'
\W Correspond à un caractère autre qu'un caractère de mot \W+ → '!@#'
\s Correspond à un caractère d'espacement (espace, tabulation, etc.) \s+ → ' \t'
\S Correspond à un caractère autre qu'un espacement \S+ → 'abc'
[] Jeu de caractères [A-Za-z]→ n'importe quelle lettre
^ Correspond au début d'une chaîne ^\d+→ chiffre au début
$ Correspond à la fin d'une chaîne \d+$→ chiffre à la fin
* Correspond au caractère précédent zéro ou plusieurs fois a* → '', 'aaa'
+ Correspond au caractère précédent une ou plusieurs fois a+ → 'a', 'aaa'
? Correspond au caractère précédent zéro ou une fois a? → '', 'a'
{m,n} Correspond au caractère précédent de m à n fois a{2,3} → 'aa', 'aaa'
| Opération OU cat|dog → 'cat'ou'dog'
() Groupe de capture (\d+)→ extraire les chiffres

4. Options de compilation (flagsparamètre)

Option Description Exemple
re.IGNORECASE (re.I) Ignorer la casse re.search(r'abc', 'ABC', re.I)
re.MULTILINE (re.M) Mode multiligne (affecte^et$） re.findall(r'^\d+', '1\n2', re.M) → ['1', '2']
re.DOTALL (re.S) Soit.Correspond à tous les caractères, y compris les sauts de ligne re.search(r'a.*b', 'a\nb', re.S)
re.ASCII Soit\w, \Wetc. ne correspondent qu'aux caractères ASCII re.search(r'\w+', 'こん', re.ASCII)→ aucune correspondance
re.VERBOSE (re.X) Autoriser les commentaires et les espaces dans l'expression régulière re.compile(r'''\d+ # 匹配数字''', re.X)

Exemple

1. Extraire les adresses e-mail

Exemple

import re

text = "Contact : [email protected], [email protected]"
emails = re.findall(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', text)
print(emails)  # Sortie : ['[email protected]', '[email protected]']

2. Remplacer les formats de date

Exemple

date_str = "Nous sommes le 05-15-2023"
new_str = re.sub(r'(\d{2})-(\d{2})-(\d{4})', r'\3year\1month\2day', date_str)
print(new_str)  # Sortie : "Nous sommes le 2023-05-15"

3. Correspondance multi-conditions

Exemple

pattern = re.compile(r'''
    ^(?P<username>\w+) # nom d'utilisateur
    :(?P<password>\S+) # mot de passe
    @(?P<domain>\w+\.\w+) # domaine
$''', re.VERBOSE)

m = pattern.match("john:[email protected]")
if m:
    print(m.groupdict())  # Sortie : {'username': 'john', 'password': 'pass123', 'domain': 'example.com'}

4. Fractionner des chaînes complexes

Exemple

text = "Apple1Banana2Cherry3Date"
parts = re.split(r'\d+', text)
print(parts)  # Sortie : ['Apple', 'Banana', 'Cherry', 'Date']

Notes

  1. Chaînes brutes: Il est recommandé d'utiliser des chaînes brutes pour les expressions régulières (r'\d'), afin d'éviter les conflits de caractères d'échappement.

  2. Correspondance gloutonne: Correspondance gloutonne par défaut (par ex..*correspondra à la correspondance la plus longue possible), vous devez utiliser.*?pour implémenter une correspondance non gourmande.

  3. Optimisation des performances: les expressions régulières fréquemment utilisées doivent privilégier l'utilisation dere.compile()précompilation.

  4. Problèmes de backtracking: les expressions régulières complexes peuvent entraîner des problèmes de performance (tels que des quantificateurs imbriqués(a+)+）。

Autres extensions