Testeur de regex Python

Testez et déboguez vos expressions régulières Python en ligne avec le Testeur regex Python de Qodex. Mettez instantanément en surbrillance les correspondances et affinez les patterns utilisés pour la validation d'emails, les vérifications de mots de passe, la validation de numéros de téléphone et bien plus. Utilisez des données issues du Générateur d'email ou du Générateur UUID, et comparez le comportement avec les testeurs regex Java ou JavaScript.

Testeur de regex Python - Documentation

Qu'est-ce que le regex Python ?

Python utilise le module intégré re pour prendre en charge les expressions régulières. Les regex permettent de rechercher, d'extraire et de transformer du texte à l'aide de patterns. Ils sont largement utilisés pour :

La validation de données (e-mail, mot de passe, numéros de téléphone)
Le traitement et le nettoyage de texte
Le web scraping et l'analyse de journaux
L'extraction de patterns dans des chaînes de caractères

Composants essentiels du regex Python

Correspondance en temps réel : les correspondances sont mises en évidence au fur et à mesure de la saisie.
Syntaxe Python re : fonctionne exactement comme le moteur regex de Python.
Groupes de capture affichés : visualisez les groupes de capture et les correspondances.
Accessible aux débutants : collez votre regex et votre chaîne de test, aucun code requis.
Intégration avec d'autres outils : testez avec le Générateur d'adresses, le Générateur de mots de passe ou le Générateur d'adresses MAC.

Métacaractères

. : correspond à n'importe quel caractère sauf le saut de ligne (\n).
Exemple : a.b correspond à acb, a9b, etc., mais pas à ab.
^ : correspond au début d'une chaîne.
Exemple : ^Hello correspond à "Hello world" mais pas à "Say Hello".
$ : correspond à la fin d'une chaîne.
Exemple : world$ correspond à "Hello world" mais pas à "world peace".
| : opérateur logique OU.
Exemple : cat|dog correspond à "cat" ou "dog".

Classes de caractères

[abc] : correspond à a, b ou c.
Exemple : gr[ae]y correspond à "gray" et "grey".
[^abc] : correspond à tout caractère sauf a, b ou c.
Exemple : [^0-9] correspond à tout caractère non numérique.
[a-zA-Z] : correspond à n'importe quelle lettre.
Exemple : [A-Z] correspond uniquement aux majuscules.

Classes de caractères prédéfinies

\d : tout chiffre, équivalent à [0-9].
\D : tout caractère non numérique.
\s : tout espace blanc : espace, tabulation, saut de ligne, etc.
\S : tout caractère non blanc.
\w : tout caractère de mot : [a-zA-Z0-9_].
\W : tout caractère qui n'est pas un caractère de mot.

Quantificateurs

* : 0 occurrence ou plus.
Exemple : ab* correspond à "a", "ab", "abb"...
+ : 1 occurrence ou plus.
Exemple : ab+ correspond à "ab", "abb"... mais pas à "a".
? : 0 ou 1 occurrence (optionnel).
Exemple : ab? correspond à "a" ou "ab".
{n} : exactement n occurrences.
Exemple : a{3} correspond à "aaa".
{n,} : au moins n occurrences.
{n,m} : entre n et m occurrences.

Groupes

(abc) : groupe capturant qui enregistre la correspondance.
Exemple : (ha)+ correspond à "ha", "hahaha", etc.
(?:abc) : groupe non capturant ; regroupe sans sauvegarder.
Utile pour les quantificateurs ou les alternatives sans rétro-référence.

Pourquoi les groupes sont-ils importants ?

Le regroupement avec des parenthèses va au-delà de la simple correspondance : il permet d'extraire et de réutiliser des parties spécifiques du résultat (groupes capturants). Cela s'avère particulièrement utile pour :

Extraire des paires clé-valeur depuis un texte structuré
Analyser des dates, heures ou mesures depuis des journaux ou formulaires
Récupérer des parties d'une URL, d'une adresse e-mail ou d'un nom de fichier

Assertions avant et arrière (lookahead et lookbehind)

Les assertions avant et arrière font partie des assertions de largeur nulle dans les expressions régulières. Elles permettent de faire correspondre du texte en fonction de ce qui le précède ou le suit, sans inclure ces éléments dans la correspondance elle-même.

(?=abc) : assertion avant positive ; correspond si abc suit.
Exemple : \d(?=px) correspond à un chiffre suivi de "px".
(?!abc) : assertion avant négative ; correspond si abc ne suit pas.
Exemple : \d(?!px) correspond aux chiffres non suivis de "px".
(?<=abc) : assertion arrière positive ; correspond si précédé par abc.
Exemple : (?<=@)\w+ correspond au texte après "@" dans un e-mail.
(?<!abc) : assertion arrière négative ; correspond si non précédé par abc.

Ancres et limites

\b : limite de mot (entre \w et \W).
Exemple : \bcat\b correspond à "cat" dans "the cat sat" mais pas dans "catering".
\B : non-limite de mot.
\A : correspond au début de la chaîne (contrairement à ^, non affecté par re.MULTILINE).
\Z : correspond à la fin de la chaîne.

Indicateurs (flags)

Vous pouvez passer des indicateurs aux fonctions comme re.search() ou les utiliser en ligne avec (?i), (?m), etc.

re.IGNORECASE / re.I : correspondance insensible à la casse.
re.MULTILINE / re.M : ^ et $ correspondent au début et à la fin de chaque ligne.
re.DOTALL / re.S : le point . correspond à tout caractère, y compris les sauts de ligne.
re.VERBOSE / re.X : autorise les espaces et commentaires dans le pattern pour plus de lisibilité.
re.ASCII / re.A : restreint \w, \b, \d, \s, etc. aux caractères ASCII uniquement.

Remarque : Python ne prend pas en charge un indicateur global (g) comme JavaScript, car les fonctions re.findall() et re.finditer() retournent déjà toutes les correspondances par défaut.

Exemples d'expressions régulières Python

Exemple 1 : Validation d'e-mail

Essayez le Validateur regex e-mail Python et le Générateur d'email pour tester ce pattern de façon interactive.

import re
email_pattern = re.compile(r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$')
email = "user@example.com"
print("Email Valid:", bool(email_pattern.match(email)))

Exemple 2 : Vérification de la robustesse d'un mot de passe

password_pattern = re.compile(r'^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$')
password = "Aa123456!"
print("Password Strong:", bool(password_pattern.match(password)))

Exemple 3 : Extraction de mots depuis une chaîne

text = "Regex is #1 at pattern matching!"
word_pattern = re.compile(r'\b\w+\b')
for match in word_pattern.finditer(text):
    print("Found:", match.group())

Comment utiliser l'outil

Saisissez votre pattern regex et votre chaîne de test.
Visualisez instantanément les correspondances et les groupes de capture.
Copiez, modifiez et affinez votre pattern jusqu'à obtenir le résultat souhaité.
Utilisez les données d'autres outils pour simuler des cas réels.

Conseils pour écrire des expressions régulières efficaces en Python

Compilez les regex avec re.compile() pour de meilleures performances dans les boucles.
Utilisez les groupes nommés (?P<nom>...) pour un code plus lisible.
Utilisez re.VERBOSE pour les regex complexes avec commentaires et espaces.
Utilisez re.findall() pour récupérer toutes les correspondances sous forme de liste.
Évitez les regex pour les données imbriquées ou structurées : préférez des parsers dédiés.
Utilisez le Testeur regex Python de Qodex pour tester les cas limites avec des données réelles.