Appariement et recherche basées sur les motifs textuels avec le module re

Le module re du langage Python vous donne les outils nécessaires pour traiter les textes avec les expressions régulières. Dans cet article, vous apprendrez comment apparier ou rechercher dans une chaîne de caractères en respectant un motif de texte spécifique (ie. expression régulière).

Si le texte que vous essayez de faire correspondre est un texte littéral simple, vous pouvez souvent utiliser les méthodes de base, telles que str.find(), str.endswith(), str.startswith(), ou quelque chose de similaire. Par exemple:

>>> text = 'oui, mais non, rien du tout, mais non, of course'
>>> # Appariement exact
>>> text == 'oui'
False
>>> # Appariement au début ou à la fin
>>> text.startswith('oui')
True
>>> text.endswith('non')
False
>>> # Rechercher la position de la première occurrence
>>> text.find('no')
10
>>>

 

Pour des appariements plus complexes, utilisez des expressions régulières et le module re. Pour illustrer les mécanismes de base de l’utilisation des expressions régulières, supposons que vous vouliez apparier des dates spécifiées en chiffres, telles que “11/27/2012”. Voici un exemple de la façon dont vous le feriez:

>>> texte1 = '11/17/2018'
>>> texte2 = 'Nov 17, 2018'
>>>
>>> import re
>>> # Un appariement simple : \d+ signifie apparier un ou plusieurs chiffres
>>> if re.match(r'\d+/\d+/\d+', texte1):
... 	print('oui')
... else:
... 	print('non')
...
oui
>>> if re.match(r'\d+/\d+/\d+', texte2):
... 	print('oui')
... else:
... 	print('non')
...
non
>>>

 

Si vous allez effectuer un grand nombre de correspondances en utilisant le même motif, il est généralement préférable de pré-compiler d’abord le motif de l’expression régulière dans un objet motif. Par exemple:

>>> texte = "Nous sommes aujourd'hui le 27/5/2018. PyConf démarre le 13/8/2018."

>>> datepat = re.compile(r'\d+/\d+/\d+')

>>> datepat.findall(texte)
['27/5/2018', '13/8/2018']

>>>

 

Lors de la définition d’expressions régulières, il est courant d’introduire des groupes de capture en mettant des parties du motif entre parenthèses. Par exemple :

>>> motif = re.compile(r'(\d+)/(\d+)/(\d+)')
>>>

 

Les groupes de capture simplifient souvent le traitement ultérieur du texte apparié car le contenu de chaque groupe peut être extrait individuellement. Par exemple :

>>> motif = re.compile(r'(\d+)/(\d+)/(\d+)')
>>> m = motif.match('13/12/2018')
>>> m
<re.Match object; span=(0, 10), match='13/12/2018'>

# Extraire le contenu de chaque groupe

>>> m.group(0)
'13/12/2018'

>>> m.group(1)
'13'

>>> m.group(2)
'12'

>>> m.group(3)
'2018'

>>> m.group()
'13/12/2018'

>>> jour, mois, annee = m.groups()

# Trouver toutes les correspondances ( remarquez le fractionnement en tuples)

>>> texte = "Nous sommes aujourd'hui le 27/5/2018. PyConf démarre le 13/8/2018."

>>> motif.findall(texte)
[('27', '5', '2018'), ('13', '8', '2018')]

>>> for jour, mois, annee in motif.findall(texte):
...     print('{}-{}-{}'.format(annee, mois, jour))
...     
... 
2018-5-27
2018-8-13

>>>

 

La méthode findall() recherche le texte et trouve toutes ses correspondances, les retournant sous forme de liste. Si vous voulez trouver des correspondances de façon itérative, utilisez plutôt la méthode finditer(). Par exemple:

>>> for m in motif.finditer(texte):
...     print(m.groups())
...     
... 
('27', '5', '2018')
('13', '8', '2018')

>>>

 

Lors de la spécification de motifs, il est relativement courant d’utiliser des chaînes brutes telles que r'(\d+)/(\d+)/(\d+)’. De telles chaînes laissent le caractère barre oblique inverse non interprété, ce qui peut être utile dans le contexte des expressions régulières. Sinon, vous devez utiliser des barres obliques doubles telles que dans cette expression ‘(\\d+)/(\\d+)/(\d+)/(\\d+)’.

Attention, la méthode match() ne vérifie que le début d’une chaîne. Il est possible qu’il corresponde à des choses auxquelles vous ne vous attendez pas. Par exemple :

>>> m = motif.match('11/8/2018abcdef')

>>> m
<re.Match object; span=(0, 9), match='11/8/2018'>

>>> m.group()
'11/8/2018'

>>>

 

Un cours élémentaire sur la théorie des expressions régulières dépasse le cadre de ce livre. Cependant, les exemples ci-dessus illustrent les bases de l’utilisation du module re pour apparier et rechercher du texte. La fonctionnalité essentielle est d’abord de compiler un pattern en utilisant re.compile() puis utiliser des méthodes telles que match(), findall(), ou finditer().

Si vous voulez avoir un appariement exact, assurez-vous que le motif inclut le marqueur de fin ($), comme dans ce qui suit:

>>> motif = re.compile(r'(\d+)/(\d+)/(\d+)$')

>>> motif.match('10/7/2018abcdef')

>>> motif.match('10/7/2018')
<re.Match object; span=(0, 9), match='10/7/2018'>

>>>

 

Enfin, si vous ne faites qu’une simple opération de recherche et d’appariement de texte, vous pouvez souvent sauter l’étape de compilation et utiliser les fonctions de niveau module dans le module re. Par exemple :

>>> re.findall(r'(\d+)/(\d+)/(\d+)', texte)
[('27', '5', '2018'), ('13', '8', '2018')]

>>>

 

Sachez, cependant, que si vous devez effectuer beaucoup de recherches ou appariements, il est généralement préférable de compiler le motif d’abord et après l’utiliser encore et encore.

Enfin, les fonctions au niveau du module conservent une mémoire cache des motifs récemment compilés, de sorte qu’il n’y a pas un énorme charge sur les performances du processeur, mais vous pouvez enregistrer quelques recherches et traitements supplémentaires en utilisant votre propre motif compilé.

LAISSER UN COMMENTAIRE

Please enter your comment!
Please enter your name here