Les expressions régulières

Que signifie ce terme un peu abscons ? Il désigne, de manière générale, un ensemble de « jokers » pouvant servir à vérifier si une donnée correspond à une certaine forme. Tout bêtement, si c'est un nom propre, commence-t-il effectivement par une majuscule ? Si c'est un code postal, comprend-il effectivement cinq chiffres ? Si c'est un mot de passe, fait-il au minimum 12 caractères, dont au moins une majuscule et un chiffre ? Etc.

Les expressions régulières ne sont absolument pas une particularité spécifique à Python : on les retrouve dans beaucoup de langages ou de codages informatiques – les plus anciens se souviennent, émus, du ms-dos, de ses * et de ses ? pour désigner des noms de fichiers. On peut même en trouver quelques équivalents (rudimentaires) dans d'autres contextes : ainsi, au Scrabble, où le jeton vierge (joker) remplace n'importe quelle lettre de l'alphabet. La seconde chose est que comme très souvent en informatique, le principe de base est extrêmement simple, mais en combinant ces éléments simples, on arrive assez vite à des problèmes d'une complexité redoutable.

Avertissement : quand on travaille avec les expressions régulières, il faut toujours veiller à deux possibilités d'erreurs : la première, à laquelle on pense en premier, est celle de l'expression qui « n'attrape pas » toutes les informations qu'elle est censée coder. Mais il ne faut jamais perdre de vue l'erreur inverse : celle de l'expression qui « attrape » des informations qui ne sont pas pertinentes. On prendra donc toujours soin de tester ses expressions régulières par rapport à ces deux erreurs possibles.

Avertissement bis : faut-il le préciser, en matière d'erreurs, il est toujours possible d'avoir « fromage et dessert », et ainsi d'écrire une expression qui parvient à la fois à ne pas récupérer toutes les informations pertinentes et à récuperer certaines informations qui ne le sont pas...

Premiers éléments

Pour jouer avec les expression régulières, il est indispensable d'utiliser la bibliothèque adéquate, à savoir re (comme regular expression) :

import re

Cette bibliothèque offre diverses méthodes. Les deux principales sont search et findall. Search renvoie un résultat booléen indiquant si l'expression est présente ou non dans un texte donné (en fait, search renvoie un objet qui possède différentes propriétés indiquant le résultat de la recherche, mais qui peut être utilisé comme un simple booléen : c'est ce que nous ferons ici). Findall renvoie, sous forme de liste, toutes les occurrences de l'expression dans le texte.

Ainsi, dans une version très basique qui n'utilise pas les epressions régulières, si l'on écrit :

toto = re.search("monsieur", "Bonjour monsieur")
toto = re.search("madame", "Bonjour monsieur")

toto vaudra True tandis que tutu vaudra False.

Et si l'on écrit :

tata = re.findall("on", "Bonjour monsieur")

Le contenu de tata sera ["on", "on"] dans la mesure où ces deux caractères apparaissent deux fois dans la chaîne dans laquelle on les recherche.

Naturellement, sans expression régulière, tout ceci n'est pas très intéressant... mais cela va rapidement le devenir, dans la mesure où il est possible d'utiliser des « jokers » qui vont tout changer et qui, bien maniés, vont donner à ces instructions une incroyable puissance.

Les bases

• Le point . remplace n'importe quel caractère, en un exemplaire. Ainsi :
  re.search("li..e", "livre") vaut True
  re.search("li..e", "ligue") vaut True
  re.search("li..e", "longe") vaut False
  re.search("li..e", "lire") vaut False
  
• Le circonflexe ^ est le symbole d'ancrage initial ; il marque le début de la chaîne. Ainsi :
  re.search("^bon", "bonjour") vaut True
  re.search("^bon", "bonsoir") vaut True
  re.search("^bon", "abondant") vaut False
  
• Le dollar $ est le symbole d'ancrage final ; il marque la fin de la chaîne. Ainsi :
  re.search("tif$", "hâtif") vaut True
  re.search("tif$", "primitif") vaut True
  re.search("tif$", "rétifs") vaut False
  
• Les crochets [ ] marquent une liste de caractères, dans laquelle il suffit que l'un soit présent. Ainsi :
  re.search("[kwz]", "kapok") vaut True
  re.search("[kwz]", "zoo") vaut True
  re.search("[kwz]", "chat") vaut False
  
• Les crochets [ ] associés à un tiret marquent - une plage de caractères, c'est-à-dire une série, dans l'ordre de la table ascii. Ainsi :
  re.search("[a-e]", "bonbon") vaut True
  re.search("[a-e]", "matin") vaut True
  re.search("[a-e]", "moulin") vaut False
  
NB : On notera toute la différence entre « [A-Z][a-z] » et « [A-Za-z] » . « [A-Z][a-z] » correspond à deux caractères, une majuscule suivie d’une minuscule. « [A-Za-z] », en revanche, correspond à un caractère unique, qui est soit une majuscule, soit une minuscule.

Les quantificateurs

• Les accolades { } permettent de spécifier un nombre d'occurrences précis du caractère qui précède. Ainsi :
  re.search("n{2}", "ennuyeux") vaut True
  re.search("n{2}", "connard") vaut True
  re.search("n{2}", "canard") vaut False
  re.search("n{2, 4}", "canard") vaut False
  re.search("n{2, 4}", "cannnard") vaut True
  
• Le plus + marque 1 ou plusieurs occurrences du caractère qui précède, autrement dit « au moins une fois ». Ainsi :
  re.search("et+", "minet") vaut True
  re.search("et+", "dinette") vaut True
  re.search("et+", "fauteuil") vaut False
  
• Le point d'interrogation ? marque 0 ou 1 occurrences du caractère qui précède, autrement dit « au plus une fois ». Ainsi :
  re.search("car?", "caractère") vaut True
  re.search("car?", "tocante") vaut True
  re.search("car?", "parrain") vaut False
  
• L'étoile * marque 0, 1 ou plusieurs occurrences du caractère qui précède. Ainsi :
  re.search("te*", "guitare") vaut True
  re.search("te*", "nuitee") vaut True
  re.search("te*", "bouquin") vaut False
  
Au premier abord, il peut sembler inutile de préciser ainsi qu'on veut un caractère, ou une série de caractères, en n'importe quelle quantité (y compris zéro !). En fait, c'est très utile pour dire en substance « peu importe ce qui se trouve ici, et même si rien ne s'y trouve ».

Deux raffinements

• L'exclusion (^) : placé au début d'une expression régulière, l'accent circonflexe signifie comme on vient de le voir : « début de la chaîne ». Mais placé au début d'une plage, il change totalement de sens et marque l'exclusion. Ainsi, [^a-z] signifie : « n'importe quel caractère sauf une minuscule ». On peut ainsi formuler des règles dans les deux sens, soit en stipulant ce que l'on veut, soit en stipulant ce qu'on ne veut pas.
• La gourmandise : par défaut, les codes (ou quantificateurs) des expressions régulières sont dits « gourmands », c’est-à-dire qu’ils capturent autant de caractères que possible. Ainsi, si l'on recherche par un findall l'expression "(.*)" dans "Je vois (un chat) et (un chien) dans le jardin", on va récupérer la chaîne "(un chat) et (un chien)" : elle correspond au plus long extrait possible répondant à notre demande. Pour récupérer séparément ce qui se trouve entre chaque paire de parenthèses, nous devons obliger le résultat à être « non gourmand », c'est-à-dire à s'arrêter non à la dernière parenthèse rencontrée, mais dès la première. On utilisera alors le point d'interrogation dans l'expression, en recherchant dorénavant "(.*?)". La liste renvoyée par le findall comportera dorénavant deux éléments distincts : "(un chat)" et "(un chien)".

Autres utilisations

Les expressions régulières ne sont pas uniquement utilisables lorsqu'il s'agit de récupérer de l'information, comme on l'a fait avec search et findall.

On peut également les mobiliser pour traiter / modifier une chaîne, en particulier avec la méthode re.sub(), qui est en quelque sorte une version améliorée de replace : tout comme celle-ci, elle effectue un rechercher / remplacer systématique au sein d'une chaîne, mais elle admet que le motif à remplacer soit une expression régulière. Cette méthode est donc extrêmement puissante pour nettoyer ou transformer des données textuelles. À noter la variante re.subn() qui, en plus de la chaîne modifiée, renvoie également le nombre de remplacements effectués.

La méthode split(), que nous avons déjà vue et qui découpe la chaîne de caractère en liste, admet elle aussi qu'une expression régulière lui soit fournie en argument. Si dans le cas le plus simple, celui d'un fichier csv, cette expression se limite à un caractère (virgule, point-virgule, etc.), on peut donc imaginer de gérer des situations plus complexes.

Quelques questions-réponses

Pour commencer, avec search :

Et maintenant, avec findall. La chaîne dans laquelle on recherche l'expression est :
"Alice a 3 chats, Bob a 12 chiens, Clara a 1 chat et 2 poissons."

Les séquences d'échappement

Certains codes dits d'échappement (à cause de l'antislash qui les précède) remplacent avantageusement une information plus lourde, voire ouvrent des possibilités spécifiques. Voici les plus courantes :

• \b : délimiteur de mot. Ainsi, \bchat\b correspond à « chat » mais pas à « chatter » ni à « achat »
• \s : correspond à n'importe quel caractère d'espacement (espace, tabulation, nouvelle ligne, etc.).
• \d : correspond à n'importe quel chiffre. C'est donc l'équivalent de [0-9].
• \D : correspond à tout caractère qui n'est pas un chiffre.
• \n : correspond à une nouvelle ligne.

Et maintenant, c'est parti, nous allons écrire les expressions régulières nous-mêmes !

Quelques armes supplémentaires

Les groupes

Un outil supplémentaire très précieux est celui des groupes. Dans une expression régulière, un groupe définit un sous-ensemble (comme qui dirait : un groupe !) de caractères, auquel on peut appliquer des quantificateurs ou des traitements particuliers. Ainsi, (bof) désigne la suite de caractères « bof » – à ne surtout pas confondre avec [bof], qui signifie : « un b, un o ou un f ». Si l'on écrit (bof)+, le quantificateur + s'applique à l'ensemble du groupe ; autrement dit, l'expression désigne les séries de caractères qui incluent au moins une fois « bof », et donc « bof », « bofbof », « bofbofbof », etc.

Les groupes donnent donc davantage de souplesse aux quantificateurs. Mais ce n'est pas leur seul intérêt. Une expression peut en effet comprendre plusieurs groupes, soit à la suite les uns des autres, soit de manière imbriquée. Le grand intérêt de cette affaire est que ces groupes sont implicitement numérotés (indicés), dans l'ordre de l'ouverture des parenthèses. On peut ainsi faire du découpage, et récupérer ainsi les morceaux de la chaîne qui correspondent aux différents groupes. Prenons l'exemple d'une date au format jj/mm/aaaa. Normalement, sa recherche dans un texte ressemblera à :

[0-9]{2}/[0-9]{2}/[0-9]{4}

Ce qu'on peut également écrire sous la forme :

\d{2}/\d{2}/\d{4}

Ajoutons des groupes, et nous pourrons ensuite récupérer chaque information individuellement :

match = re.search("(\d{2})/(\d{2})/(\d{4})", texte)
if match:
   jour = match.group(1)
   mois = match.group(2)
   annee = match.group(3)

On remarque au passage que les groupes constituent ici des propriétés de l'objet match, qui est lui-même de type booléen – plus exactement,n dont la propriété par défaut est de type booléen.

Le « OU »

Maintenant que nous connaissonbs le groupe, nous pouvons employer l'opérateur pipe (prononcer « païpe »), soit |, fonctionne de la même manière que le OU booléen. Ainsi :

Les backreferences

La présence des groupes permet également d'utiliser ces indices dans l'expression régulière elle-même. Imaginons par exemple que nous souhaitions détecter, dans un texte, la présence de mots qui se suivent à l'identique (comme dans « Je suis très très content »). Pour faire très simple, nous pouvons considérer qu'un mot est une suite composée d'un nombre quelconque de caractères, suivi d'une espace, ce qui s'écrit '[a-zA-Z]+ '. Comment repérer le fait que ce mot soit répété ? En en faisant un groupe, puis en demandant si ce groupe est suivi par lui-même (ici, le groupe étant le premier et seul de l'expression, il porte l'indice 1 :

'([a-zA-Z]+) \1'

Les assertions positives anticipées (positive lookahead)

Cette appellation barbare désigne une idée assez simple : la possibilité de repérer des éléments dans une chaîne en quelque sorte « à l'avance », c'est-à-dire sans la parcourir. Le cas classique est celui où l'on recherche si la chaîne comporte certains éléments sans savoir dans quel ordre ceux se présentent. Imaginons le cas où nous voulons savoir si une phrase contient certains mots, dans un ordre quelconque. Avec l'approche standard, on pourrait imaginer de s'en sortir avec un OU – mais cette solution devient rapidement intenable si le nombre de mots augmente : pour 2 mots, il faut un OU, pour 3 mots il en faut 6, pour 4 mots il en faut 24, etc. C'est pourquoi le recours aux « APA » est fort utile.

Pour obtenir ce résultat, la syntaxe consiste à définir l'ensemble recherché comme un groupe, et à placer au début de celui-ci la séquence ?=.*. Ainsi, si nous cherchons si un texte contient, comme celui de Rabelais, « veaux », « vaches », « cochons », « poulets », et ceci dans n'importe quel ordre, l'expression régulière correspondante sera :

(?=.*\bveaux\b)(?=.*\bvaches\b)(?=.*\bcochons\b)(?=.*\bpoulets\b)

Et maintenant, à vous de jouer.