Synthèse des connaissances et partage des expressions régulières en Python

Cet article présente les connaissances de base des expressions régulières Python. Le contenu de cet article n'inclut pas comment écrire des expressions régulières efficaces ni comment optimiser les expressions régulières. Veuillez consulter d'autres didacticiels sur ces sujets.

1. Syntaxe des expressions régulières

1.1 Caractères et classes de caractères
1 Caractères spéciaux : .^$?+*{}[]()|
Si vous souhaitez utiliser des valeurs littérales, les caractères spéciaux ci-dessus doivent être échappés en utilisant
2 Classes de caractères
1. Un ou plusieurs caractères contenus dans [] sont appelés classes de caractères Lors de la correspondance, la classe de caractères le fera Si non. quantificateur est spécifié, un seul d’entre eux sera mis en correspondance.
2. Une plage peut être spécifiée dans la classe de caractères, par exemple [a-zA-Z0-9] représente n'importe quel caractère de a à z, A à Z, 0 à 9
3. Le crochet gauche est suivi de A ^ signifie la négation d'une classe de caractères. Par exemple, [^0-9] signifie qu'elle peut correspondre à n'importe quel caractère autre qu'un chiffre.
4. Au sein de la classe de caractères, à l'exception de , les autres caractères spéciaux n'ont plus de signification particulière et représentent tous des valeurs littérales. ^ placé en première position représente la négation, placé dans d'autres positions représente ^ lui-même, - placé au milieu représente une plage et placé comme premier caractère d'une classe de caractères représente - lui-même.

5. Le raccourci peut être utilisé dans la classe de caractères, tel que d s w
3 Shorthand
. Peut correspondre à n'importe quel caractère, à l'exception des sauts de ligne. S'il y a l'indicateur re.DOTALL, il correspondra à n'importe quel caractère. caractère Y compris la nouvelle ligne
　　 d correspond à un chiffre Unicode, s'il a re.ASCII, il correspond à 0-9
　 　　 D correspond à un chiffre Unicode non numérique
　　 s correspond à Unicode vide, s'il porte re.ASCII, il correspond tnrfv A
S correspond à des espaces non-blancs Unicode
w correspond à des caractères de mot Unicode, s'il est avec re.ascii, correspond à l'un des [a-zA-Z0-9_]
W correspond à un caractère non unique Unicode

1.2 Quantificateur
1. ? Faire correspondre le caractère précédent 0 ou 1 fois
2. * Faire correspondre le caractère précédent 0 fois ou plus
3. + Faire correspondre le caractère précédent 1 fois ou plus
4. {m} correspond à l'expression précédente m fois
5. {m,} correspond à l'expression précédente au moins m fois
6. {,n} correspond à l'expression régulière précédente au plus n fois
7. {m,n} correspond à l'expression régulière précédente au moins m fois et au plus n fois
Remarque :
Les quantificateurs ci-dessus sont des modes gourmands et en correspondront autant que possible si vous souhaitez le modifier. au mode non gourmand est implémenté en faisant suivre le quantificateur avec un ?

1.3 Regroupement et capture
1 Le rôle de ():
1. Capturer le contenu de l'expression régulière dans () pour plus traitement , vous pouvez désactiver la fonction de capture de cette parenthèse en suivant ? : après la parenthèse gauche
2. Combinez une partie de l'expression régulière pour utiliser des quantificateurs ou |
2 La réponse fait référence au contenu capturé dans le précédent () :
1. Référence arrière
via le numéro de groupe Chaque parenthèse qui n'utilise pas ?: se verra attribuer un groupe, en commençant par 1 et en augmentant de gauche à droite. Vous pouvez vous référer à l'expression de la précédente. () via i Contenu capturé
2. Faites référence au contenu capturé dans les parenthèses précédentes
via le nom du groupe Vous pouvez créer un groupe en suivant le crochet ouvrant ?P crochets. Alias, suivi de (?P=nom) pour référencer le contenu précédemment capturé. Tels que (? Pw+)s+(?P=word) pour faire correspondre les mots répétés.
3 Notes :
Les références arrière ne peuvent pas être utilisées dans les classes de caractères [].

1.4 Assertions et balises
Les assertions ne correspondront à aucun texte, mais imposeront seulement certaines contraintes sur le texte où se trouve l'assertion
1 Assertions couramment utilisées :
1. b correspond à la limite d'un mot et est placé dans la classe de caractères [ ] signifie retour arrière
2. B correspond aux limites non-mots, affectées par les balises ASCII
3. A correspond à
au début 4. ^ correspond au début, s'il y a est le drapeau MULTILINE, puis dans Matches
après chaque caractère de nouvelle ligne 5. Z correspond à
à la fin 6. $ correspond à la fin, s'il y a le drapeau MULTILINE, correspond à
avant chaque caractère de nouvelle ligne 7. (?=e) Anticipation positive
8. (?!e) Antiquité négative
9. (?<=e) Rétrospective positive
10. (? 2 Explication du look-ahead
　　　Look forward : exp1(?=exp2) Le contenu après exp1 doit correspondre à exp2
　　 Lookahead négatif : exp1(?!exp2) Le contenu après exp1 ne peut pas match exp2
　　　Lookback : (?<=exp2)exp1 Le contenu avant exp1 doit correspondre à exp2
　　anticipation négative : (?　　　Par exemple : nous je veux trouver bonjour, mais bonjour doit être suivi de monde. L'expression régulière peut être comme ceci Écrivez : "(hello)s+(?=world)", utilisé pour correspondre à "hello wangxing" et "hello world". correspond au bonjour de ce dernier

　1.5 Correspondance conditionnelle
　　(?(id )yes_exp|no_exp) : Si la sous-expression correspondant à l'identifiant correspond au contenu, alors elle correspond à yes_exp, sinon elle correspond à no_exp

　1.6 Indicateurs d'expression régulière
1. Il existe deux types d'indicateurs d'expression régulière Utilisation
1. En passant le paramètre flag à la méthode de compilation, plusieurs indicateurs peuvent être séparés par |, comme re.compile( r"#[da-f]{6}b", re.IGNORECASE|re. MULTILINE)
2. Ajoutez un indicateur à l'expression régulière en ajoutant (? flag) devant l'expression régulière, tel que ( ?ms)#[da-z]{6}b
2. Indicateurs couramment utilisés
　　 re.A ou re.ASCII, de sorte que b B s S w W d D supposent tous que la chaîne est Supposons que la chaîne est ASCII
　　 re.I ou re.IGNORECASE fait que l'expression régulière ignore la casse
re.M ou re.MULTILINE correspond à plusieurs lignes afin que chacune ^ corresponde après chaque retour chariot et chaque $ corresponde avant chaque retour chariot
　　 re.S ou re.DOTALL permet de faire correspondre n'importe quel caractère, y compris Enter
　　 re. Tels que :
　　 re.compile(r"""

　　　　(?:
　　　　　(?P["']) #Guillemet gauche
 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　duct_
citation) #Parenthèse droite
　　　　　""",re.VERBOSE|re.IGNORECASE)

2. Module d'expression régulière Python

2.1 Expression régulière Traitement des expressions les chaînes ont quatre fonctions principales

1. Faire correspondre pour voir si une chaîne est conforme à la grammaire d'une expression régulière, renvoyant généralement vrai ou faux

2. Obtenir l'expression régulière pour extraire le texte dans la chaîne qui répond aux exigences

3. Remplacez le texte qui correspond à l'expression régulière dans la chaîne de recherche et remplacez-le par la chaîne correspondante
4. Divisez la chaîne à l'aide d'expressions régulières

2.2 Deux façons d'utiliser les expressions régulières dans le module re en Python

1. Utilisez la méthode re.compile(r, f) pour générer un objet d'expression régulière, puis appelez l'expression régulière Le méthode correspondante de l'objet.L'avantage de cette approche est qu'elle peut être utilisée plusieurs fois après avoir généré l'objet d'expression régulière 2. Il existe une méthode de module correspondante pour chaque méthode d'objet de l'objet d'expression régulière dans le module re. La différence est que le premier paramètre transmis est une chaîne d'expression régulière. Cette méthode convient aux expressions régulières qui ne sont utilisées qu'une seule fois. 2.3 Méthodes courantes des objets d'expression régulière

.

1. rx.findall(s,start, end):
Renvoie une liste S'il n'y a pas de regroupement dans l'expression régulière, la liste contient tout le contenu correspondant
S'il n'y a pas de regroupement dans l'expression régulière. expression régulière S'il y a un regroupement, chaque élément de la liste est un tuple. Le tuple contient le contenu correspondant dans le sous-groupe, mais le contenu correspondant à l'ensemble de l'expression régulière n'est pas renvoyé
　　2. rx.finditer(s, start , end):
Renvoie un objet itérable
Parcourez l'objet itérable et renvoyez un objet correspondant à chaque fois. Vous pouvez appeler la méthode group() de l'objet correspondant pour afficher le contenu correspondant au groupe spécifié 0. représente l'intégralité de l'expression régulière. Le contenu correspondant à la formule
3. rx.search(s, start, end):
Renvoie un objet correspondant s'il n'y a pas de correspondance, il renvoie Aucun
La recherche. La méthode ne correspond qu'une seule fois et s'arrête. Elle ne continuera pas à correspondre
4. rx.match(s, start, end):
Si l'expression régulière correspond au début de la chaîne, renvoie un objet correspondant, sinon return Aucun
5. rx.sub(x, s, m):
Renvoie une chaîne. Remplacez chaque position correspondante par x et renvoyez la chaîne remplacée Si m est spécifié, elle sera remplacée jusqu'à m fois. Pour x, vous pouvez utiliser /i ou /g peut être un nom ou un numéro de groupe pour référencer le contenu capturé.
　　　x dans la méthode module re.sub(r, x, s, m) peut utiliser une fonction. À ce stade, nous pouvons transmettre le contenu capturé via cette fonction pour traitement, puis remplacer le texte correspondant.
6. rx.subn(x, s, m):
Identique à la méthode re.sub(), la différence est qu'elle renvoie un tuple, dont l'un est la chaîne de résultat et l'autre est le numéro de remplacement .
7. rx.split(s, m) : Diviser la chaîne
Renvoie une liste
Diviser la chaîne en utilisant le contenu correspondant à l'expression régulière
S'il y a des groupes dans l'expression régulière, alors placez le contenu correspondant par le groupe au milieu de chacune des deux divisions de la liste dans le cadre de la liste, par exemple :
　　rx = re.compile(r"(d)[a-z]+(d)")
s = "ab12dk3klj8jk9jks5"
résultat = rx.split(s)
Retour ['ab1', '2', '3', 'klj', '8', '9', 'jks5' ]
8. rx.flags() : Indicateurs définis lors de la compilation d'expressions régulières
9. rx.pattern() : Chaîne utilisée lors de la compilation d'expressions régulières

2.4 Objets correspondants Propriétés et méthodes de

01. m.group(g, ...)
Renvoie le contenu correspondant au numéro ou au nom du groupe. La valeur par défaut ou 0 indique le contenu correspondant à l'expression entière If. plusieurs sont spécifiés, un tuple
sera renvoyé 02. m.groupdict(default)
Renvoie un dictionnaire. La clé du dictionnaire est le nom de groupe de tous les groupes nommés, et la valeur est le contenu capturé par le groupe nommé
S'il existe un paramètre par défaut, il sera utilisé comme valeur par défaut pour les groupes qui ne participent pas dans la correspondance.
03. m.groups(default)
Renvoie un tuple. Contient tous les sous-groupes qui capturent le contenu, à partir de 1. Si une valeur par défaut est spécifiée, cette valeur est utilisée comme valeur du groupe qui n'a pas capturé le contenu
04. m.lastgroup()
Le nombre de le contenu correspondant Le nom du groupe de capture le plus élevé Si aucun nom n'est utilisé, renvoie Aucun (rarement utilisé)
　　05. m.lastindex()
　　 Le numéro du groupe de capture ayant le numéro le plus élevé qui correspond. le contenu, sinon, renvoie None .
06. m.start(g):
Le sous-groupe de l'objet correspondant actuel est mis en correspondance à partir de cette position dans la chaîne Si le groupe actuel ne participe pas à la correspondance, -1 est renvoyé
07. .m.end (g)
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 de cette position de la chaîne à la fin du match, si le groupe actuel ne participe pas au match, -1 est renvoyé '　　
　　08. m.span( )
　　 Renvoie un groupe binaire, le contenu est la valeur de retour de m.start(g) et m.end(g)
　　09. m.re()
　　 L'expression régulière qui génère cet objet correspondant
　　 10. m. string()
La chaîne
passée à la correspondance ou à la recherche de correspondance 11. m.pos()
La position de départ de la recherche. C'est-à-dire le début de la chaîne, ou la position spécifiée par start (pas couramment utilisé)
　12. m.endpos()
　La position finale de la recherche. C'est-à-dire la position de fin de la chaîne, ou la position spécifiée par end (pas couramment utilisé)

　2.5 Résumé

1. Pour la fonction de correspondance d'expression régulière, Python n'a pas de méthode pour renvoyer vrai et faux, mais cela peut être jugé selon que la valeur de retour de la méthode de correspondance ou de recherche est Aucune
2. Pour le. Fonction de recherche d'expression régulière , si vous effectuez une seule recherche, vous pouvez utiliser l'objet correspondant renvoyé par la méthode search ou match. Pour plusieurs recherches, vous pouvez utiliser l'objet itérable renvoyé par la méthode finditer pour accéder de manière itérative à
3. Pour le fonction de remplacement des expressions régulières, vous pouvez utiliser des expressions régulières. Elle peut être implémentée par la méthode sub ou subn de l'objet formule, ou par la méthode re module sub ou subn La différence est que le texte de remplacement de la méthode sub du module. peut être généré à l'aide d'une fonction
4. Pour la fonction de segmentation d'expression régulière, vous pouvez utiliser la méthode split de l'objet d'expression régulière. Il est à noter que si l'objet d'expression régulière est regroupé, le contenu capturé par le groupe le sera. être également placé dans la liste des retours

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!