Python Regex – Comment compter le nombre de correspondances ?

Pour compter plusieurs fois un motif regex dans une chaîne donnée, utilisez la méthode len(re.findall(pattern, string)) qui renvoie le nombre de sous-chaînes correspondantes ou len([*re.finditer(pattern, text)]) qui décompresse toutes les sous-chaînes correspondantes dans une liste et en renvoie également la longueur.

Il y a quelques heures, j'ai écrit une expression régulière en Python qui correspondait non pas une mais plusieurs fois dans le texte et je me suis demandé :comment compter le nombre de correspondances ?

Considérez l'exemple minimal où vous faites correspondre un nombre arbitraire de caractères de mot '[a-z]+' dans une phrase donnée 'python is the best programming language in the world' .

Vous pouvez regarder ma vidéo explicative pendant que vous lisez le didacticiel :

Article connexe : Python Regex Superpower - Le guide ultime

Les ingénieurs de Google, Facebook et Amazon sont des maîtres des expressions régulières. Si vous souhaitez également le devenir, consultez notre nouveau livre :La manière la plus intelligente d'apprendre Python Regex (Amazon Kindle/Print, s'ouvre dans un nouvel onglet) .

Combien y a-t-il de correspondances dans la chaîne ? Pour compter le nombre de correspondances, vous pouvez utiliser plusieurs méthodes :

Méthode 1 :Python re.findall()

Utilisez le re.findall(pattern, string) méthode qui renvoie une liste de sous-chaînes correspondantes. Comptez ensuite la longueur de la liste renvoyée. Voici un exemple :

>>> import re
>>> pattern = '[a-z]+'
>>> text = 'python is the best programming language in the world'
>>> len(re.findall(pattern, text))
9

Pourquoi le résultat est-il 9 ? Parce qu'il y a neuf sous-chaînes correspondantes dans la liste renvoyée du re.findall() méthode :

>>> re.findall(pattern, text)
['python', 'is', 'the', 'best', 'programming', 'language', 'in', 'the', 'world']

Cette méthode fonctionne très bien s'il y a des correspondances qui ne se chevauchent pas.

Voulez-vous maîtriser la superpuissance des regex ? Découvrez mon nouveau livre La façon la plus intelligente d'apprendre les expressions régulières en Python avec l'approche innovante en 3 étapes pour un apprentissage actif :(1) étudiez un chapitre de livre, (2) résolvez un puzzle de code et (3) regardez une vidéo de chapitre éducatif.

Méthode 2 :Python re.finditer()

Vous pouvez également compter le nombre de fois qu'un pattern donné correspond à un text en utilisant le re.finditer(pattern, text) méthode :

Spécification :re.finditer(pattern, text, flags=0)

Définition :renvoie un itérateur qui parcourt toutes les correspondances non superposées du pattern dans le text .

Le flags L'argument vous permet de personnaliser certaines propriétés avancées du moteur de regex, par exemple si la capitalisation des caractères doit être ignorée. Vous pouvez en savoir plus sur l'argument des drapeaux dans mon tutoriel de blog détaillé.

Exemple :Vous pouvez utiliser l'itérateur pour compter le nombre de correspondances. Contrairement au re.findall() méthode décrite ci-dessus, cela a l'avantage que vous pouvez analyser les objets de correspondance eux-mêmes qui contiennent beaucoup plus d'informations que la simple sous-chaîne correspondante.

import re
pattern = '[a-z]+'
text = 'python is the best programming language in the world'
for match in re.finditer(pattern, text):
   print(match)

'''
<re.Match object; span=(0, 6), match='python'>
<re.Match object; span=(7, 9), match='is'>
<re.Match object; span=(10, 13), match='the'>
<re.Match object; span=(14, 18), match='best'>
<re.Match object; span=(19, 30), match='programming'>
<re.Match object; span=(31, 39), match='language'>
<re.Match object; span=(40, 42), match='in'>
<re.Match object; span=(43, 46), match='the'>
<re.Match object; span=(47, 52), match='world'>
'''

Si vous voulez compter le nombre de correspondances, vous pouvez utiliser un simple count variables :

import re
pattern = '[a-z]+'
text = 'python is the best programming language in the world'

count = 0
for match in re.finditer(pattern, text):
   count += 1

print(count)
# 9

Ou une solution plus Pythonique :

import re
pattern = '[a-z]+'
text = 'python is the best programming language in the world'

print(len([*re.finditer(pattern, text)]))
# 9

Cette méthode fonctionne très bien s'il y a des correspondances qui ne se chevauchent pas. Il utilise l'opérateur astérisque * pour décompresser toutes les valeurs dans l'itérable.

Méthode 3 :correspondances qui se chevauchent

Les deux méthodes ci-dessus fonctionnent très bien s'il n'y a pas de correspondances qui se chevauchent. S'il y a des correspondances qui se chevauchent, le moteur regex les ignorera simplement car il "consomme" toutes les sous-chaînes correspondantes et ne commence à faire correspondre le modèle suivant qu'après le stop index du match précédent.

Donc, si vous avez besoin de trouver le nombre de correspondances qui se chevauchent, vous devez utiliser une approche différente.

L'idée est de garder une trace de la position de départ dans le match précédent et de l'incrémenter de un après chaque match :

import re
pattern = '99'
text = '999 ways of writing 99 - 99999'

left = 0
count = 0
while True:
    match = re.search(pattern, text[left:])
    if not match:
        break
    count += 1
    left += match.start() + 1
print(count)
# 7

En gardant une trace de l'index de début de la correspondance précédente dans la variable de gauche, nous pouvons contrôler où rechercher la correspondance suivante dans la chaîne. Notez que nous utilisons l'opération de découpage de Python text[left:] pour ignorer tous les caractères de gauche déjà pris en compte dans les correspondances précédentes. Dans chaque itération de boucle, nous faisons correspondre un autre modèle dans le texte. Cela fonctionne même si ces correspondances se chevauchent.

Où aller à partir d'ici

Vous avez appris trois façons de trouver le nombre de correspondances d'un modèle donné dans une chaîne.

Si vous rencontrez des difficultés avec les expressions régulières, consultez notre tutoriel gratuit sur les expressions régulières de 20 000 mots sur le blog Finxter ! Cela vous donnera des superpuissances regex !

Cours Python Regex

Les ingénieurs de Google sont passés maîtres dans l'expression régulière. Le moteur de recherche Google est un énorme moteur de traitement de texte qui extrait la valeur de milliers de milliards de pages Web.

Les ingénieurs de Facebook sont des maîtres des expressions régulières. Les réseaux sociaux comme Facebook, WhatsApp et Instagram connectent les humains via des messages texte .

Les ingénieurs d'Amazon sont des maîtres des expressions régulières. Les géants du commerce électronique expédient des produits basés sur des descriptions de produits textuelles . Les expressions régulières dominent le jeu lorsque le traitement de texte rencontre l'informatique.