Expressions régulières en python

En Python, une expression régulière est une chaîne de caractères précédée d’un r. La différence avec une chaîne de caractères quelconque s’illustre aisément :

  >>> print r"\bto\nto"

affiche

  \bto\nto

Opérations

Considérons le texte suivant :

  >>> import re
  >>> tt='cou2coucou22222cou'

Recherche de motifs

Satisfaisant une expression rationnelle

Pour retourner la liste des expressions de la forme 2+ (un nombre non nul de 2 :

  >>> re.findall(r'2+',tt)
  ['2', '22222']

De même, pour trouver toutes les expressions régulières de la forme ta suivi d'un nombre quelconque de s :

  >>> re.findall(r'tas*', 'ta tasse se tasse dans le tas')
  ['ta', 'tass', 'tass', 'tas']

Ne la satisfaisant pas

Pour retourner la liste des expressions qui ne sont pas de cette forme :

  >>> re.split(r'2+',tt)
  ['cou', 'coucou', 'cou']

Substitution

  >>> re.sub('2+','3','zrzer22zrer2fds222sdfd')
  'zrzer3zrer3fds3sdfd'

On peut restreindre la substitution à la condition qu'un nombre fixé d'occurences soit rencontrées :

  >>> re.sub('2{2,3}','3','zrzer22zrer2fds222sdfd')
  'zrzer3zrer2fds3sdfd'

Dans ce qui précède, {m,n} signifie : de m à n répétitions de ce qui précède.

Syntaxe des expressions rationnelles

Symboles de répétition

*

Un nombre quelconque de fois le symbole précédent.

+

Au moins une fois le symbole précédent.

?

0 ou une fois le symbole précédent.

{n}

n fois le symbole précédent.

{m,n}

Entre m et n fois le symbole précédent.

{m,}

Au moins m fois le symbole précédent.

{,n}

Au plus n fois le symbole précédent.

{m,n}?

Le plus petit nombre de fois, compris entre m et n, le caractère précédent.

Le ou

e1|e2

Intercepte l'expression e1 ou l'expression e2.

[ ]

Le ou généralisé à plusieurs caractères.

• On peut définir des plages avec -. Ainsi, [a-z] décrit toutes les lettres minuscules.
• On peut définir la plage inverse avec ^. Ainsi, [^a-z] décrit tout ce qui n'est pas une lettre minuscule.

Les autres symboles

.

Tout caractère, sauf le saut de ligne.

^

Le début d'une ligne.

$\setminus \$ $

La fin d'une ligne.

$\setminus $A

Le début d'une chaîne de caractères.

$\setminus $b

Le caractère d'espacement.

$\setminus $B

Le caractère d'espacement. A l'exception de ceux en début ou en fin de chaîne.

$\setminus $d

Un chiffre.

$\setminus $D

Un caractère qui n'est pas un chiffre.

$\setminus $s

Un caractère d'espacement quelconque (tabulation, saut de ligne...)

$\setminus $S

Le contraire de ce qui précède.

$\setminus $w

Un caractère alphanumérique, ou l'underscore \_.

$\setminus $W

Le contraire de ce qui précède.

$\setminus $Z

La fin de la chaîne.

Les options

IGNORECASE

Rend insensible à la casse.

  >>> re.findall(r'a','aaAAaazexAAaa',re.I)
  ['a', 'a', 'A', 'A', 'a', 'a', 'A', 'A', 'a', 'a']

UNICODE

Les symboles $\setminus $w, $\setminus $W, $\setminus $b, $\setminus $B, $\setminus $d, $\setminus $D, $\setminus $s et $\setminus $S se basent sur de l'unicode.

LOCALE

Rend les symboles $\setminus $w, $\setminus $W, $\setminus $b, $\setminus $B dépendant de la langue locale du système.

DOTALL

Le saut de ligne est également pris en compte dans $\setminus $b.

MULTILIGNE

Les symboles ^ et \$ interprètent le début et la fin de chaque ligne.

Combiner plusieurs expressions rationnelles

(e)

Forme un groupe avec l'expression e.

(?:e)

Intercepte le groupe e, mais ne le conserve pas.

(?<=e1)e2

Permet d'intercepter e2, pourvu qu'elle soit précédée d'e1.

(?<!e1)e2

Permet d'intercepter e2, pourvu qu'elle ne soit pas précédée de e1.

Exemples d'utilisation

Rechercher une expression

  >>> if re.search('gogo',chaine):
  ...     print chaine

...s'il trouve gogo dans la chaine de caractères chaine, il affiche chaine.

Afficher les balises

  >>> re.findall(r'<.*>','<div><p> Un paragraphe </p></div>')
  ['<div><p> Un paragraphe </p></div>']

Ce qui n'est pas le résultat souhaité. Pour obtenir la plus petite expression, à chaque fois :

  >>> re.findall(r'<.*?>','<div><p> Un paragraphe </p></div>')
  ['<div>', '<p>', '</p>', '</div>']