Tutoriel Python : installer et utiliser le module RegEX

Table des matières :

1. Introduction
2. Utilisation des caractères spéciaux
3. Méthodes d'expression régulière
4. Objets de correspondance
5. L’utilisation des expressions régulières du Python
6. Exercices
7. Correction des exercices
8. Conclusion

1. Introduction :

Les expressions régulières, également appelées RE, ou regexes, fournissent un moyen puissant de rechercher et de manipuler des chaînes de caractères. Les expressions régulières sont essentiellement un minuscule langage de programmation hautement spécialisé, intégré à Python et mis à disposition par le module RE. Les expressions régulières utilisent une séquence de caractères et de symboles pour définir un modèle de texte. Un tel modèle est utilisé pour localiser un morceau de texte dans une chaîne de caractères en faisant correspondre le modèle aux caractères de la chaîne. Les expressions régulières sont utiles pour trouver des numéros de téléphone, des adresses électroniques, des dates et toute autre donnée ayant un format cohérent.

2. Utilisation des caractères spéciaux :

Un modèle d'expression régulière est composé de caractères simples, tels que abc, ou d'une combinaison de caractères simples et spéciaux, tels que ab*c. Les modèles simples sont construits à partir des caractères pour lesquels vous souhaitez trouver une correspondance textuelle. Par exemple, le motif abc correspond aux combinaisons de caractères dans les chaînes de caractères uniquement lorsque les caractères "abc" apparaissent ensemble et dans cet ordre.

Par exemple, le modèle ab*c correspond à toute combinaison de caractères dans laquelle un seul "a" est suivi de zéro ou de plusieurs "b" (* signifie 0 ou plusieurs occurrences du point précédent) et puis immédiatement suivi de la lettre "c".

Exemple 1 :

import re
txt = "cour-gratuit"
x = re.findall("[a-m]", txt)
print(x)

Résultat de l’execution :

Exemple 2 :

Syntaxe:

import re
txt = "Maîtriser le module RegEX du Python"
x = re.findall("\W", txt)
print(x)
if x:
print("Yes")
else:
print("No")

Résultat de l’exécution :

 Exemple 3:

Syntaxe:

import re
txt = "tutoriel 23"
x = re.findall("\d", txt)
print(x)

Résultat de l’exécution :

Exemple 4 :

Syntaxe:

import re
txt = "Maîtriser le module RegEX du Python"
x = re.findall("RegEX|PIP",txt)
print(x)
if x:
print("Oui")
else:
print("Non")

Résultat de l’exécution :

Exemple 5 :

Syntaxe:

import re
txt = "RegEX module 1 2"
#Retourner une correspondance à chaque caractère sans chiffre :
x = re.findall("\D", txt)
print(x)

Résultat de l’exécution :

Exemple 6 :

Syntaxe:

import re
txt = "le module RegEX du Python"
#Vérifiez si la chaîne commence par "Le" :
x = re.findall("\Ale", txt)
print(x)

Résultat de l’exécution :

a) Utilisation du préfixe r pour les expressions régulières :

Considérons l'expression régulière, r'^$'. Cette expression régulière correspond à une ligne vide.

Le "^" indique le début d'une ligne, et le "$" la fin d'une ligne. Ne rien avoir entre les caractères spéciaux "^" et "$", correspond donc à une ligne vide. Le préfixe "r" indique à Python que l'expression est une chaîne brute et qu'elle est pratique dans les expressions.

3. Méthodes d'expression régulière:

Maintenant que nous nous sommes penchés sur quelques expressions régulières simples, comment on peut réellement les utiliser en Python ? En Python, les méthodes pour utiliser et appliquer les expressions régulières sont accessibles en important le module re. Le module re(RegEX) fournit une interface avec le standard Python moteur d'expression.

Les expressions régulières peuvent être compilées dans un objet modèle, qui dispose de méthodes pour diverses opérations telles que la recherche de concordances de motifs ou l'exécution de substitutions de chaînes de caractères. Ceci peut être réalisé en utilisant la méthode :

re.compile(pattern[,flags]).

où pattern est l'expression régulière et l'argument facultatif flags est utilisé pour permettre diverses particularités et variations syntaxiques.

4. Objets de correspondance:

Les méthodes match() et search(), supportées par un objet d'expression régulière compilé, retournent None si aucune correspondance n'est trouvée. Si elles réussissent, une instance de l'objet match est renvoyée, contenant des informations sur la correspondance comme la sous-chaîne à laquelle elle correspond.

5. L’utilisation des expressions régulières du Python :

                Afin de construire et d'utiliser des expressions régulières, suivez les étapes suivantes :

Étape 1 : Importer le module d'expressions régulières.

Étape 2 : Compiler le modèle d'expression régulière en utilisant la méthode re.compile(). Cette méthode renvoie le modèle d'expression régulière comme un objet.

Étape 3 : Invoquez une méthode appropriée supportée par l'objet d'expression régulière compilé qui renvoie une instance d'objet correspondant contenant des informations sur des cordes assorties.

Étape 4 : Appel des méthodes (la méthode group() est appropriée dans la plupart des cas) associées à l'objet correspondant pour afficher les résultats.

Exemple 7 :

Syntaxe:

import re
pattern = re.compile(r'(e)g')
pattern
match_object = pattern.match(' egg is nutritional food ')
match_object
match_object.group()
match_object.group(0)
match_object = pattern.match(' brownegg is nutritional food ')
match_object.group()

Résultat de l’exécution :

ü  Explication du code :

• Importation du module re(RegEX) ?.
• Compilation de  l'expression régulière "(e)g" qui correspond à la caractères "eg", au début d'une chaîne de caractères ?-?.
• Passez la chaîne de caractères à partir de laquelle vous voulez extraire le modèle d'expression régulière comme argument pour la méthode match() ?.  

Comme Vous pouvez voir dans le résultat de match_object ?, la chaîne de caractères correspondante est assignée à la correspondance.  Pour obtenir les chaînes de caractères qui ont été mises en correspondance, utilisez la méthode group() associée à match_object ?. Les groupes sont toujours numérotés en commençant par 0. Le groupe 0 est toujours présent et il représente le résultat entier de l'expression régulière elle-même, donc les méthodes group() de l'objet match ont toutes 0 comme argument par défaut ? . Dans ?, même si la chaîne contient le motif eg, les caractères eg ne se trouvent pas au début de la chaîne.

Ainsi, si vous essayez d'utiliser la méthode group() avec l'objet match, vous obtiendrez une erreur ?. Le "r", au début de la chaîne désigne à une chaîne "brute" en Python. Il est fortement recommandé de prendre l'habitude d'écrire des chaînes de caractères avec un préfixe "r".

Exemple 8 :

Syntaxe:

import re
pattern = re.compile(r'(ab)*')
match_object = pattern.match('ababababab')
match_object.span()
match_object.start()
match_object.end()

Résultat de l’exécution :

Dans l'exemple ci-dessus, le modèle d'expression régulière (ab)* correspondra à zéro ou plusieurs répétitions de ab . Passez la chaîne de caractères dont vous voulez extraire le modèle d'expression régulière comme un argument à la méthode match() . Les groupes indiqués par '(', ')' capturent également le et l'index de fin de la sous-chaîne correspondante, et ceci peut être récupéré en utilisant la méthode span() .

La position initiale de la correspondance peut également être obtenue par la méthode start() et la position finale de la correspondance est obtenue par la méthode end() . Puisque la méthode match() seulement vérifie si l'expression régulière correspond au début d'une chaîne de caractères, la méthode start() renvoie zéro.

Exemple 9 :

Syntaxe:

import re
pattern = re.compile(r'(a(b)c)d')
method_object = pattern.match('abcd')
method_object.group(0)
method_object.group(2,1,2)
method_object.group(1)
method_object.group(2)
method_object.groups()

Résultat de l’exécution :

Exemple 10:

Syntaxe:

import re
pattern = re.compile(r'\d+')
match_list = pattern.findall("Everybody think they're famous when they get 100000 followers on Instagram and 5000 on Twitter")
match_list

Résultat de l’exécution :

Dans l'exemple ci-dessus, le motif d'expression régulière "\d+" correspondra à un ou plusieurs chiffres de un numéro . Passez la chaîne de caractères dont vous voulez extraire le modèle d'expression régulière comme argument de la méthode findall() . La méthode findall() renvoie une liste de numéros ['100000', '5000'] sous la forme des chaînes de caractères, chaque chaîne représente une correspondance .

6. Exercices :

Exercice 1 :

Écrivez un programme Python pour supprimer les parenthèses dans une chaîne de caractères.

Exercice 2 :

Écrivez un programme Python pour trouver l'occurrence et la position des sous-chaînes dans une chaîne..

Exercice 3 :

Écrivez un programme Python pour rechercher les nombres (0-9) de longueur comprise entre 1 et 3 dans une chaîne donnée.

Exercice 4  :

Écrivez un programme Python pour supprimer les zéros non significatifs d'une adresse IP.

Exercice 5  :

Écrivez un programme Python pour vérifier un nombre est décimale ou non avec une précision de 3.

7. Correction des exercices :

Exercice 1  :

Syntaxe:

import re
items = [" google (.com) ", " bing ", " github (.com) ", " jupyter (.org) ", " Cour-gratuit (.com) "]
for item in items:
print(re.sub(r" ?\([^)]+\)", " ", item))

Résultat de l’exécution : 

Exercice 2 :

Syntaxe:

import re
text = ' Python Tutoriel, PHP Tutoriel, C# Tutoriel '
pattern = 'Tutoriel'
for match in re.finditer(pattern, text):
S = match.start()
E = match.end()
print('on trouve "%s" at %d:%d' % (text[S:E], S, E))

Résultat de l’exécution : 

Exercice 3  :

Syntaxe:

import re
results = re.finditer(r"([0-9]{1,3})", " les Exercices 1, 12, 13,20 et 254 sont très importants ")
print("les nombres de longueur entre 1 est 3 ")
for n in results:
print(n.group(0))

Résultat de l’exécution : 

Exercice 4  :

Syntaxe:

import re
ip = "216.07.064.196"
string = re.sub('\.[0]*', '.', ip)
print(string)

Résultat de l’exécution : 

Exercice 5  :

Syntaxe:

def is_decimal(num):
import re
dnumre = re.compile(r"""^[0-9]+(\.[0-9]{1,3})?$""")
result = dnumre.search(num)
return bool(result)
print(is_decimal('198.123'))
print(is_decimal('132.43'))
print(is_decimal('100.123233'))

Résultat de l’exécution : 

8. Conclusion :

Dans ce tutoriel nous avons appris les bases des expressions de régression et comment travailler avec le paquet RegEx(re). Il est essentiel donc de retenir les points suivants:

• Le terme "expressions régulières" est également appelé regexes ou modèles regex.
• Le module re doit être importé pour pouvoir travailler avec des expressions régulières.
• Utilisez la méthode compile() dans le module re pour compiler l'expression régulière qui correspond aux objets.
• Utilisez diverses méthodes comme les méthodes search(), match(), findall() et sub() pour extraire des sous-chaînes correspondantes à un modèle.