Expressions régulières (RegEx) en Python

Dans ce tutoriel, vous apprendrez l'expression régulière (RegEx) et utilisez le module re de Python avec RegEx (sous l'aide d'exemples).

L'expression régulière (RegEx) est une séquence de caractères définissant un modèle de recherche. Par exemple,

^a...s$

Le code suivant définit le modèle RegEx. Le modèle est :paracommençant parsterminée parToute chaîne de cinq lettres.

Les modèles définis avec RegEx peuvent être utilisés pour correspondre aux chaînes de caractères.

Python possède un module nommé reRegEx. Voici un exemple :

import re
pattern = '^a...s$'
test_string = 'abyss'
result = re.match(pattern, test_string)
if　result:
　　print("Recherche réussie.")
else:
　　print("Recherche infructueuse.")

Ici, nous utilisons la fonction re.match() pour rechercher le modèle dans la chaîne de test. Si la recherche est réussie, cette méthode retourne un objet de correspondance. Sinon, elle retourne None.

reLe module contient d'autres fonctions définies, qui peuvent être utilisées avec RegEx. Avant de discuter, apprenons l'expression régulière elle-même.

Si vous connaissez les bases de RegEx, sautez àPython RegEx.

Spécifier un modèle à l'aide d'une expression régulière

Pour spécifier une expression régulière, on utilise des métacaractères. Dans l'exemple ci-dessus, ^ et $ sont des métacaractères.

Les caractères métatonaux

Les caractères métatonaux sont les caractères interprétés de manière spéciale par le moteur RegEx. Voici la liste des caractères métatonaux :

[]　. ^ $ * +　? {}　() \ |

[] - Les crochets

Les crochets spécifient un ensemble de caractères à correspondre.

Ici, [abc] correspondra, si vous voulez correspondre à une chaîne contenant n'importe quel a, b ou c.

Vous pouvez également utiliser-La plage de caractères dans les crochets.

• [a-e] est le même que [abcde].

• [1-4] est le même que [1234]。

• [0-39] est le même que [01239]。

Vous pouvez utiliser l'insertion ^ au début des crochets pour compléter (inverser) un ensemble de caractères.

• [^abc] indique tous les caractèresaorborcdehorsden'importe quel caractère.

• [^0-9] indique n'importe quel caractère non numérique.

.- Le point

Le point . correspond à n'importe quel caractère individuel (sauf le retour chariot '\n').

^- Le symbole insert

Le symbole insert ^ est utilisé pour vérifier si une chaîne de caractères

$- Le symbole dollar

Le symbole dollar $ est utilisé pour vérifier si une chaîne de caractèresparun caractère spécifiqueà la fin.

*- Le symbole étoile

Le symbole étoile * correspond*Correspondzéro ou plusieurs foisdu motif restant.

+- Le signe plus

Le signe plus + correspond+Correspondune ou plusieurs foisdu motif restant.

?- Le symbole interrogaire

Le symbole interrogaire ? correspondapparaît zéro ou une foisdu motif restant.

{}- les accolades

Considérez le code suivant : {n,m}. Cela signifie qu'il faut conserver au moinsn foismode, et au plusm foismode.

Essayons à nouveau un exemple. RegEx [0-9]{2, 4} correspond au moins2position mais pas plus de4position

|- La barre oblique oblique

La barre oblique oblique | est utilisée pour indiquer l'alternance (opérateur ou).

Ici, a|b correspond à n'importe quel motif qui contientaorbChaîne

()- Les parenthèses

Les parenthèses ( ) sont utilisées pour regrouper des sous-expressions. Par exemple, (a|b|c)xz correspond à n'importe quel motif qui contientaorborcCorrespond et est suivide xzChaîne

\- Barre oblique

La barre oblique inverse \ est utilisée pour échapper à divers caractères, y compris tous les caractères métacaractères. Par exemple,

\$a Si la chaîne contient $ suivi de a, il correspond. Ici, le moteur RegEx ne l'interprète pas de manière spéciale.

Si vous n'êtes pas sûr que un caractère a un sens spécial, vous pouvez le préfixer avec\ . Cela assure que le caractère n'est pas traité de manière spéciale.

Séquences spéciales

Les séquences spéciales rendent les schémas courants plus faciles à écrire. Voici une liste des séquences spéciales :

\A -si le caractère spécifié est au début de la chaîne, il correspond.

\b -si le caractère spécifié est au début ou à la fin du mot, il correspond.

\B-avec\b. Si le caractère spécifién'est pasau début ou à la fin du mot, il correspond.

\d-Correspond à n'importe quel chiffre décimal. Équivalent à [0-9]

\D-Correspond à n'importe quel caractère non décimal. Équivalent à [^0-9]

\s-Correspond à l'endroit où la chaîne contient n'importe quel caractère d'espace. Équivalent à [ \t\n\r\f\v].

\S-Correspond à l'endroit où la chaîne contient n'importe quel caractère non blanc. Équivalent à [^ \t\n\r\f\v].

\w--zA-Z0-9]

\W-Correspond à n'importe quel caractère non alphabétique et non numérique. Équivalent à [^a-zA-Z0-9_]

\Z -Si le caractère spécifié est à la fin de la chaîne, il correspond.

Astuce :Pour construire et tester des expressions régulières, vous pouvez utiliser des outils de test RegEx tels queregexCet outil peut non seulement vous aider à créer des expressions régulières, mais aussi à les apprendre.

Maintenant que vous avez compris les bases des expressions régulières (RegEx), discutons de la manière d'utiliser les RegEx dans le code Python.

Expressions régulières Python

Python a un module nommé re pour les expressions régulières. Pour l'utiliser, nous devons importer le module.

import re

Ce module définit quelques fonctions et constantes qui peuvent être utilisés avec RegEx.

re.findall()

re.findall() retourne une liste de chaînes contenant toutes les correspondances.

Example1：re.findall()

# Program to extract numbers from a string
import re
string = 'hello　12　hi　89. Howdy　34'
pattern = '\d'+'
result = re.findall(pattern, string)　
print(result)
# Sortie:　['12>>> match.groups()89>>> match.groups()34]

Si le modèle n'est pas trouvé, re.findall() retourne une liste vide.

re.split()

La méthode split divise les chaînes correspondantes et retourne une liste des chaînes divisées.

Example2：re.split()

import re
string = 'Twelve:12　Eighty nine:89.
pattern = '\d'+'
result = re.split(pattern, string)　
print(result)
# Sortie:　['Twelve:',　'　Eighty nine:',　'.']

Si le modèle n'est pas trouvé, re.split() retourne une liste contenant des chaînes vides.

Vous pouvez passer le paramètre maxsplit à la méthode re.split(). C'est le nombre maximum de divisions qui doit être effectuées.

import re
string = 'Twelve:12　Eighty nine:89　Nine:9.
pattern = '\d'+'
# maxsplit =　1
# Split only at the first occurrence
result = re.split(pattern, string,)　1(　
print(result)
# Sortie:　['Twelve:',　'　Eighty nine':89　Nine:9.']

En passant, maxsplit a par défaut une valeur de 0; la valeur par défaut est 0. Cela signifie que toutes les correspondances sont divisées.

re.sub()

La syntaxe de re.sub() :

re.sub(pattern, replace, string)

Cette méthode retourne une chaîne où les correspondances sont remplacées par le contenu de la variable replace.

Example3：re.sub()

# Programme pour supprimer tous les espaces
import re
# Chaîne multiligne
string = 'abc　12\
de　23　\n f45　6'
# Correspond à tous les caractères blancs
pattern = '\s+'
# Chaîne vide
replace = ''
new_string = re.sub(pattern, replace, string)　
print(new_string)
# Sortie:　abc12de23f456

Si le modèle n'est pas trouvé, re.sub() retourne la chaîne d'origine.

Vous pouvezcountLe quatrième paramètre est passé à la méthode re.sub(). Si il est omis, le résultat est 0. Cela remplace toutes les occurrences de la correspondance.

import re
# Chaîne multiligne
string = 'abc　12\
de　23　\n f45　6'
# Correspond à tous les caractères blancs
pattern = '\s+'
replace = ''
new_string = re.sub(r'\s'+', replace, string,　1(　
print(new_string)
# Sortie:
# abc12de　23
# f45　6

re.subn()

re.subn() est similaire à re.sub(), il s'attend à ce qu'il retourne un tuple contenant2un tuple contenant le nouveau chaîne et le nombre de remplacements effectués.

Example4：re.subn()

# Programme pour supprimer tous les espaces
import re
# Chaîne multiligne
string = 'abc　12\
de　23　\n f45　6'
# Correspond à tous les caractères blancs
pattern = '\s+'
# Chaîne vide
replace = ''
new_string = re.subn(pattern, replace, string)　
print(new_string)
# Sortie: ('abc12de23f456',　4(

re.search()

La méthode re.search() prend deux paramètres : le modèle et la chaîne. Cette méthode cherche la première position de la correspondance du modèle RegEx avec la chaîne.

Si la recherche réussit, re.search() renvoie un objet de correspondance. Sinon, il renvoie None.

match = re.search(pattern, str)

Example5：re.search()

import re
string = "Python is fun"
# Vérifiez si "Python" est au début
match = re.search('\APython', string)
if match:
　　print("pattern found inside the string")
else:
　　print("pattern not found")　　
# Sortie: pattern found inside the string

Ici,matchcontient un objet match.

l'objet de correspondance

Vous pouvez utiliserdir()La fonction obtient les méthodes et propriétés de l'objet de correspondance.

Certains méthodes et propriétés courantes de l'objet de correspondance sont :

match.group()

La méthode group() renvoie la partie correspondante de la chaîne.

Example6：匹配对象

import re
string = '39801　356,　2102　1111'
# Trois chiffres, suivis d'un espace, deux chiffres
pattern = '(\d{3}) (\d{2})'
# Le variable match contient un objet Match.
match = re.search(pattern, string)　
if match:
　　print(match.group())
else:
　　print("pattern not found")
# Sortie:　801　35

Ici,match变量包含一个match对象。

match3}) Variable contains a match object.2}) Our pattern (\d{3}) (\d{2}) have two subgroups (\d{

)) and (\d{1(
'801'
)) and (\d{2(
'35'
)) and (\d{1,　2(
>>> match.group(801>>> match.groups()35('
))). You can get a part of the string of these bracketed subgroups. That's it:
>>> match.group(801>>> match.groups()35('

', ''

)

The start() function returns the index of the beginning of the matched substring. Similarly, end() returns the index of the end of the matched substring. match.start(), match.end() and match.span()
2
>>> match.start()
8

>>> match.end()

The span() function returns a tuple containing the start and end indices of the matched part.
>>> match.span()2,　8(

)

The re attribute of the match object returns a regular expression object. Similarly, the string attribute returns the passed string. match.re and match.string

>>> match.re
re.compile('(\\d{3}) (\d{2})'
>>> match.string
'39801　356,　2102　1111'

We have introduced all the commonly used methods defined in the re module. If you want to learn more information, please visitPython 3 re module.

Use the r prefix before RegEx

If you use the r prefix before a regular expressionrorRthe prefix indicates a raw string. For example, '\n' is a new line, while r'\n' represents two characters: a backslash \ followed by n.

The backslash \ is used to escape various characters, including all meta-characters. However, usingrThe prefix \ treats it as a normal character.

Example7Use the r prefix for raw strings

import re
string = '\n and \r are escape sequences.'
result = re.findall(r'[\n\r]', string)　
print(result)
# Output: ['\n', '\r']