Expression régulière python

Dans ce sujet, nous apprendrons des expressions régulières Python.

Définition: Des expressions régulières, parfois appelées re ou regex ou regexp, sont des séquences de caractères pour correspondre aux modèles en texte / chaîne. Python a un module RE intégré pour effectuer ce.

Les utilisations courantes d'une expression régulière sont:

1. Recherchez une chaîne (recherche et recherche)
2. Find All Matching String (findall)
3. Diviser la chaîne en sous-chaîne (Split)
4. Remplacer la partie d'une chaîne (sous)

Une expression régulière est une combinaison d'alphabets, métacharacteurs. Ainsi, les métacharacteurs sont disponibles.

• \ Ceci est utilisé pour laisser tomber / ignorer la signification particulière du caractère
• [] Cela indique une classe de caractères ex: [A-Z], [A-ZA-Z0-9]
• ^ Cela correspond au début du texte
• $ Cela correspond à la fin du texte
• . Cela correspond à n'importe quel personnage sauf Newline
• ? Faire correspondre zéro ou un événement.
• | Signifie ou (correspondez à l'un des personnages séparés par celui-ci.
• * Tout nombre d'occurrences (y compris 0 occurrences)
• + Un ou plusieurs événements
• Indiquez plusieurs occurrences d'un RE précédent à correspondre.
• () Joigner un groupe de regexp

Si nous utilisons la barre arrière '\', cela indique diverses séquences. Je veux utiliser la barre arrière sans sa signification particulière utilisez '\\'.

• \ d correspond à tout chiffre décimal, c'est le même que la classe set [0-9]
• \ D correspond à tout caractère non chiffré
• \ s correspond à tout caractère blanc.
• \ S correspond à tout caractère non blanc
• \ w correspond à tout caractère alphanumérique; C'est la même chose qu'une classe [A-ZA-Z0-9_].
• \ W correspond à tout caractère non alphanumérique.

La méthode suivante disponible dans le module RE:

re.recherche() :

Cette méthode renvoie la partie correspondante de la chaîne, et elle s'arrête après le premier match. Cela peut donc être utilisé pour tester une expression plutôt que d'extraire des données.

Syntaxe: concernant.Recherche (modèle, chaîne)
Valeur de retour:
Aucun : le motif ne correspond pas
Chaîne : le motif correspondait

Ex: Dans cet exemple, recherchera le mois et la date

Importer RE
regexp = r "([a-za-z] +) (\ d +)"
match = re.Recherche (Regexp, "Mon fils anniversaire est le 20 juillet")
Si le match != Aucun:
Imprimer ("correspondre à l'index% s,% s"% (correspondre.start (), match.end ())) # Ceci fournit l'index de la chaîne correspondante
Print ("Match complet:% S"% (match.groupe (0)))
Imprimer ("Mois:% S"% (match.groupe 1)))
Print ("Day:% S"% (match.groupe (2)))
autre:
imprimer ("Le motif regex donné ne correspond pas")

concernant.correspondre() :

Cette méthode recherche et renvoie le premier match. Cela ne vérifie le match qu'au début de la chaîne.

Syntaxe: concernant.Match (motif, chaîne)
Valeur de retour:
Aucun: le motif ne correspond pas
String: motif correspondant

Ex: Cet exemple pour montrer le modèle correspondant au début de la chaîne

Importer RE
regexp = r "([a-za-z] +) (\ d +)"
match = re.match (regexp, "20 juillet")
Si match == aucun:
imprimer ("pas une date valide")
autre:
Print ("Gire String:% S"% (match.groupe()))
Imprimer ("Mois:% S"% (match.groupe 1)))
Print ("Day:% S"% (match.groupe (2)))

Ex: pour montrer le modèle non égalé au début

Importer RE
match = re.match (regexp, "mon fils anniversaire est le 20 juillet")
Si match == aucun:
imprimer ("pas une date valide")
autre:
Print ("Gire String:% S"% (match.groupe()))
Imprimer ("Mois:% S"% (match.groupe 1)))
Print ("Day:% S"% (match.groupe (2)))

concernant.Trouver tout() :

Cette méthode renvoie toutes les correspondances de motif dans une chaîne. La chaîne est recherchée du début à la fin et les correspondances sont renvoyées dans l'ordre trouvé.

Syntaxe : concernant.findall (motif, chaîne)
Valeur de retour
String vide ([)]: le modèle ne correspond pas
Liste de la chaîne: modèle correspondant

Ex: Expression régulière pour trouver des chiffres

Importer RE
String = "" "Bangalore Pincode est 560066 et
Gulbarga Pincode est 585101 "" "
regexp = '\ d +'
match = re.findall (regexp, string)
imprimer (match)

Ex: Trouver le numéro de mobile (numéro d'exact à 10 chiffres) à partir du texte donné

Importer RE
String = "" "Bangalore Office numéro 1234567891,
Mon numéro est 8884278690, contact d'urgence 3456789123
Numéro non valide 898883456 "" "
regexp = '\ d 10' # Cette expression régulière pour faire correspondre le nombre exact de 10 chiffres
match = re.findall (regexp, string)
imprimer (match)

concernant.compiler():

Les expressions régulières sont compilées dans des objets motifs et peuvent être utilisés sur les méthodes. Exemple de recherche des correspondances de motifs, substitutions de chaînes.

Ex:

Importer RE
e = re.compiler ('[a-e]')
Imprimer (E.Findall ("Je suis né à 11.M. le 20 juillet 1989 "))
e = re.compiler ('\ d') # \ d est équivalent à [0-9].
Imprimer (E.Findall ("Je suis né à 11.M. le 20 juillet 1989 "))
p = re.compiler ('\ d +') # groupe d'un ou plusieurs chiffres
Imprimer (P.Findall ("Je suis né à 11.M. le 20 juillet 1989 "))

concernant.diviser():

Chaîne divisée basée sur les occurrences d'un motif. S'il est trouvé, les caractères restants de la chaîne sont retournés dans le cadre de la liste résultante. Nous pouvons spécifier la division maximale pour une chaîne donnée.

Syntaxe - concernant.Split (modèle, chaîne, maxsplit = 0)
Valeurs de retour:
Liste vide ([]): le modèle ne correspond pas
Liste de la chaîne: modèle correspondant

Ex:

Importer RE
# '\ W +' correspond à des caractères non alphanumériques ou à un groupe de caractères
# Split en trouvant «,« ou blanc »
imprimer (re.Split ('\ w +', 'bon, mieux, meilleur'))
imprimer (re.Split ('\ W +', "Book's Books Books"))
# Ici ':', ", ',' ne sont pas alphanumériques où la séparation se produit
imprimer (re.Split ('\ w +', 'né le 20 juillet 1989, à 11 h 00')))
# '\ d +' désigne des caractères numériques ou un groupe de caractères
# Spliting se produit à «20», «1989», «11», «00»
imprimer (re.Split ('\ d +', «né le 20 juillet 1989, à 11h00»))
# SPPENSE MAXIMUM SPÉCIFICATIVE en 1
imprimer (re.Split ('\ d +', «né le 20 juillet 1989, à 11h00
Am ', maxsplit = 1))

concernant.sous():

Ici, la signification «sub» est une sous-chaîne. Dans cette fonction, l'expression régulière donnée (paramètre de modèle) est adaptée dans la chaîne donnée (paramètre de chaîne); Si la sous-chaîne est trouvée, elle est remplacée par un paramètre de remplacement.
Ici, dans le décompte, spécifiez le nombre de fois que le regex est remplacé.
Ici, nous pouvons spécifier l'indicateur Regex (Ex: Re. IgnoreCase)

Syntaxe:- concernant.sub (motif, repose, string, count = 0, drapeaux = 0)
Valeur de retour:
Renvoie une nouvelle chaîne après avoir remplacé un motif ailleurs
Renvoie la même chaîne

Ex:

Importer RE
# Ex: le modèle «lly» correspond à la chaîne à «avec succès» et «delly»
imprimer (re.sub («lly», «# $», «rendez-vous de docteur avec succès dans Delly»))
# Ex: Case Hasbeen ignoré, en utilisant le drapeau, «lly» correspondra à deux fois avec la chaîne
# Après correspondance, 'lly' est remplacé par '~ *' dans "avec succès" et "Delly".
imprimer (re.sub («lly», «# $», «rendez-vous de docteur avec succès dans Delly», drapeau = re.IgnoreCase))
# Ex: Case Senstitivité, «lly» ne sera pas retiré.
imprimer (re.sub («lly», «# $», «rendez-vous de docteur avec succès dans Delly»))
# Ex: comme le nombre = 1, le remplacement des temps maximum se produit est 1
imprimer (re.sub («lly», «# $», «rendez-vous de doctorat avec succès dans Delly», comte = 1, drapeau = re.IgnoreCase))

concernant.subn ():

subn () fonctionnalité identique à sub () à toutes les manières; La seule différence est de fournir une sortie. Il renvoie un tuple qui contient un décompte d'un total de remplacement et de la nouvelle chaîne.
Syntaxe:- concernant.subn (motif, repose, string, count = 0, drapeaux = 0)

Ex:

Importer RE
imprimer (re.Subn («lly», «# $», «rendez-vous de docteur avec succès dans Delly»))
t = re.Subn («lly», «# $», «rendez-vous de docteur avec succès dans Delly», Flags = re.IgnoreCase)
imprimer (t)
imprimer (len (t))
# Cela donnera la même sortie que sub ()
imprimer (t [0])

concernant.s'échapper() :

Cela renvoie la chaîne avec une barre de barre '\' avant chaque caractère non alphanumérique. Ceci est utile si nous voulons correspondre à une chaîne littérale arbitraire qui peut avoir des métacharacteurs d'expression régulière.
Syntaxe:- concernant.Escape (String)
Ex:

Importer RE
# L'affaire ci-dessous n'a que "n'est pas alphanumérique
imprimer (re.Escape ("rendez-vous médecin réservé avec succès à 13 h"))
# Ci-dessous l'affaire a, ", Caret '^', '-', '[]', '\' ne sont pas alphanumériques
imprimer (re.Escape ("Il a demandé ce que c'est [0-9], j'ai dit \ t ^ Classe Numéro"))

Conclusion:

L'article couvrait les choses nécessaires pour comprendre l'expression régulière dans n'importe quelle application. Nous avons appris diverses méthodes et personnages de méta présents dans Python Regexp en utilisant des exemples.