• 4 heures
  • Moyenne

Ce cours est visible gratuitement en ligne.

course.header.alt.is_video

course.header.alt.is_certifying

J'ai tout compris !

Mis à jour le 02/05/2018

Utilisez des expressions régulières

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

 

Dans ce chapitre vous découvrirez le pouvoir extraordinaire des expressions régulières ainsi que leur utilisation ! D'ailleurs, vous les utiliserez pour améliorer le projet.

Actuellement, notre projet ne reconnait pas le format de fichier que nous passons en argument. Ce serait assez agréable de ne plus spécifier le format et que notre programme le détermine par lui-même, n'est-ce pas ? C'est un parfait cas d'utilisation d'une expression régulière.

 

Les expressions régulières

Nous utilisons les expressions régulières, sans nous en rendre compte, dans le langage courant. Est-ce que la discussion suivante vous semble familière ?

- (téléphone) Pouvez-vous me donner votre nom s'il vous plait ?
- Oui bien sûr. Céline.
- Comment ? Cécile ?
- Non non. Céline. Avec un 'l'.
- Ah. Heu... Cécilia ?
- Non. Céline. La première lettre est C comme dans Crabe, puis vous avez 4 lettres : é comme Echelle, l comme Litre, i comme Internet, n comme Noisette. Et ça finit par e comme de l'Eau.
- Ah oui. Céline ! Comme Céline Dion.
- (soupir)

 

Que s'est-il passé ? Afin de me faire comprendre, j'ai épelé mon prénom en prenant des exemples que mon interlocuteur connaissait déjà. A chaque fois, j'ai porté son attention sur les parties similaires en occultant les autres.

Une expression régulière réalise la même opération mais de manière plus abstraite. Il s'agit d'une chaîne de caractères, souvent appelée motif, qui décrit selon une syntaxe particulière un ensemble de chaînes de caractères possible.

 

Par exemple, voici la représentation de Céline : ^C.{4}e$

 

Syntaxe

Les expressions régulières sont très puissantes lorsque vous cherchez des variantes d'un même motif. Par exemple, si nous souhaitions trouver dans une liste de prénoms tous ceux qui sont de la forme suivante : Céline, Cécile, Célia, Cécilia. Comment faire ?

Regardons en premier les éléments en commun : 

  • Les prénoms commencent par un 'C',

  • La seconde lettre est un 'é',

  • La quatrième lettre est un 'i'.

Nous avons, par extension, le modèle suivant :

  • Ils commencent par un 'C',

  • La seconde lettre est un 'é',

  • La troisième lettre est variable,

  • La quatrième lettre est un 'i',

  • Les lettres suivantes sont des n, e, l, a ou i. Il peut y en avoir plusieurs.

Comment représenter cela par une expression régulière ? De la manière suivante :

  • Ils commencent par un 'C' : ^C

  • La seconde lettre est un 'é' : é=> ^Cé

  • La troisième lettre est variable : .=> ^Cé.

  • La quatrième lettre est un 'i' : i=> ^Cé.i

  • Les lettres suivantes sont des n, e, l, a ou i. Il peut y en avoir plusieurs : [nelai]+=> ^Cé.i[nelai]+

L'expression régulière est alors la suivante : ^Cé.i[nelai]+

 

Cette syntaxe m'est complètement inconnue. Pourquoi commencer par un accent circonflexe alors qu'il n'est présent nulle part ?

Très bonne question ! La syntaxe des expressions régulières est assez particulière. Commençons par les signes les plus connus !

Représentation :

  • . : représente tout caractère (chiffre, lettre ou symbole)

  • ^ : représente le début d'une ligne. Tout signe le suivant sera considéré comme étant le début d'une ligne.

  • $ : représente la fin d'une ligne. Tout signe le précédant sera considéré comme étant à la fin de la ligne.

  • \w : représente un caractère venant d'un mot (a-z, A-Z, 0-9 ou tout caractère unicode comme 爱)

  • \d : représente un chiffre (0 - 9)

Occurrences :

  • * : aucune ou plusieurs occurrences

  • + : au moins une occurrence

  • [] : au moins un des caractères présents entre crochets

 

Sélectionner un groupe : les parenthèses

Une dernière utilisation assez commune concerne les parenthèses. Elles permettent de sélectionner uniquement ce qui est entre parenthèses dans un ensemble plus large.

Par exemple :

'^C(.{4})e$' # renvoie les quatre caractères après le 'C' du début et avant le 'e' de la fin.
'(^C)é.i[nelai]+' # renvoie le c du début

 

Cela permet de trouver les occurrences d'une expression régulière en ne renvoyant pas l'intégralité de la chaîne de caractères mais uniquement une partie.

 

Entrainez-vous !

Parfait ! Entrainez-vous quelques instants sur Pythex à trouver l'expression régulière qui correspond aux modèles suivants :

  • Numéro de téléphone (10 chiffres entre 0 et 10, commençant par 06 ou 07). Découvrez une proposition.

  • Adresse e-mail (caractères alphanumériques ou chiffres, @, caractères alphanumériques ou chiffres, point et caractères alphanumériques ou chiffres).

A vous de jouer !

 

La librairie standard re

Les expressions régulières ne sont pas spécifiques à Python. Par exemple, vous pouvez les utiliser pour filtrer le trafic dans Google Analytics ! Néanmoins, il faut utiliser une librairie qui vous donnera des méthodes permettant d'utiliser les expressions régulières.

Voyons tout de suite comment utiliser les expressions régulières dans notre projet. Nous allons réaliser cela en plusieurs étapes :

  • import de la librairie re

  • écriture de l'expression régulière

  • utilisation de la méthode appropriée

 

Import de la librairie re

Commencez par importer la librairie standard re (pour Regular Expression, Expression Régulière en anglais).

parite.py

import re

 

Ecriture de l'expression régulière

Nous allons chercher ce qui ressemble à un format de fichier dans la chaîne de caractères renvoyée par args.datafile. Pour rappel, voici notre code actuel :

def parse_arguments():
    parser = argparse.ArgumentParser()
    parser.add_argument("-d","--datafile",help="""CSV file containing pieces of information about the members of parliament""")
    ...
    return parser.parse_args()

if __name__ == '__main__':
    args = parse_arguments()
    try:
        datafile = args.datafile
        if datafile == None:
            raise Warning('You must indicate a datafile!')
    except Warning as e:
        lg.warning(e)
    else:
        if args.extension == 'xml':
            x_an.launch_analysis(datafile)
        elif args.extension == 'csv':
            c_an.launch_analysis(datafile, args.byparty, args.info, args.displaynames,
                           args.searchname, args.index, args.groupfirst)
    finally:
        lg.info('#################### Analysis is over ######################')

 

Un format de fichier suit le modèle suivant :

  • un ou plusieurs caractères (dont des espaces)

  • un point

  • trois caractères (nous nous limiterons à trois caractères pour le moment puisque nous ne prenons en charge que le csv et le xml)

Je vous laisse essayer avant de lire ma proposition !!

 

Utilisation de la méthode appropriée

La librairie offre de nombreuses méthodes, dont les deux suivantes :

  • search : trouve dans une chaîne de caractères la première occurrence correspond à l'expression régulière,

  • findall : trouve dans une chaîne de caractères toutes les occurrences correspondant à une expression régulière.

Utilisez la première, search, car nous ne souhaitons obtenir qu'un seul résultat.

if __name__ == '__main__':
    args = parse_arguments()
    try:
        datafile = args.datafile
        if datafile == None:
            raise Warning('You must indicate a datafile!')
    except Warning as e:
        lg.warning(e)
    else:
        e = re.search(r'^.+\.(\D{3})$', args.datafile)
        extension = e.group(1)
        if extension == 'xml':
            x_an.launch_analysis(datafile)
        elif extension == 'csv':
            c_an.launch_analysis(datafile, args.byparty, args.info, args.displaynames,
                           args.searchname, args.index, args.groupfirst, args.byage)
    finally:
        lg.info('#################### Analysis is over ######################')

 

La méthode group() renvoie les valeurs d'un groupe. Puisque vous souhaitez travailler avec la fin de la chaîne de caractères, sans le point, utilisez des parenthèses dans l'expression régulière et récupérez les valeurs grâce à group. Lire la documentation.

 

Code du chapitre

Le code du chapitre est à retrouver ici. 

Exemple de certificat de réussite
Exemple de certificat de réussite