Opérations d'expression régulière du module re de Python

Ce module fournit des opérations de correspondance d'expressions régulières similaires à Perl. La même chose s'applique aux chaînes Unicode.

Les expressions régulières utilisent une barre oblique inverse " " pour représenter des formes spéciales ou comme caractères d'échappement, ce qui entre en conflit avec la syntaxe de Python. Par conséquent, Python utilise " \\ " pour représenter les expressions régulières " ", car si vous le souhaitez. correspond à " " dans l'expression régulière, vous devez l'échapper et le remplacer par " \ ", et dans la syntaxe Python, vous devez échapper à chaque élément de la chaîne, il devient donc " \\ ".

Trouvez-vous la méthode d'écriture ci-dessus gênante ? Afin de rendre les expressions régulières plus lisibles, Python a spécialement conçu des chaînes brutes. Je dois vous rappeler que dans N'utilisez pas de chaîne brute lors de l'écriture des chemins de fichiers. , il y a des pièges ici. La chaîne brute utilise « r » comme préfixe de la chaîne, tel que r « n » : elle représente deux caractères « » et « n » au lieu d’un caractère de nouvelle ligne. Ce formulaire est recommandé lors de l'écriture d'expressions régulières en Python.

La plupart des opérations sur les expressions régulières peuvent atteindre le même objectif que les fonctions au niveau du module ou les méthodes RegexObject. Et cela ne vous oblige pas à compiler l'objet d'expression régulière depuis le début, mais vous ne pouvez pas utiliser certains paramètres de réglage pratiques.

1. Syntaxe des expressions régulières

Afin de gagner de la place, elle ne sera pas décrite ici.

2. La différence entre mars et recherche

Python propose deux opérations primitives différentes : match et search . La correspondance commence au point de départ de la chaîne, tandis que la recherche (perl par défaut) démarre toute correspondance à partir de la chaîne.

Remarque : lorsque l'expression régulière commence par '^', la correspondance et la recherche sont identiques. match ne réussira que si et seulement si la chaîne correspondante peut être mise en correspondance depuis le début ou peut être mise en correspondance à partir de la position du paramètre pos. Comme suit :

>>> import re
>>> re.match("c", "abcdef")
>>> re .search("c","abcdef")
<_sre.SRE_Match objet à 0x00A9A988>
>>> re.match("c", "cabcdef")
< _sre Objet .SRE_Match à 0x00A9AB80>
>>> re.search("c","cabcdef")
<_sre.SRE_Match objet à 0x00AF1720>
>>> = re.compile("c")
>>> patterm.match("abcdef")
>>> patterm.match("abcdef",1)
> > ;> patterm.match("abcdef",2)
<_sre.SRE_Match objet à 0x00A9AB80>

3. >
re.compile(pattern, flags=0)

Compilez l'expression régulière et renvoyez l'objet RegexObject, puis vous pouvez appeler match() et search( ) via la méthode objet RegexObject.

prog = re.compile(pattern)

result = prog.match(string)

et

result = re .match(pattern, string)

est équivalent.

La première méthode peut réaliser la réutilisation d'expressions régulières.

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

Recherchez dans la chaîne pour voir si elle peut correspondre à l'expression régulière. Renvoie un objet _sre.SRE_Match, ou None si aucune correspondance n'est trouvée.

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

Si le début de la chaîne peut correspondre à l'expression régulière. Renvoie un objet _sre.SRE_Match, ou None si aucune correspondance n'est trouvée.

re.split(pattern, string, maxsplit=0)

Divisez la chaîne par expression régulière. Si vous placez l'expression régulière entre parenthèses, la chaîne correspondante sera également incluse dans la liste et renvoyée. maxsplit est le nombre de séparations, maxsplit=1 se sépare une fois, la valeur par défaut est 0 et il n'y a pas de limite sur le nombre de fois.

>>> re.split('W', 'Mots, mots, mots.')

['Mots', 'mots', 'mots',' ]

>>> re.split('(W )', 'Mots, mots, mots.')
['Mots', ', ', 'mots', ', ', ' mots', '.', '']
>>> re.split('W', 'Mots, mots, mots.', 1)
['Mots', 'mots, mots .']
>>> re.split('[a-f] ', '0a3B9', flags=re.IGNORECASE)


Remarque : Le Python que j'utilise est 2.6, En regardant le code source, j'ai trouvé que split() n'avait pas le paramètre flags, qui a été ajouté dans la version 2.7. J'ai rencontré ce problème plus d'une fois. La documentation officielle n'est pas cohérente avec le code source. Si vous trouvez une anomalie, vous devez consulter le code source pour en trouver la raison.

S'il y a une correspondance au début ou à la fin de la chaîne, la liste renvoyée commencera ou se terminera par une chaîne vide.

>>> re.split('(W )', '...mots, mots...')
['', '...', 'mots', ', ', 'words', '...', '']

Si la chaîne ne peut pas correspondre, une liste de la chaîne entière sera renvoyée.

>>> re.split("a","bbb")
['bbb']

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

Trouvez toutes les sous-chaînes correspondant à RE et renvoyez-les sous forme de liste. Les matchs sont retournés dans l'ordre de gauche à droite. S'il n'y a pas de correspondance, une liste vide est renvoyée.

>>> re.findall("a","bcdef")
[]

>>> (r"d ","12a32bc43jf3")
['12', '32', '43', '3']

re.finditer(motif, chaîne, drapeaux=0 )

Trouvez toutes les sous-chaînes correspondant à RE et renvoyez-les en tant qu'itérateur. Les matchs sont retournés dans l'ordre de gauche à droite. S'il n'y a pas de correspondance, une liste vide est renvoyée.

>>> it = re.finditer(r"d ","12a32bc43jf3")
>>> pour la correspondance :
imprimer la correspondance. group()

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

Trouver toutes les sous-chaînes correspondant à RE et utiliser un remplacement de chaîne différent. Le nombre d'arguments facultatifs est le nombre maximum de substitutions après une correspondance de modèle ; le nombre doit être un entier non négatif. La valeur par défaut est 0 qui remplace toutes les correspondances. S'il n'y a pas de correspondance, la chaîne sera renvoyée inchangée.

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

a le même effet que la méthode re.sub, mais renvoie un new Un double-tuple de chaîne et le nombre d'exécutions de remplacement.

re.escape(string)

Échapper les caractères non alphanumériques dans la chaîne

re.purge()

Effacer les expressions régulières dans le cache

4. Objet d'expression régulière

re.RegexObject

re.compile() renvoie l'objet RegexObject

re.MatchObject

group() renvoie celui correspondant à RE String

start() renvoie la position où le match commence

end() renvoie la position où le match se termine

span() renvoie a Le tuple contient la position du match (début, fin)

5. Compiler les drapeaux

La compilation flag vous permet de modifier certaines des façons dont les expressions régulières fonctionnent. Dans le module re, le drapeau peut utiliser deux noms, l'un est le nom complet tel que IGNORECASE et l'autre est l'abréviation, sous forme d'une lettre telle que I. (Si vous êtes familier avec la modification du mode Perl, les formes à une lettre utilisent la même lettre ; par exemple, l'abréviation de re.VERBOSE est re.X.) Plusieurs indicateurs peuvent être spécifiés en les effectuant par un OU au niveau du bit. Par exemple, re.I | re.M est défini sur les indicateurs I et M :

I
IGNORECASE

fait correspondre la casse -sensible Insensible ; les classes de caractères et les chaînes ignorent la casse lors de la correspondance des lettres. Par exemple, [A-Z] peut également correspondre à des lettres minuscules et Spam peut correspondre à « Spam », « spam » ou « spAM ». Cette lettre minuscule ne prend pas en compte la position actuelle.

L
LOCALE

Affecte "w, "W, "b et "B, en fonction de la localisation actuelle configurée .

locales est une fonctionnalité de la bibliothèque de langage C qui est utilisée pour fournir une assistance à la programmation qui doit prendre en compte différents langages. Par exemple, si vous travaillez avec du texte français, vous souhaitez faire correspondre le texte avec « w », mais « w » ne correspond qu'à la classe de caractères [A-Za-z] ; il ne correspond pas à « é » ou « ? . Si votre système est configuré correctement et que les paramètres régionaux sont définis sur le français, une fonction C interne indiquera au programme que « é » doit également être considéré comme une lettre. L'utilisation de l'indicateur LOCALE lors de la compilation d'une expression régulière entraînera un objet compilé qui utilise ces fonctions C pour gérer "w", ce qui sera plus lent, mais vous permettra toujours d'utiliser "w pour faire correspondre le texte français.

M
MULTILINE

(^ et $ ne seront pas interprétés pour le moment ; ils seront introduits dans la section 4.1.)

Utilisez "^" pour faire correspondre uniquement le début de la chaîne, tandis que $ ne correspondra qu'à la fin de la chaîne et à la fin de la chaîne immédiatement avant une nouvelle ligne (le cas échéant). Lorsque cet indicateur est spécifié, "^" correspond au début de la chaîne et au début de chaque ligne de la chaîne. De même, le métacaractère $ correspond à la fin de la chaîne et à la fin de chaque ligne de la chaîne (directement avant chaque nouvelle ligne).

S
DOTALL

fait en sorte que le caractère spécial "." corresponde exactement à n'importe quel caractère, y compris les nouvelles lignes sans cet indicateur, ". " Correspond à n'importe quel caractère sauf la nouvelle ligne.

X
VERBOSE

Ce drapeau facilite la compréhension de l'écriture d'expressions régulières en vous offrant un format plus flexible. Lorsque cet indicateur est spécifié, les espaces dans la chaîne RE sont ignorés, sauf s'ils se trouvent dans une classe de caractères ou après une barre oblique inverse, ce qui vous permet d'organiser et d'indenter les RE plus clairement. Il permet également d'écrire des commentaires dans le RE, qui seront ignorés par le moteur ; les commentaires sont marqués d'un symbole "#", mais ce symbole ne peut pas venir après une chaîne ou une barre oblique inverse.

Enfin : si vous pouvez utiliser la méthode chaîne, ne choisissez pas les expressions régulières, car la méthode chaîne est plus simple et plus rapide.

Pour plus d'articles liés aux opérations d'expression régulière du module re de Python, veuillez faire attention au site Web PHP chinois !