Expressions régulières Python

Une expression régulière est une séquence spéciale de caractères qui peut vous aider à vérifier facilement si une chaîne correspond à un certain modèle.

Python a ajouté le module re depuis la version 1.5, qui fournit des modèles d'expressions régulières de style Perl. Le module

re apporte toutes les capacités d'expression régulière au langage Python. La fonction

compile génère un objet d'expression régulière basé sur une chaîne de modèle et des arguments d'indicateur facultatifs. Cet objet dispose d'une série de méthodes pour la correspondance et le remplacement des expressions régulières. Le module

re fournit également des fonctions identiques à ces méthodes, qui prennent une chaîne de modèle comme premier argument.

Ce chapitre présente principalement les fonctions de traitement d'expressions régulières couramment utilisées en Python.

---

Fonction re.match

re.match essaie de faire correspondre un modèle à partir de la position de départ de la chaîne Si la correspondance échoue à partir de la position de départ, match() renvoie. aucun.

Syntaxe de la fonction :

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

Description du paramètre de fonction :

参数	描述
pattern	匹配的正则表达式
string	要匹配的字符串。
flags	标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

La méthode re.match renvoie un objet correspondant si la correspondance est réussie, sinon, il renvoie None .

Nous pouvons utiliser la fonction d'objet correspondant group(num) ou groups() pour obtenir l'expression correspondante.

匹配对象方法	描述
group(num=0)	匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。
groups()	返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。

Instance 1 :

#!/usr/bin/python
# -*- coding: UTF-8 -*- 

import re
print(re.match('www', 'www.php.cn').span())  # 在起始位置匹配
print(re.match('com', 'www.php.cn'))         # 不在起始位置匹配

La sortie de l'instance ci-dessus est :

(0, 3)
None

Instance 2 :

#!/usr/bin/python
import re

line = "Cats are smarter than dogs"

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 "No match!!"

Le résultat de l'exécution de ce qui précède L'instance est la suivante :

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

---

méthode re.search

re.search analyse la chaîne entière et renvoie la première correspondance réussie.

Syntaxe de la fonction :

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

Description du paramètre de fonction :

参数	描述
pattern	匹配的正则表达式
string	要匹配的字符串。
flags	标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

La méthode re.search renvoie un objet correspondant si la correspondance est réussie, sinon elle renvoie Aucun.

Nous pouvons utiliser la fonction d'objet correspondant group(num) ou groups() pour obtenir l'expression correspondante.

匹配对象方法	描述
group(num=0)	匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。
groups()	返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。

Instance 1 :

#!/usr/bin/python
# -*- coding: UTF-8 -*- 

import re
print(re.search('www', 'www.php.cn').span())  # 在起始位置匹配
print(re.search('com', 'www.php.cn').span())         # 不在起始位置匹配

La sortie de l'instance ci-dessus est :

(0, 3)
(11, 14)

Instance 2 :

#!/usr/bin/python
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 "Nothing found!!"

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

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

---

La différence entre re.match et re.search

re.match correspond uniquement 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 Aucun ; tandis que re.search Correspond à la chaîne entière jusqu'à ce qu'une correspondance soit trouvée.

Exemple :

#!/usr/bin/python
import re

line = "Cats are smarter than dogs";

matchObj = re.match( r'dogs', line, re.M|re.I)
if matchObj:
   print "match --> matchObj.group() : ", matchObj.group()
else:
   print "No match!!"

matchObj = re.search( r'dogs', line, re.M|re.I)
if matchObj:
   print "search --> matchObj.group() : ", matchObj.group()
else:
   print "No match!!"

Les résultats de l'exemple ci-dessus sont les suivants :

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

---

Récupération et remplacement

Le module re de Python fournit re.sub pour remplacer les chaînes Matches. .

Syntaxe :

re.sub(pattern, repl, string, max=0)

La chaîne renvoyée est remplacée par la correspondance non répétitive la plus à gauche de RE dans la chaîne. Si le modèle n'est pas trouvé, le caractère sera renvoyé inchangé.

Le nombre de paramètres facultatifs est le nombre maximum de substitutions après la correspondance de modèles ; le nombre doit être un entier non négatif ; La valeur par défaut est 0 qui remplace toutes les correspondances.

Exemple :

#!/usr/bin/python
import re

phone = "2004-959-559 # This is Phone Number"

# Delete Python-style comments
num = re.sub(r'#.*$', "", phone)
print "Phone Num : ", num

# Remove anything other than digits
num = re.sub(r'\D', "", phone)    
print "Phone Num : ", num

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

Phone Num :  2004-959-559
Phone Num :  2004959559

---

Modificateur d'expression régulière - indicateurs facultatifs

Les expressions régulières peuvent contenir des modifications d'indicateur facultatives caractère pour contrôler les modèles correspondants. Le modificateur est spécifié comme indicateur facultatif. Plusieurs indicateurs peuvent être spécifiés par OU(|) au niveau du bit. Par exemple, re.I | re.M est défini sur les indicateurs I et M :

修饰符	描述
re.I	使匹配对大小写不敏感
re.L	做本地化识别（locale-aware）匹配
re.M	多行匹配，影响 ^ 和 $
re.S	使 . 匹配包括换行在内的所有字符
re.U	根据Unicode字符集解析字符。这个标志影响 w, W, b, B.
re.X	该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。

---

Modèle d'expression régulière

Les chaînes de modèles 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 d'un modèle d'expression régulière correspondent à la même chaîne.

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

Les signes de ponctuation ne se correspondent que s'ils sont échappés, sinon ils représentent une signification particulière.

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

Étant donné que les expressions régulières contiennent généralement 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 que r'/t', équivalent à '//t') correspondent aux caractères spéciaux correspondants.

Le tableau suivant répertorie les éléments spéciaux dans la syntaxe du modèle d'expression régulière. Si vous utilisez un modèle et fournissez des arguments flags facultatifs, la signification de certains éléments du modèle changera.

Transférer. délimiteur positif. Réussit si l'expression régulière contenue, notée ... , correspond avec succès à la position actuelle, sinon elle échoue. Mais une fois l'expression contenue essayée, le moteur de correspondance ne s'améliore pas du tout ; le reste du modèle doit encore essayer le côté droit du délimiteur. Délimiteur négatif avant. L'opposé du délimiteur positif ; réussit lorsque l'expression contenue ne peut pas être mise en correspondance à la position actuelle dans la chaîne Modèle indépendant correspondant, omis Go faire marche arrière. correspond aux caractères alphanumériques et aux traits de soulignementcorrespond aux caractères non alphanumériques et aux traits de soulignement correspond à n'importe quel caractère d'espacement, équivalent à [tnrf]. correspond Tout caractère non vide correspond à n'importe quel nombre, équivalent à [0-9].correspond à n'importe quel non-numérocorrespond au début de la chaîne Correspond à la fin de la chaîne S'il y a une nouvelle ligne, seule la fin de la chaîne avant la nouvelle ligne correspond. c correspond à la fin de la chaîne correspond à la position où le le dernier match est terminé. correspond à une limite de mot, qui fait référence à la position entre un mot et un espace. Par exemple, « erb » correspond à « er » dans « jamais » mais pas à « er » dans « verbe ». correspond aux limites autres que les mots. « erB » correspond à « er » dans « verbe » mais pas dans « jamais ». correspond à un caractère de nouvelle ligne. Correspond à un caractère de tabulation. etc. correspond à la sous-expression du nième groupe. Correspond à la sous-expression du nième groupe si elle correspond. Sinon, il s'agit de l'expression du code de caractère octal. Exemple d'expression régulière

Motif	Description
^	Correspond au début de la chaîne
$	correspond à la fin de la chaîne.
.	correspond à n'importe quel caractère à l'exception du caractère de nouvelle ligne. Lorsque l'indicateur re.DOTALL est spécifié, il peut correspondre à n'importe quel caractère, y compris le caractère de nouvelle ligne.
[...]	est utilisé pour représenter un groupe de caractères, répertoriés séparément : [amk] correspond à 'a', 'm' ou 'k'
[^...]	Caractères non compris dans [] : [^abc] correspond aux caractères autres que a, b, c.
re*	correspond à 0 ou plusieurs expressions.
re+	correspond à une ou plusieurs expressions.
re?	Correspond à 0 ou 1 fragments définis par l'expression régulière précédente, de manière non gourmande
re{ n>
re{ n,}	Correspond exactement à n expressions précédentes.
re{ n, m}	Faire correspondre n à m fois le fragment défini par l'expression régulière précédente, de manière gourmande
a| b	correspond à a ou b
(re)	G 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)	Expression régulière pour désactiver les indicateurs facultatifs i, m ou x. N'affecte que la zone entre parenthèses.
(?:re)	est similaire à (...), mais ne représente pas un groupe
(?imx : re)	entre parenthèses en utilisant i, m ou x drapeaux facultatifs
(?-imx : re)	entre parenthèses N'utilisez pas les indicateurs facultatifs i, m ou x
(?#...)	commentaire (?= re)
	(?! re)
	(?> re)
	w
	W
	s
	S
	d
	D
	A
	Z
	z
	G
	b
	B
	n, t, etc.
	1...9
	10

Correspondance de caractères

---

python

Exemple	Description

实例	描述
python	匹配 "python".

correspond à "python".<🎜> < 🎜><🎜><🎜>

Classe de caractères

实例	描述
[Pp]ython	匹配 "Python" 或 "python"
rub[ye]	匹配 "ruby" 或 "rube"
[aeiou]	匹配中括号内的任意一个字母
[0-9]	匹配任何数字。类似于 [0123456789]
[a-z]	匹配任何小写字母
[A-Z]	匹配任何大写字母
[a-zA-Z0-9]	匹配任何字母及数字
[^aeiou]	除了aeiou字母以外的所有字符
[^0-9]	匹配除了数字外的字符

Classe de caractères spéciaux

实例	描述
.	匹配除 "n" 之外的任何单个字符。要匹配包括 'n' 在内的任何字符，请使用象 '[.n]' 的模式。
d	匹配一个数字字符。等价于 [0-9]。
D	匹配一个非数字字符。等价于 [^0-9]。
s	匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ fnrtv]。
S	匹配任何非空白字符。等价于 [^ fnrtv]。
w	匹配包括下划线的任何单词字符。等价于'[A-Za-z0-9_]'。
W	匹配任何非单词字符。等价于 '[^A-Za-z0-9_]'。