Expressions Régulières – Regex en Python

Les expressions régulières (ou Regex en Python ) sont un outil puissant pour rechercher, manipuler et extraire des motifs dans des chaînes de caractères. Elles sont souvent utilisées pour des tâches telles que la validation de données, la recherche avancée et la transformation de texte.

En Python, vous pouvez utiliser le module re pour travailler avec des regex. Dans le cadre de pandas, les regex sont souvent utilisées avec des méthodes comme str.contains(), str.replace(), str.extract() pour manipuler des chaînes dans des colonnes de DataFrames.

Voici un guide pour utiliser des regex en Python et avec pandas.

1. Utilisation des regex en Python avec le module re

Le module re de Python permet de travailler directement avec des expressions régulières. Voici les méthodes les plus couramment utilisées :

• re.search() : Cherche le premier motif correspondant dans une chaîne.
• re.findall() : Trouve toutes les correspondances dans une chaîne.
• re.sub() : Remplace les motifs trouvés par une autre chaîne.
• re.match() : Vérifie si le motif correspond au début de la chaîne.

Exemple de base avec re.search() :

import re

# Rechercher un mot dans une chaîne
motif = r'chat'
texte = "Il y a un chat dans la maison."

resultat = re.search(motif, texte)

if resultat:
    print("Mot trouvé !")
else:
    print("Mot non trouvé.")

Exemple avec re.sub() pour remplacer un motif :

# Remplacer tous les chiffres par un symbole '#'
texte = "Mon numéro est 12345."
nouveau_texte = re.sub(r'\d', '#', texte)

print(nouveau_texte)

Résultat :

Mon numéro est #####.

2. Principaux motifs des expressions régulières

Voici quelques motifs courants dans les regex :

• . : Représente n’importe quel caractère sauf un saut de ligne.
• ^ : Représente le début de la chaîne.
• $ : Représente la fin de la chaîne.
• \d : Représente n’importe quel chiffre (0 à 9).
• \w : Représente n’importe quelle lettre ou chiffre (a-z, A-Z, 0-9, _).
• \s : Représente un espace blanc (espace, tabulation, saut de ligne).
• + : Représente une ou plusieurs occurrences du motif précédent.
• * : Représente zéro ou plusieurs occurrences du motif précédent.
• [] : Représente un ensemble de caractères. Par exemple, [aeiou] cherche n’importe quelle voyelle.
• | : Représente un ou logique. Par exemple, chien|chat cherche “chien” ou “chat”.
• () : Capture une sous-chaîne.

3. Utiliser les regex avec pandas

str.contains() : Chercher un motif dans une colonne

La méthode str.contains() permet de chercher des motifs dans une colonne d’un DataFrame.

Exemple : Chercher un mot commençant par “télé”

import pandas as pd

# Créer un DataFrame
data = {
    'Commentaire': ['J’adore la télévision', 'Mon téléphone est nouveau', 'Tablette de qualité']
}

df = pd.DataFrame(data)

# Chercher les mots commençant par "télé"
resultat = df[df['Commentaire'].str.contains(r'\btélé\w+', regex=True)]

print(resultat)

Résultat :

               Commentaire
0        J’adore la télévision
1  Mon téléphone est nouveau

str.replace() : Remplacer un motif par une chaîne de caractères

La méthode str.replace() permet de remplacer des motifs trouvés dans une chaîne par un autre texte.

Exemple : Remplacer tous les nombres par le mot “Nombre”

df = pd.DataFrame({
    'Texte': ['J’ai 10 pommes', 'Il a 15 livres', 'Aucun nombre ici']
})

# Remplacer les nombres par "Nombre"
df['Texte'] = df['Texte'].str.replace(r'\d+', 'Nombre', regex=True)

print(df)

Résultat :

               Texte
0    J’ai Nombre pommes
1   Il a Nombre livres
2       Aucun nombre ici

str.extract() : Extraire des motifs

str.extract() permet d’extraire des motifs spécifiques d’une chaîne de caractères et de les placer dans une nouvelle colonne.

Exemple : Extraire un numéro de téléphone d’un texte

# Créer un DataFrame avec des textes contenant des numéros de téléphone
data = {
    'Texte': ['Mon numéro est 123-456-7890', 'Contactez-moi au 987-654-3210', 'Aucun numéro ici']
}

df = pd.DataFrame(data)

# Extraire le numéro de téléphone (forme 123-456-7890)
df['Numero_Telephone'] = df['Texte'].str.extract(r'(\d{3}-\d{3}-\d{4})')

print(df)

Résultat :

                      Texte Numero_Telephone
0  Mon numéro est 123-456-7890    123-456-7890
1   Contactez-moi au 987-654-3210    987-654-3210
2               Aucun numéro ici             NaN

4. Utilisation avancée des regex avec des groupes

Les groupes dans les regex, définis par des parenthèses (), permettent d’extraire plusieurs parties d’une chaîne.

Exemple : Extraire un nom et un domaine d’adresses e-mail

data = {
    'Email': ['alice@example.com', 'bob@domain.com', 'charlie@site.org']
}

df = pd.DataFrame(data)

# Extraire le nom d'utilisateur et le domaine de l'email
df[['Utilisateur', 'Domaine']] = df['Email'].str.extract(r'(\w+)@(\w+\.\w+)')

print(df)

Résultat :

                Email Utilisateur     Domaine
0    alice@example.com       alice   example.com
1     bob@domain.com        bob     domain.com
2  charlie@site.org     charlie     site.org

5. Remplacer avec des fonctions conditionnelles

Vous pouvez aussi remplacer des valeurs à l’aide d’une fonction qui modifie les correspondances trouvées.

Exemple : Remplacer chaque mot commençant par “télé” par sa version majuscule

# Fonction de mise en majuscule
def majuscule(motif):
    return motif.group(0).upper()

# Remplacer les mots commençant par "télé" par leur version en majuscule
df['Commentaire'] = df['Commentaire'].str.replace(r'\btélé\w+', majuscule, regex=True)

print(df)

Résultat :

                  Commentaire
0      J’adore la TÉLÉvision
1      Mon TÉLÉphone est nouveau
2        Tablette de qualité

Les regex en Python, et plus spécifiquement avec pandas, offrent une méthode puissante et flexible pour rechercher, remplacer et extraire des motifs complexes dans des chaînes de caractères. Les principales méthodes à utiliser sont :

• str.contains() : Chercher un motif dans une colonne.
• str.replace() : Remplacer des motifs par une autre chaîne.
• str.extract() : Extraire des motifs spécifiques.
• re.search() et re.sub() pour une utilisation plus générique en Python.

Les regex sont particulièrement utiles pour manipuler des données textuelles, extraire des informations structurées ou nettoyer des ensembles de données dans des DataFrames pandas.

Comment rechercher un mot en regex avec des caractères spéciaux ?

Lorsque vous utilisez des expressions régulières (regex) pour rechercher un mot qui contient des caractères spéciaux, il est important de savoir que certains de ces caractères ont une signification particulière dans les expressions régulières (comme ., *, +, ?, ^, $, (, ), [, ], {, }, |, \, etc.). Pour rechercher un mot contenant ces caractères, vous devez les échapper en ajoutant un antislash (\) devant le caractère spécial ou utiliser une méthode comme re.escape() qui échappera automatiquement tous les caractères spéciaux.

1. Rechercher un mot avec des caractères spéciaux en échappant manuellement les caractères

Si vous connaissez les caractères spéciaux dans votre chaîne, vous pouvez les échapper en les précédant d’un antislash (\).

Exemple : Rechercher une adresse IP (qui contient des points)

Dans cet exemple, les points (.) sont des caractères spéciaux en regex, car ils représentent n’importe quel caractère. Pour rechercher une adresse IP, il faut échapper les points (\.).

import re

# Texte contenant une adresse IP
texte = "L'adresse IP du serveur est 192.168.1.1."

# Rechercher l'adresse IP avec des caractères spéciaux (les points doivent être échappés)
motif = r'192\.168\.1\.1'

# Recherche dans le texte
resultat = re.search(motif, texte)

if resultat:
    print("Adresse IP trouvée :", resultat.group())
else:
    print("Adresse IP non trouvée.")

Résultat :

Adresse IP trouvée : 192.168.1.1

2. Utiliser re.escape() pour échapper automatiquement les caractères spéciaux

La méthode re.escape() permet d’échapper automatiquement tous les caractères spéciaux dans une chaîne. C’est très pratique si vous ne savez pas à l’avance quels caractères peuvent être spéciaux dans votre texte.

Exemple : Utiliser re.escape() pour rechercher une chaîne avec des caractères spéciaux

import re

# Texte contenant des caractères spéciaux
texte = "Cherchons ce chemin de fichier : C:\\Utilisateurs\\Nom\\Documents\\fichier.txt"

# Utiliser re.escape() pour échapper tous les caractères spéciaux
motif = re.escape('C:\\Utilisateurs\\Nom\\Documents\\fichier.txt')

# Rechercher le chemin de fichier dans le texte
resultat = re.search(motif, texte)

if resultat:
    print("Chemin trouvé :", resultat.group())
else:
    print("Chemin non trouvé.")

Résultat :

Chemin trouvé : C:\Utilisateurs\Nom\Documents\fichier.txt

3. Utiliser str.contains() dans pandas avec des caractères spéciaux

Si vous travaillez avec des DataFrames dans pandas, vous pouvez utiliser la méthode str.contains() pour rechercher des motifs dans une colonne. Les caractères spéciaux doivent également être échappés dans les regex.

Exemple : Rechercher des chaînes avec des points (.) dans une colonne pandas

import pandas as pd

# Créer un DataFrame avec des adresses IP
data = {
    'Adresse_IP': ['192.168.1.1', '10.0.0.1', '127.0.0.1', '192.168.0.1']
}

df = pd.DataFrame(data)

# Rechercher les adresses IP commençant par "192."
resultat = df[df['Adresse_IP'].str.contains(r'192\.168\.1\.1', regex=True)]

print(resultat)

Résultat :

     Adresse_IP
0  192.168.1.1

4. Exemple complet avec plusieurs caractères spéciaux

Supposons que vous vouliez rechercher une chaîne contenant plusieurs caractères spéciaux comme : C:\Utilisateurs\Nom\Documents\fichier.txt dans un texte plus long.

Exemple :

import re

# Texte contenant des chemins de fichiers
texte = "Voici un chemin de fichier : C:\\Utilisateurs\\Nom\\Documents\\fichier.txt et un autre chemin."

# Utiliser re.escape() pour échapper les caractères spéciaux
chemin_a_chercher = re.escape("C:\\Utilisateurs\\Nom\\Documents\\fichier.txt")

# Rechercher le chemin dans le texte
resultat = re.search(chemin_a_chercher, texte)

if resultat:
    print("Chemin trouvé :", resultat.group())
else:
    print("Chemin non trouvé.")

Résultat :

Chemin trouvé : C:\Utilisateurs\Nom\Documents\fichier.txt

5. Autres cas de caractères spéciaux courants

5.1. Rechercher un mot avec des parenthèses

Les parenthèses sont des caractères spéciaux en regex, donc vous devez les échapper.

# Rechercher "Nom de fichier (final)"
texte = "Voici le Nom de fichier (final)."
motif = re.escape("Nom de fichier (final)")

resultat = re.search(motif, texte)
print(resultat.group())  # Affiche "Nom de fichier (final)"

5.2. Rechercher un mot avec des accolades

Les accolades {} sont aussi des caractères spéciaux qui doivent être échappés.

# Rechercher "Valeur {exemple}"
texte = "Voici la Valeur {exemple}."
motif = re.escape("Valeur {exemple}")

resultat = re.search(motif, texte)
print(resultat.group())  # Affiche "Valeur {exemple}"

• Les caractères spéciaux en regex comme ., *, +, ?, ^, $, (, ), [, ], {, }, |, et \ ont une signification particulière et doivent être échappés avec \ si vous voulez les rechercher tels quels.
• re.escape() est une méthode pratique pour échapper automatiquement tous les caractères spéciaux dans une chaîne.
• Les méthodes str.contains() et str.replace() de pandas acceptent des regex et permettent de chercher ou remplacer des motifs avec des caractères spéciaux dans les colonnes de DataFrames.

Ces techniques vous permettent de gérer efficacement les recherches en texte contenant des caractères spéciaux dans vos projets Python.

Comment utiliser regex pour emails ?

Les expressions régulières (regex) sont très utiles pour valider et manipuler des adresses e-mail dans des chaînes de caractères. En Python, avec le module re ou des méthodes de pandas comme str.contains() ou str.extract(), vous pouvez utiliser des regex pour identifier, extraire ou valider des adresses e-mail dans des textes ou colonnes de DataFrame.

Voici un guide pour utiliser des regex pour les e-mails.

1. Structure de base d’une adresse e-mail

Une adresse e-mail a généralement la structure suivante :

nom_utilisateur@domaine.ext

• nom_utilisateur : peut contenir des lettres, chiffres, points, tirets, et underscores.
• domaine : composé de lettres, chiffres, tirets, et points.
• ext (extension) : des lettres uniquement (comme .com, .fr, .org).

2. Regex de base pour les adresses e-mail

Voici une expression régulière simple pour capturer des adresses e-mail valides :

[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+

Explication :

• [a-zA-Z0-9_.+-]+ : Capture le nom d’utilisateur, qui peut contenir des lettres, chiffres, points, underscores (_), tirets (-) et le symbole plus (+).
• @ : Symbole obligatoire entre le nom d’utilisateur et le domaine.
• [a-zA-Z0-9-]+ : Capture le nom de domaine, composé de lettres, chiffres et tirets.
• \. : Capture le point séparant le domaine de l’extension.
• [a-zA-Z0-9-.]+ : Capture l’extension du domaine, qui peut être composée de lettres, chiffres, tirets, et points (comme .com, .fr).

3. Exemple en Python pour valider et extraire des e-mails

Exemple 1 : Valider un e-mail avec re.search()

import re

# Regex pour valider une adresse e-mail
motif_email = r'[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+'

# Exemple d'une chaîne contenant une adresse e-mail
texte = "Mon e-mail est alice@example.com, n'hésitez pas à me contacter."

# Rechercher une adresse e-mail
resultat = re.search(motif_email, texte)

if resultat:
    print("Adresse e-mail trouvée :", resultat.group())
else:
    print("Aucune adresse e-mail trouvée.")

Résultat :

Adresse e-mail trouvée : alice@example.com

Exemple 2 : Extraire toutes les adresses e-mail avec re.findall()

Si vous souhaitez extraire toutes les adresses e-mail présentes dans un texte, utilisez re.findall().

# Exemple d'une chaîne avec plusieurs adresses e-mail
texte = "Contactez alice@example.com ou bob@domain.org pour plus d'informations."

# Extraire toutes les adresses e-mail
emails = re.findall(motif_email, texte)

print("Adresses e-mail trouvées :", emails)

Résultat :

Adresses e-mail trouvées : ['alice@example.com', 'bob@domain.org']

4. Utiliser regex pour e-mails avec pandas

Si vous avez un DataFrame contenant des adresses e-mail dans une colonne, vous pouvez utiliser str.contains() pour rechercher les e-mails et str.extract() pour les extraire.

Exemple 1 : Rechercher des e-mails dans une colonne avec str.contains()

import pandas as pd

# Créer un DataFrame avec une colonne contenant des chaînes de caractères
data = {
    'Texte': ['Voici mon e-mail alice@example.com', 
              'Bob est à bob@domain.org', 
              'Pas d\'e-mail ici', 
              'Contactez-nous à support@service.com']
}

df = pd.DataFrame(data)

# Rechercher les lignes contenant une adresse e-mail
emails_present = df[df['Texte'].str.contains(motif_email, regex=True)]

print(emails_present)

Résultat :

                                        Texte
0              Voici mon e-mail alice@example.com
1                     Bob est à bob@domain.org
3            Contactez-nous à support@service.com

Exemple 2 : Extraire des adresses e-mail avec str.extract()

# Extraire les adresses e-mail présentes dans la colonne 'Texte'
df['Email'] = df['Texte'].str.extract(r'([a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+)', expand=False)

print(df)

Résultat :

                                        Texte                Email
0              Voici mon e-mail alice@example.com    alice@example.com
1                     Bob est à bob@domain.org       bob@domain.org
2                                Pas d'e-mail ici                NaN
3            Contactez-nous à support@service.com  support@service.com

5. Gérer les cas spécifiques

5.1. Validation stricte avec regex

Une regex plus stricte pour les adresses e-mail peut inclure des limitations sur la longueur ou des caractères spécifiques dans les parties du nom d’utilisateur ou du domaine.

Exemple pour limiter l’extension à 2-6 caractères :

[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z]{2,6}

Cette version limite l’extension du domaine à 2 à 6 lettres, ce qui est typique pour des domaines comme .com, .org, .fr, mais exclut les domaines à extension plus longue comme .photography.

5.2. Remplacer des adresses e-mail

Vous pouvez anonymiser ou masquer des adresses e-mail dans un texte à l’aide de re.sub().

# Remplacer les adresses e-mail par "[email masqué]"
texte = "Mon adresse e-mail est alice@example.com"
texte_modifie = re.sub(motif_email, "[email masqué]", texte)

print(texte_modifie)

Résultat :

Mon adresse e-mail est [email masqué]

6. Utiliser regex pour vérifier la validité d’un e-mail

Vous pouvez utiliser des regex dans des validations plus complexes. Par exemple, pour vérifier si un e-mail est bien formaté avant de l’accepter dans une application :

def valider_email(email):
    motif_email = r'[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z]{2,6}'
    if re.fullmatch(motif_email, email):
        return True
    else:
        return False

# Exemple de validation
email_test = "alice@example.com"
if valider_email(email_test):
    print(f"L'adresse '{email_test}' est valide.")
else:
    print(f"L'adresse '{email_test}' n'est pas valide.")

Résultat :

L'adresse 'alice@example.com' est valide.

Les expressions régulières offrent une méthode flexible et puissante pour travailler avec des adresses e-mail dans Python. Voici les méthodes clés à retenir :

• re.search() : Pour trouver la première occurrence d’une adresse e-mail dans un texte.
• re.findall() : Pour extraire toutes les adresses e-mail présentes dans une chaîne.
• re.sub() : Pour remplacer ou anonymiser des adresses e-mail dans un texte.
• str.contains() et str.extract() dans pandas : Pour rechercher ou extraire des e-mails dans des colonnes de DataFrame.

Ces techniques permettent de manipuler des adresses e-mail efficacement dans des projets impliquant des ensembles de données ou des validations textuelles.

Autres articles

Maîtriser l'utilisation de la méthode join en...

La méthode join en Python est un outil puissant pour...

Read more

Comment Gérer Efficacement le Budget Mariage avec...

Télécharger un modèle Excel automatisé de budget mariage automatisé avec...

Read more

Manipulation des Tableaux en Python avec Numpy

Numpy est une bibliothèque puissante et efficace pour la manipulation...

Read more