Expressions régulières en Python

Cet article explique les expressions régulières en Python.

Nous couvrirons un large éventail de sujets, de l'utilisation de base du module re aux correspondances de motifs complexes avec des expressions régulières.

YouTube Video

Expressions régulières en Python

Le module re est utilisé pour rechercher et manipuler des chaînes en utilisant des expressions régulières.

Qu'est-ce que le module re ?

Le module re est inclus dans la bibliothèque standard de Python et fournit des fonctionnalités pour manipuler des chaînes de caractères à l'aide d'expressions régulières. Les expressions régulières sont utilisées pour trouver, extraire ou remplacer efficacement des motifs spécifiques dans des chaînes de caractères.

Motifs de base pour les expressions régulières

Les expressions régulières définissent des motifs à l'aide de symboles spéciaux. Voici quelques motifs de base.

• .: Tout caractère unique
• ^: Début d'une chaîne
• $: Fin d'une chaîne
• \d: Tout chiffre (0-9)
• \w: Tout caractère alphanumérique (a-z, A-Z, 0-9, _)
• \s: Tout caractère d'espacement
• *: Zéro ou plusieurs répétitions
• +: Une ou plusieurs répétitions
• []: Classe de caractères (par exemple, [a-z] correspond aux alphabets en minuscules)

 1import re
 2
 3pattern = r"\d{3}-\d{4}"
 4text = "My postal code is 123-4567."
 5result = re.search(pattern, text)
 6if result:
 7    print(result.group())  # Output: 123-4567
 8
 9# Define a pattern using basic regular expression symbols
10pattern = r"^\w+\s\d+\s[a-zA-Z]+$"
11
12# Example text to test the pattern
13text = "Room 23 Tokyo"
14
15# Check if the pattern matches the text
16result = re.match(pattern, text)
17if result:
18    print("Matched:", result.group())
19else:
20    print("No match")

• Ce code vérifie d'abord si la chaîne correspond à un motif de code postal. Ensuite, il vérifie si la chaîne entière (du début à la fin) correspond à un motif composé d'un mot, d'un espace blanc, de chiffres, d'un espace blanc et d'un mot anglais. Cela vous aide à comprendre comment les éléments de base des expressions régulières peuvent être combinés.

Comment utiliser les fonctions de correspondance

re.match()

re.match() vérifie si le début de la chaîne correspond au motif spécifié.

1import re
2
3pattern = r"\w+"
4text = "Python is powerful"
5match = re.match(pattern, text)
6if match:
7    print(match.group())  # Output: Python

• Ce code vérifie si la chaîne commence par un caractère de mot (alphanumérique ou tiret bas). Le premier mot 'Python' correspond au motif et est renvoyé.

re.search()

re.search() parcourt toute la chaîne et retourne la première correspondance.

1import re
2
3pattern = r"powerful"
4text = "Python is powerful and versatile"
5search = re.search(pattern, text)
6if search:
7    print(search.group())  # Output: powerful

• Ce code recherche dans toute la chaîne le mot 'powerful' et renvoie la première correspondance. En conséquence, re.search() renvoie la chaîne correspondante 'powerful'.

re.findall()

re.findall() retourne toutes les correspondances avec le motif sous forme de liste.

1import re
2
3pattern = r"\b\w{6}\b"
4text = "Python is powerful and versatile"
5matches = re.findall(pattern, text)
6print(matches)  # Output: ['Python', 'strong']

• Ce code trouve tous les mots qui comptent exactement six caractères et les renvoie sous forme de liste. 'Python' dans la chaîne satisfait la condition, et la liste ['Python'] est renvoyée.

re.finditer()

re.finditer() retourne toutes les correspondances sous forme d'itérateur, ce qui permet de récupérer des informations détaillées pour chaque correspondance.

1import re
2
3pattern = r"\b\w{6}\b"
4text = "Python is powerful and versatile"
5matches = re.finditer(pattern, text)
6for match in matches:
7    print(match.group())  # Output: Python

• Ce code recherche séquentiellement tous les mots de six lettres et traite chaque correspondance via un itérateur. 'Python' correspond ici au motif et est renvoyé.

Remplacement et Division

re.sub()

re.sub() remplace les parties de la chaîne correspondant à l'expression régulière par une autre chaîne.

1import re
2
3pattern = r"\d+"
4text = "There are 100 apples"
5new_text = re.sub(pattern, "many", text)
6print(new_text)  # Output: There are many apples

• Ce code remplace tous les chiffres dans la chaîne par 'many'.

re.split()

re.split() divise la chaîne aux endroits correspondant à l'expression régulière.

1import re
2
3pattern = r"\s+"
4text = "Python is powerful"
5parts = re.split(pattern, text)
6print(parts)  # Output: ['Python', 'is', 'powerful']

• Ce code divise la chaîne selon un ou plusieurs caractères d'espacement. En conséquence, la chaîne est divisée en mots, produisant ['Python', 'is', 'powerful'].

Groupes et Captures

L'utilisation de regroupements avec des expressions régulières facilite l'extraction des sous-chaînes correspondantes. Enfermer entre parenthèses () capture cela en tant que groupe.

1import re
2
3pattern = r"(\d{3})-(\d{4})"
4text = "My postal code is 123-4567."
5match = re.search(pattern, text)
6if match:
7    print(match.group(1))  # Output: 123
8    print(match.group(2))  # Output: 4567

• Ce code extrait les nombres à 3 chiffres et à 4 chiffres comme groupes séparés d'un code postal de la forme '123-4567'. group(1) renvoie les trois premiers chiffres '123', et group(2) renvoie les quatre derniers chiffres '4567'.

Groupes nommés

L'utilisation de groupes nommés vous permet de récupérer les valeurs par des noms significatifs plutôt que de vous fier aux indices. Ci-dessous se trouve un exemple concret qui extrait la date et le niveau d'un journal.

1import re
2
3log = "2025-10-25 14:00:01 [ERROR] Something failed"
4
5pattern = r"(?P<date>\d{4}-\d{2}-\d{2}) (?P<time>\d{2}:\d{2}:\d{2}) \[(?P<level>[A-Z]+)\] (?P<msg>.*)"
6m = re.search(pattern, log)
7if m:
8    print(m.group("date"), m.group("time"), m.group("level"))
9    print("message:", m.group("msg"))

• Ce code utilise des groupes nommés pour extraire la date, l'heure, le niveau et le message d'une chaîne de journal. Il récupère les valeurs en utilisant des noms significatifs plutôt que des indices.

Utilisation des Options de Drapeaux

Le module re dispose de plusieurs options de drapeaux pour contrôler le comportement de la recherche.

• re.IGNORECASE (re.I) : Une option de drapeau qui rend la correspondance insensible à la casse.
• re.MULTILINE (re.M) : Une option de drapeau qui permet la correspondance sur plusieurs lignes.
• re.DOTALL (re.S) : Une option de drapeau où un point . correspond également aux caractères de nouvelle ligne.

1import re
2
3pattern = r"python"
4text = "Python is powerful"
5match = re.search(pattern, text, re.IGNORECASE)
6if match:
7    print(match.group())  # Output: Python

• Ce code recherche le mot 'python' sans tenir compte de la casse. En utilisant l'indicateur re.IGNORECASE, il détecte également 'Python'.

Avantages des objets d'expressions régulières (re.compile)

Compiler un motif avec re.compile en facilite la réutilisation et améliore la lisibilité. Vous pouvez également définir des indicateurs ici.

L'exemple suivant recherche à plusieurs reprises des correspondances sur plusieurs lignes en utilisant un motif compilé. Si vous utilisez fréquemment le même motif, le compiler avec re.compile améliore les performances.

1import re
2
3pattern = re.compile(r"User: (\w+), ID: (\d+)")
4text = "User: alice, ID: 1\nUser: bob, ID: 2"
5
6for m in pattern.finditer(text):
7    print(m.groups())

• Ce code utilise une expression régulière compilée pour extraire des noms d'utilisateur et des identifiants à partir de plusieurs lignes. re.compile améliore l'efficacité lors de la réutilisation du même motif et rend également le code plus lisible.

Applications

Par exemple, considérez un script qui extrait toutes les adresses e-mail d'un fichier texte.

1import re
2
3pattern = r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}"
4text = "Contact us at info@example.com or support@service.com."
5emails = re.findall(pattern, text)
6print(emails)  # Output: ['info@example.com', 'support@service.com']

• Ce code trouve toutes les adresses e-mail dans la chaîne et les extrait sous forme de liste.

Conclusion

Le module re est un outil puissant pour manipuler les chaînes en Python. Ici, nous avons abordé un large éventail allant de l'utilisation basique aux expressions régulières avancées en utilisant des regroupements et des options de drapeaux. Les expressions régulières en Python sont très puissantes et un outil indispensable pour le traitement de texte.

Vous pouvez suivre l'article ci-dessus avec Visual Studio Code sur notre chaîne YouTube. Veuillez également consulter la chaîne YouTube.

YouTube Video