Expressions régulières Python3

Une expression régulière est une séquence spéciale de caractères qui vous aide à vérifier commodément si une chaîne correspond à un certain motif.

En Python, utilisez le modulerepour gérer les expressions régulières.

Le module re fournit un ensemble de fonctions qui vous permettent d'effectuer des opérations de correspondance de motif, de recherche et de remplacement dans des chaînes.

reLe module donne au langage Python une fonctionnalité complète d'expressions régulières.

Ce chapitre présente principalement les fonctions de traitement des expressions régulières couramment utilisées en Python. Si vous n'êtes pas familier avec les expressions régulières, vous pouvez consulter notreTutoriel sur les expressions régulières。

Fonction re.match

re.match tente de faire correspondre un motif à partir de la position de départ de la chaîne. Si la correspondance n'est pas réussie à la position de départ, match() renvoie None.

Syntaxe de la fonction：

re.match(pattern, string, flags=0)

Description des paramètres de la fonction :

Paramètre	Description
pattern	L'expression régulière à faire correspondre.
string	La chaîne à faire correspondre.
indicateurs	Flags, utilisés pour contrôler le mode de correspondance de l'expression régulière, comme la sensibilité à la casse, la correspondance multiligne, etc. Voir :Modificateurs d'expressions régulières - Indicateurs facultatifs

En cas de correspondance réussiere.matchla méthode renvoie un objet de correspondance, sinon elle renvoieNone。

Nous pouvons utilisergroup(num)ougroups()les fonctions de l'objet de correspondance pour obtenir l'expression correspondante.

Méthodes de l'objet de correspondance	Description
group(num=0)	La chaîne de toute l'expression correspondante. group() peut prendre en entrée plusieurs numéros de groupe à la fois, auquel cas elle renvoie un tuple contenant les valeurs correspondant à ces groupes.
groups()	Renvoie un tuple contenant toutes les chaînes des sous-groupes, de 1 au nombre de sous-groupes contenus.

Exemple

#!/usr/bin/python import re print(re.match('www', 'www.example.com').span()) # Correspondance à la position de départ print(re.match('com', 'www.example.com')) # Pas de correspondance à la position de départ

La sortie de l'exemple ci-dessus est :

(0, 3)
None

Exemple

#!/usr/bin/python3 import re line = "Cats are smarter than dogs" # .* signifie correspondre à un ou plusieurs caractères, à l'exception des caractères de nouvelle ligne (\n, \r) # (.*?) indique le mode "non-greedy", qui ne sauvegarde que la première sous-chaîne correspondante matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I) if matchObj: print ("matchObj.group() : ", matchObj.group()) print ("matchObj.group(1) : ", matchObj.group(1)) print ("matchObj.group(2) : ", matchObj.group(2)) else: print ("Aucune correspondance !!")

Le résultat d'exécution de l'exemple ci-dessus est le suivant :

matchObj.group() :  Cats are smarter than dogs
matchObj.group(1) :  Cats
matchObj.group(2) :  smarter

méthode re.search

re.search parcourt toute la chaîne et renvoie la première correspondance réussie.

Syntaxe de la fonction :

re.search(pattern, string, flags=0)

Description des paramètres de la fonction :

Paramètre	Description
pattern	L'expression régulière à faire correspondre.
string	La chaîne à faire correspondre.
indicateurs	Flags, utilisés pour contrôler le mode de correspondance de l'expression régulière, comme la sensibilité à la casse, la correspondance multiligne, etc. Voir :Modificateurs d'expressions régulières - Indicateurs facultatifs

En cas de correspondance réussie, la méthode re.search renvoie un objet de correspondance, sinon elle renvoie None.

Nous pouvons utiliser les fonctions group(num) ou groups() de l'objet de correspondance pour obtenir l'expression correspondante.

Méthodes de l'objet de correspondance	Description
group(num=0)	La chaîne de toute l'expression correspondante. group() peut prendre en entrée plusieurs numéros de groupe à la fois, auquel cas elle renvoie un tuple contenant les valeurs correspondant à ces groupes.
groups()	Renvoie un tuple contenant toutes les chaînes des sous-groupes, de 1 au nombre de sous-groupes contenus.

Exemple

#!/usr/bin/python3 import re print(re.search('www', 'www.example.com').span()) # Correspondance à la position de départ print(re.search('com', 'www.example.com').span()) # Ne correspond pas à la position de départ

La sortie de l'exemple ci-dessus est :

(0, 3)
(11, 14)

Exemple

#!/usr/bin/python3 import re line = "Cats are smarter than dogs" searchObj = re.search( r'(.*) are (.*?) .*', line, re.M|re.I) if searchObj: print ("searchObj.group() : ", searchObj.group()) print ("searchObj.group(1) : ", searchObj.group(1)) print ("searchObj.group(2) : ", searchObj.group(2)) else: print ("Rien trouvé !!")

Le résultat d'exécution de l'exemple ci-dessus est le suivant :

searchObj.group() :  Cats are smarter than dogs
searchObj.group(1) :  Cats
searchObj.group(2) :  smarter

Différence entre re.match et re.search

re.matchIl ne correspond qu'au début de la chaîne. Si le début de la chaîne ne correspond pas à l'expression régulière, la correspondance échoue et la fonction renvoie None, tandis quere.searchIl correspond à toute la chaîne jusqu'à ce qu'une correspondance soit trouvée.

Exemple

#!/usr/bin/python3 import re line = "Cats are smarter than dogs" matchObj = re.match( r'dogs', line, re.M|re.I) if matchObj: print ("correspondance --> matchObj.group() : ", matchObj.group()) else: print ("Aucune correspondance !!") matchObj = re.search( r'dogs', line, re.M|re.I) if matchObj: print ("search --> matchObj.group() : ", matchObj.group()) else: print ("Aucune correspondance !!")

La sortie de l'exemple ci-dessus est :

No match!!
search --> matchObj.group() :  dogs

Rechercher et remplacer

Le module re de Python fournit re.sub pour remplacer les correspondances dans une chaîne.

Syntaxe :

re.sub(pattern, repl, string, count=0, flags=0)

Paramètres :

pattern : La chaîne de motif dans l'expression régulière.
repl: La chaîne de remplacement, qui peut aussi être une fonction.
string : La chaîne d'origine à rechercher et remplacer.
count: Le nombre maximal de remplacements après la correspondance du motif. La valeur par défaut 0 signifie remplacer toutes les correspondances.
flags: Le mode de correspondance utilisé au moment de la compilation, sous forme numérique.

Les trois premiers sont des paramètres obligatoires, et les deux derniers sont des paramètres facultatifs.

Exemple

#!/usr/bin/python3 import re phone = "2004-959-559 # Ceci est un numéro de téléphone" # Supprimer les commentaires num = re.sub(r'#.*$', "", phone) print ("Numéro de téléphone :", num) # Supprimer le contenu non numérique num = re.sub(r'\D', "", phone) print ("Numéro de téléphone :", num)

Le résultat d'exécution de l'exemple ci-dessus est le suivant :

电话号码 :  2004-959-559 
电话号码 :  2004959559

Le paramètre repl est une fonction

Dans l'exemple suivant, les nombres correspondants dans la chaîne sont multipliés par 2:

Exemple

#!/usr/bin/python import re # Multiplier les nombres correspondants par 2 def double(matched): value = int(matched.group('value')) return str(value * 2) s = 'A23G4HFD567' print(re.sub('(?P<value>\d+)', double, s))

Le résultat de sortie de l'exécution est :

A46G8HFD1134

fonction compile

La fonction compile est utilisée pour compiler une expression régulière et générer un objet d'expression régulière (Pattern), qui est utilisé par les fonctions match() et search().

Le format de syntaxe est:

re.compile(pattern[, flags])

Paramètres :

pattern : Une expression régulière sous forme de chaîne
flags est facultatif, indiquant le mode de correspondance, comme ignorer la casse, le mode multiligne, etc. Les paramètres spécifiques sont :
re.L indique que les jeux de caractères spéciaux \w, \W, \b, \B, \s, \S dépendent de l'environnement actuel
re.MULTILINE or re.M - Mode multiligne, modifie le comportement de ^ et $ afin qu'ils correspondent au début et à la fin de chaque ligne de la chaîne.
re.DOTALL ou re.S - Fait en sorte que.corresponde à n'importe quel caractère, y compris les retours à la ligne.
re.ASCII - Fait en sorte que \w, \W, \b, \B, \d, \D, \s, \S ne correspondent qu'aux caractères ASCII.
re.VERBOSE ou re.X - Ignore les espaces blancs et les commentaires, ce qui permet d'organiser plus clairement des expressions régulières complexes.

Ces options peuvent être utilisées individuellement ou combinées à l'aide d'un OU bit à bit (|). Par exemple, re.IGNORECASE | re.MULTILINE signifie activer à la fois l'ignorance de la casse et le mode multiligne.

Exemple

>>>import re >>> pattern = re.compile(r'\d+') # Utilisé pour correspondre à au moins un chiffre >>> m = pattern.match('one12twothree34four') # Recherche au début, aucune correspondance >>> print( m ) None >>> m = pattern.match('one12twothree34four', 2, 10) # Commencer la correspondance à partir de la position de 'e', aucune correspondance >>> print( m ) None >>> m = pattern.match('one12twothree34four', 3, 10) # Commencer la correspondance à partir de la position de '1', correspond exactement >>> print( m ) # Renvoie un objet Match <_sre.SRE_Match object at 0x10a42aac0> >>> m.group(0) # 0 peut être omis '12' >>> m.start(0) # 0 peut être omis 3 >>> m.end(0) # 0 peut être omis 5 >>> m.span(0) # 0 peut être omis (3, 5)

Ci-dessus, lorsque la correspondance réussit, un objet Match est renvoyé, où :

group([group1, …])La méthode est utilisée pour obtenir une ou plusieurs chaînes correspondant à un groupe. Lorsque vous devez obtenir la sous-chaîne correspondante entière, vous pouvez directement utilisergroup()ougroup(0)；
start([group])La méthode est utilisée pour obtenir la position de départ de la sous-chaîne correspondant au groupe dans la chaîne entière (l'index du premier caractère de la sous-chaîne). La valeur par défaut du paramètre est 0;
end([group])La méthode est utilisée pour obtenir la position de fin de la sous-chaîne correspondant au groupe dans la chaîne entière (l'index du dernier caractère de la sous-chaîne + 1). La valeur par défaut du paramètre est 0;
span([group])La méthode renvoie(start(group), end(group))。

Regardons un autre exemple :

Exemple

>>>import re >>> pattern = re.compile(r'([a-z]+) ([a-z]+)', re.I) # re.I signifie ignorer la casse >>> m = pattern.match('Hello World Wide Web') >>> print( m ) # Correspondance réussie, renvoie un objet Match <_sre.SRE_Match object at 0x10bea83e8> >>> m.group(0) # Renvoie la sous-chaîne entière qui a été mise en correspondance avec succès 'Hello World' >>> m.span(0) # Renvoie l'index de la sous-chaîne entière mise en correspondance (0, 11) >>> m.group(1) # Renvoie la sous-chaîne mise en correspondance par le premier groupe 'Hello' >>> m.span(1) # Renvoie l'index de la sous-chaîne mise en correspondance par le premier groupe (0, 5) >>> m.group(2) # Renvoie la sous-chaîne mise en correspondance par le deuxième groupe 'World' >>> m.span(2) # Renvoie l'index de la sous-chaîne mise en correspondance par le deuxième groupe (6, 11) >>> m.groups() # Équivalent à (m.group(1), m.group(2), ...) ('Hello', 'World') >>> m.group(3) # Le troisième groupe n'existe pas Traceback (most recent call last): File "<stdin>", line 1, in <module> IndexError: pas de tel groupe

findall

Trouve toutes les sous-chaînes correspondant à l'expression régulière dans la chaîne et renvoie une liste. S'il y a plusieurs motifs correspondants, renvoie une liste de tuples. Si aucune correspondance n'est trouvée, renvoie une liste vide.

Note:match et search correspondent une fois, findall correspond à toutes les correspondances.

La syntaxe est :

re.findall(pattern, string, flags=0)
ou 
pattern.findall(string[, pos[, endpos]])

Paramètres :

patternLe motif de correspondance.
stringLa chaîne à faire correspondre.
posParamètre facultatif, spécifie la position de départ dans la chaîne, sa valeur par défaut est 0.
endposParamètre facultatif, spécifie la position de fin dans la chaîne, sa valeur par défaut est la longueur de la chaîne.

Trouver tous les nombres dans une chaîne :

Exemple

import re result1 = re.findall(r'\d+','example 123 google 456') pattern = re.compile(r'\d+') # Trouver les nombres result2 = pattern.findall('example 123 google 456') result3 = pattern.findall('run88oob123google456', 0, 10) print(result1) print(result2) print(result3)

Résultat de sortie :

['123', '456']
['123', '456']
['88', '12']

Plusieurs motifs de correspondance, renvoie une liste de tuples :

Exemple

import re

result = re.findall(r'(\w+)=(\d+)', 'set width=20 and height=10')
print(result)

[('width', '20'), ('height', '10')]

re.finditer

Similaire à findall, trouve toutes les sous-chaînes correspondant à l'expression régulière dans la chaîne et les renvoie sous forme d'itérateur.

re.finditer(pattern, string, flags=0)

Paramètres :

Paramètre	Description
pattern	L'expression régulière à faire correspondre.
string	La chaîne à faire correspondre.
indicateurs	Drapeaux, utilisés pour contrôler le comportement de correspondance de l'expression régulière, par ex., la sensibilité à la casse, la correspondance multiligne, etc. Voir :Modificateurs d'expressions régulières - drapeaux facultatifs

Exemple

import re it = re.finditer(r"\d+","12a32bc43jf3") for match in it: print (match.group() )

Résultat de sortie :

re.split

La méthode split divise la chaîne par les sous-chaînes correspondantes et renvoie une liste. Son utilisation est la suivante :

re.split(pattern, string[, maxsplit=0, flags=0])

Paramètres :

Paramètre	Description
pattern	L'expression régulière à faire correspondre.
string	La chaîne à faire correspondre.
maxsplit	Nombre de divisions, maxsplit=1 divise une fois, la valeur par défaut est 0, aucune limite sur le nombre.
indicateurs	Drapeaux, utilisés pour contrôler le comportement de correspondance de l'expression régulière, par ex., la sensibilité à la casse, la correspondance multiligne, etc. Voir :Modificateurs d'expressions régulières - drapeaux facultatifs

Exemple

>>>import re >>> re.split('\W+', 'exemple, exemple, exemple.') ['exemple', 'exemple', 'exemple', ''] >>> re.split('(\W+)', ' exemple, exemple, exemple.') ['', ' ', 'exemple', ', ', 'exemple', ', ', 'exemple', '.', ''] >>> re.split('\W+', ' exemple, exemple, exemple.', 1) ['', 'exemple, exemple, exemple.'] >>> re.split('a*', 'bonjour le monde') # Pour une chaîne qui ne trouve pas de correspondance, split ne la divisera pas ['bonjour le monde']

Objet d'expression régulière

re.RegexObject

re.compile() renvoie un objet RegexObject.

re.MatchObject

group() renvoie la chaîne correspondant à l'expression régulière.

start()Renvoie la position de début de la correspondance
end()Renvoie la position de fin de la correspondance
span()Renvoie un tuple contenant les positions (start, end) de la correspondance

Modificateurs d'expressions régulières - Drapeaux facultatifs

Les expressions régulières peuvent inclure certains modificateurs de drapeau facultatifs pour contrôler les modes de correspondance.

Les drapeaux suivants peuvent être utilisés seuls ou combinés avec l'opérateur OU bit à bit (|). Par exemple, re.IGNORECASE | re.MULTILINE signifie activer à la fois les modes insensible à la casse et multiligne.

Modificateur	Description	Exemple
re.IGNORECASE ou re.I	Rend la correspondance insensible à la casse	import re pattern = re.compile(r'apple', flags=re.IGNORECASE) result = pattern.match('Apple') print(result.group()) # 输出: 'Apple'
re.MULTILINE ou re.M	Correspondance multiligne, affecte^et$, ce qui les fait correspondre au début et à la fin de chaque ligne de la chaîne.	import re pattern = re.compile(r'^\d+', flags=re.MULTILINE) text = '123\n456\n789' result = pattern.findall(text) print(result) # 输出: ['123', '456', '789']
re.DOTALL ou re.S:	faire en sorte que.corresponde à n'importe quel caractère, y compris le saut de ligne.	import re pattern = re.compile(r'a.b', flags=re.DOTALL) result = pattern.match('a\nb') print(result.group()) # 输出: 'a\nb'
re.ASCII	Faire en sorte que \w, \W, \b, \B, \d, \D, \s, \S correspondent uniquement aux caractères ASCII.	import re pattern = re.compile(r'\w+', flags=re.ASCII) result = pattern.match('Hello123') print(result.group()) # 输出: 'Hello123'
re.VERBOSE ou re.X	Ignore les espaces blancs et les commentaires, ce qui permet d'organiser plus clairement des expressions régulières complexes.	import re pattern = re.compile(r''' \d+ # 匹配数字 [a-z]+ # 匹配小写字母 ''', flags=re.VERBOSE) result = pattern.match('123abc') print(result.group()) # 输出: '123abc'

Motifs d'expressions régulières

Les chaînes de motif utilisent une syntaxe spéciale pour représenter une expression régulière.

Les lettres et les chiffres se représentent eux-mêmes. Les lettres et les chiffres dans un motif d'expression régulière correspondent aux mêmes chaînes.

La plupart des lettres et des chiffres ont une signification différente lorsqu'ils sont précédés d'une barre oblique inverse.

Les signes de ponctuation ne correspondent à eux-mêmes que lorsqu'ils sont échappés ; sinon, ils représentent des significations spéciales.

La barre oblique inverse elle-même doit être échappée avec une barre oblique inverse.

Comme les expressions régulières contiennent souvent des barres obliques inverses, il est préférable d'utiliser des chaînes brutes pour les représenter. Les éléments de motif (tels quer'\t', équivalent à\\t) correspondent aux caractères spéciaux correspondants.

Le tableau suivant répertorie les éléments spéciaux dans la syntaxe des motifs d'expressions régulières. Si vous fournissez des paramètres de drapeau optionnels lors de l'utilisation de motifs, la signification de certains éléments de motif changera.

Modèle	Description
^	Correspond au début de la chaîne.
$	Correspond à la fin de la chaîne.
.	Correspond à tout caractère sauf le saut de ligne. Lorsque l'indicateur re.DOTALL est spécifié, il peut correspondre à n'importe quel caractère, y compris le saut de ligne.
[...]	Utilisé pour correspondre à l'un des caractères contenus, par exemple, [amk] correspond à 'a', 'm' ou 'k'.
[^...]	Caractères non inclus dans [] : [^abc] correspond à des caractères autres que a, b, c.
re*	Correspond à 0 ou plusieurs répétitions de l'expression.
re+	Correspond à 1 ou plusieurs répétitions de l'expression.
re?	Correspond à 0 ou 1 occurrence du fragment défini par l'expression régulière précédente, non glouton.
re{ n}	Correspond à n occurrences de l'expression précédente. Par exemple, "o{2}" ne peut pas correspondre au "o" dans "Bob", mais peut correspondre aux deux o de "food".
re{ n,}	Correspond à n occurrences ou plus de l'expression précédente. Par exemple, "o{2,}" ne peut pas correspondre au "o" dans "Bob", mais peut correspondre à tous les o de "foooood". "o{1,}" est équivalent à "o+". "o{0,}" est équivalent à "o*".
re{ n, m}	Correspond à n à m répétitions du fragment défini par l'expression régulière précédente, glouton.
a\| b	Correspond à a ou b
(re)	Correspond à l'expression entre parenthèses, et représente également un groupe.
(?imx)	L'expression régulière contient trois indicateurs facultatifs : i, m ou x. N'affecte que la zone entre parenthèses.
(?-imx)	L'expression régulière désactive les indicateurs facultatifs i, m ou x. N'affecte que la zone entre parenthèses.
(?: re)	Similaire à (...), mais ne représente pas un groupe.
(?imx: re)	Utilise les indicateurs facultatifs i, m ou x entre les parenthèses.
(?-imx: re)	N'utilise pas les options facultatives i, m ou x à l'intérieur des parenthèses.
(?#...)	Commentaire.
(?= re)	Assertion d'anticipation positive. Si l'expression régulière contenue, désignée par ..., correspond avec succès à la position actuelle, elle réussit ; sinon, elle échoue. Toutefois, une fois que l'expression contenue a été tentée, le moteur de correspondance n'avance pas du tout ; le reste du motif essaie toujours la partie droite de l'assertion.
(?! re)	Assertion d'anticipation négative. L'opposé de l'assertion positive ; réussit lorsque l'expression contenue ne peut pas correspondre à la position actuelle dans la chaîne.
(?> re)	Motif de correspondance indépendant, sans retour arrière.
\w	Correspond aux chiffres, aux lettres et au trait de soulignement.
\W	Correspond à tout caractère qui n'est pas un chiffre, une lettre ou un trait de soulignement.
\s	Correspond à tout caractère d'espacement, équivalent à [\t\n\r\f].
\S	Correspond à tout caractère non blanc.
\d	Correspond à tout chiffre, équivalent à [0-9].
\D	Correspond à tout caractère non numérique.
\A	Correspond au début de la chaîne.
\Z	Correspond à la fin de la chaîne. S'il y a un saut de ligne, il correspond uniquement à la fin de la chaîne avant le saut de ligne.
\z	Correspond à la fin de la chaîne.
\G	Correspond à la position où la dernière correspondance s'est terminée.
\b	Correspond à une limite de mot, qui est la position entre un mot et un espace. Par exemple, 'er\b' peut correspondre au 'er' dans « never », mais ne peut pas correspondre au 'er' dans « verb ».
\B	Correspond à une limite de non-mot. 'er\B' peut correspondre au 'er' dans "verb", mais ne peut pas correspondre au 'er' dans "never".
\n, \t, etc.	Correspond à un saut de ligne. Correspond à une tabulation, etc.
\1...\9	Correspond au contenu du n-ième groupe.
\10	Correspond au contenu du n-ième groupe s'il a été mis en correspondance. Sinon, il fait référence à une expression de code de caractère octal.

Exemples d'expressions régulières

Correspondance de caractères

Exemple	Description
python	Correspond à "python".

Classes de caractères

Exemple	Description
[Pp]ython	Correspond à « Python » ou « python »
rub[ye]	Correspond à « ruby » ou « rube »
[aeiou]	Correspond à n'importe quelle lettre entre les crochets
[0-9]	Correspond à n'importe quel chiffre. Similaire à
[a-z]	Correspond à n'importe quelle lettre minuscule
[A-Z]	Correspond à n'importe quelle lettre majuscule
[a-zA-Z0-9]	Correspond à n'importe quelle lettre et chiffre
[^aeiou]	Tous les caractères sauf les lettres aeiou
[^0-9]	Correspond aux caractères autres que les chiffres

Classes de caractères spéciaux

Exemple	Description
.	Correspond à tout caractère unique sauf "\n". Pour correspondre à n'importe quel caractère, y compris '\n', utilisez un motif comme '[.\n]'.
\d	Correspond à un chiffre. Équivalent à [0-9].
\D	Correspond à un caractère autre qu'un chiffre. Équivalent à [^0-9].
\s	Correspond à tout caractère d'espacement, y compris l'espace, la tabulation, le saut de page, etc. Équivalent à [ \f\n\r\t\v].
\S	Correspond à tout caractère qui n'est pas un caractère d'espacement. Équivalent à [^ \f\n\r\t\v].
\w	Correspond à tout caractère de mot, y compris le trait de soulignement. Équivalent à '[A-Za-z0-9_]'.
\W	Correspond à tout caractère qui n'est pas un caractère de mot. Équivalent à '[^A-Za-z0-9_]'.

Autres extensions

Python3Tutoriel avancé

Expressions régulières Python3

Fonction re.match

Exemple

Exemple

méthode re.search

Exemple

Exemple

Différence entre re.match et re.search

Exemple

Rechercher et remplacer

Exemple

Le paramètre repl est une fonction

Exemple

fonction compile

Exemple

Exemple

Exemple

findall

Exemple

Exemple

re.finditer

Exemple

re.split

Exemple

Objet d'expression régulière

re.RegexObject

re.MatchObject

Modificateurs d'expressions régulières - Drapeaux facultatifs

Motifs d'expressions régulières

Exemples d'expressions régulières

Correspondance de caractères

Classes de caractères

Classes de caractères spéciaux