Traiter_regular_expression.py

Soyez le premier à donner votre avis sur cette source.

Snippet vu 4 482 fois - Téléchargée 15 fois

Contenu du snippet

Au départ je voulais extraire des adresses mail de mes messages. Je me suis frotté au ReGex, et je n'ai pas trouvé cela très simple de premier abord. Du coup, j'ai fait plusieurs tests en passant du plus simple au plus compliqué. C'est cet ensemble de tests que vous retrouverez ici et qui est à voir comme une démo. Le programme en Python se lance et propose 7 "problèmes" de RegEx avec les solutions associées (dont mon problème initial : l'extraction d'adresse mail).

Source / Exemple :


#!/usr/bin/python
#-*- coding:latin-1 -*-
import re

def traiter_expr1(expr):
    regex = re.compile(r"(\w+ss\w+)")
    m = regex.findall(expr)
    return(m)

def traiter_expr2(expr):
    regex = re.compile(r"([A-Z]{4})")
    m = regex.findall(expr)
    return(m)

def traiter_expr3(expr):
    regex = re.compile(r"(?!A{4}|B{4}|CCCC|DDDD)([A-Z]{4})")
    m = regex.findall(expr)
    return(m)

def traiter_expr4(expr):
    regex = re.compile(r"([-.\w]+)@([-\w]+\.[-.\w]+)")
    m = regex.findall(expr)
    return(m)

def traiter_expr5(expr):
    regex = re.compile(r"([-.\w]+)@(?![-\w]+\.[-\w]+\.[-\w]+)([-\w]+\.[-.\w]+)")
    m = regex.findall(expr)
    return(m)

def traiter_expr6(expr):
    regex = re.compile(r"(?![-.\w]+@[-\w]+\.[-\w]+\.[-\w]+)([-.\w]+@[-\w]+\.[-.\w]+)")
    m = regex.findall(expr)
    return(m)

def traiter_expr7(expr):
    regex = re.compile(r"([âêîôûàèìòùáéíóúäëïöüãõñç\w]+ff[âêîôûàèìòùáéíóúäëïöüãõñç\w]+)")
    m = regex.findall(expr)
    return(m)

print "Ceci est une démo ! Pour toute explication help(re)"
print "Voici l'expression qui va être traiter de différentes façons :\n"
EXPR = "D'abord 2 adresses mail classiques : jean-frederic.hochet@monFAI.net et jean-rene.ferais_plus@monfai.com\nPuis une autre moins classique AAAA_BBBB@ke_sako.mon_FAI.fr, je sais elle est bidon (comme les 2 autres), mais elle va servir; et enfin des expressions entre différents délimiteurs ABCD;EFGH;2345 67AA89-CCCC-CCCD\nFIN\n"
print EXPR
print "1-Cherchons tous les mots comprenant 2 s"
raw_input("Vous avez trouvé, alors appuyez sur une touche :")
print "la Regex = (\w+ss\w+)"
print "donne",traiter_expr1(EXPR)
print
print "2-Cherchons maintenant les groupes de 4 lettres majuscules"
raw_input("Vous avez trouvé, alors appuyez sur une touche :")
print "pour cela on utilise la Regex = ([A-Z]{4}) simple non ?"
print traiter_expr2(EXPR)
print
print "3-La même chose qu'en 2, sauf qu'on ne veut pas les groupes de 4 lettres :AAAA, BBBB, CCCC, DDDD"
raw_input("Vous avez trouvé, alors appuyez sur une touche :")
print "Cela se corse non?, la Regex devient (?!AAAA|BBBB|C{4}|D{4})([A-Z]{4})"
print traiter_expr3(EXPR)
print
print "4-Cette fois nous allons extraire les adresses mail"
print "Nous prendrons @ comme délimiteur, ce qui permet de sortir user et domaine"
raw_input("Vous avez trouvé, alors appuyez sur une touche :")
print "La Regex devient ([-.\w]+)@([-\w]+\.[-.\w]+)"
print traiter_expr4(EXPR)
print
print "5-En 4, on détecte aussi les domaines avec 2 points, qui sont des domaines très particuliers"
print "Comment ne pas les prendre en compte ?"
raw_input("Vous avez trouvé, alors appuyez sur une touche :")
print "Voici la réponse : Regex = ([-.\w]+)@(?![-\w]+\.[-\w]+\.[-\w]+)([-\w]+\.[-.\w]+)"
print "Cela commence à être compliqué non ?"
print "L'idée est de dire que l'on ne veut pas (le ?!) garder les domaines avec 2 points dans ceux que l'on va trouver"
print traiter_expr5(EXPR)
print
print "6-Comme en 5, mais on veut une liste d'adresses et non un tuple user,domaine"
print "A partir de 5, le plus simple est de faire user+\"@\"+domaine, mais on peut les extraire directement ..."
raw_input("Vous avez trouvé, alors appuyez sur une touche :")
print "Voici la réponse : Regex = (?![-.\w]+@[-\w]+\.[-\w]+\.[-\w]+)([-.\w]+@[-\w]+\.[-.\w]+)"
print "Si on ne voulait garder que les domaines avec 2 points, il faut mettre ?= au lieu de ?!"
print "Oui, les Regex peuvent vite devenir des usines à gaz"
print traiter_expr6(EXPR)
print
print "7-Vous l'avez constaté, jusqu'à présent, nous nous sommes contentés des lettres non accentuées"
print "Reprenez l'exemple 1 et remplacez ss par ff et bien vous ne trouverez pas \"différents\""
raw_input("Vous avez trouvé comment faire, alors appuyez sur une touche :")
print "Il suffit d'ajouter toutes les lettres accentuées comme ceci :"
print "Regex = ([âêîôûàèìòùáéíóúäëïöüãõñç\w]+ff[âêîôûàèìòùáéíóúäëïöüãõñç\w]+)"
print "Et je n'ai pas ajouté les majusules accentuées !"
print traiter_expr7(EXPR)
print
print "Voilà  n'est qu'un tout petit aperçu de ce que l'on peut faire avec les Regex"
print "N'oubliez pas la ressource inépuisable qu'est Internet"
print "Alors à vous de jouer maintenant"

Conclusion :


Il y a certainement des optimisations, mais la seule prétention de cette source est d'aider ceux qui comme moi ont à débuter dans l'utilisation des ReGex.
Je lance aussi un appel aux expérimentés, pour une solution plus générique (et donc plus condensée) au problème 3 : trouver tous les groupes de 4 lettres majuscules sauf les groupes de 4 lettres identiques.

A voir également

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.