exemples re

ation » Le standard de Python Library » 7. Chaîne services »
. 7.2 re - opérations d'expression régulières
Ce module fournit expression régulière des opérations similaires à ceux trouvés dans Perl correspondant. Les deux modèles et les chaînes à rechercher peuvent être des chaînes Unicode ainsi que des chaînes de 8 bits.

Les expressions régulières utilisent la barre oblique inverse '\' pour indiquer les formes spéciales ou pour permettre à des caractères spéciaux pour être utilisés sans invoquer leur signification spéciale. Cette collision avec l'utilisation de Python de même nature dans le même but dans les littéraux de chaîne; par exemple, pour correspondre à une barre oblique inverse littérale, on peut avoir à écrire '\\\\' que la chaîne de modèle, parce que l'expression régulière doit être \\ et chaque barre oblique inverse doit être exprimé en \\ l'intérieur d'une chaîne de Python régulière littérale.

La solution est d'utiliser la notation chaîne brute de Python pour modèles d'expressions régulières; obliques sont pas traitées d'une manière particulière dans une chaîne littérale avec le préfixe 'r' Donc r"\n" est une chaîne de deux caractères contenant '\' et 'n' tandis que "\n" est une chaîne à un caractère contenant un saut de ligne. Habituellement, les modèles seront exprimés en code Python en utilisant cette notation de chaîne brute.

Il est important de noter que la plupart des opérations régulières d'expression sont disponibles que des fonctions de niveau module et RegexObject méthodes. Les fonctions sont des raccourcis qui ne vous obligent pas à compiler un objet regex premier, mais manquent certains paramètres de réglage fin.

7.2.1. Regular Expression Syntaxe
Une expression régulière (ou RE) spécifie un ensemble de chaînes qui lui correspond; les fonctions de ce module vous permettent de vérifier si une chaîne particulière correspond à une expression régulière donnée (ou si une expression régulière donnée correspond à une chaîne particulière, ce qui revient à la même chose).

Les expressions régulières peuvent être enchaînés pour former de nouvelles expressions régulières; si A et B sont les deux expressions régulières, alors AB est également une expression régulière. En général, si une chaîne p correspond à A et une autre chaîne q correspond B, le PQ de chaîne correspondra AB. Cela vaut moins que A ou B contiennent des opérations de faible priorité; conditions aux limites entre A et B; ou ont numérotée références du groupe. Ainsi, les expressions complexes peuvent être facilement construits à partir d'expressions primitives simples comme celles décrites ici. Pour plus de détails de la théorie et la mise en oeuvre des expressions régulières, consultez le livre Friedl référencé ci-dessus, ou presque tout manuel sur la construction de compilateur.

Une brève explication du format des expressions régulières suit. Pour de plus amples informations et une présentation plus douce, consulter le Expression HOWTO régulier.

Les expressions régulières peuvent contenir des caractères à la fois spéciales et ordinaires. La plupart des caractères ordinaires, comme 'A' 'a' ou '0' sont les plus simples expressions régulières; ils correspondent tout simplement eux-mêmes. Vous pouvez concaténer des caractères ordinaires, de sorte que last correspond à la chaîne 'last' (Dans le reste de cette section, nous écrirons de RE dans this special style généralement sans les guillemets, et les chaînes à être appariés 'in single quotes'

Certains personnages, comme '|' ou '(' sont spéciaux Les caractères spéciaux soit debout pour les classes de personnages ordinaires, ou affectent la façon dont les expressions régulières autour d'eux sont interprétés régulières chaînes de modèle d'expression ne peuvent pas contenir des octets nuls, mais peuvent spécifier le.. octet nul en utilisant le \number notation, par exemple, '\x00'

Les caractères spéciaux sont:

'.'
(Dot). Dans le mode par défaut, cela correspond à tout caractère sauf un saut de ligne. Si le DOTALL drapeau a été spécifié, cela correspond à tout caractère compris un saut de ligne.
'^'
(Caret.) Correspond au début de la chaîne, et MULTILINE le mode correspond également immédiatement après chaque saut de ligne.
'$'
Correspond à la fin de la chaîne ou juste avant le saut de ligne à la fin de la chaîne, et MULTILINE le mode correspond également à un saut de ligne. foo correspond à la fois «foo» et «machin», tandis que l'expression régulière foo$ correspond seulement 'foo' . Plus intéressant, la recherche de foo.$ Dans 'foo1\nfoo2\n' matchs de la foo2 «normalement, mais 'foo1' dans MULTILINE le mode; la recherche d'un simple $ en 'foo\n' va trouver deux matchs (vide): l'un juste avant le saut de ligne, et un à la fin de la chaîne.
'*'
Fait correspondre la RE résultante à 0 ou plusieurs répétitions de la RE précédente, autant de répétitions que sont possibles. ab* correspondra à 'a', 'ab', ou 'a' suivi par un certain nombre de 'B.
'+'
Causes de la RE résultante à 1 ou plusieurs répétitions de la RE précédente. ab+ correspondra à 'a' suivi par un non-zéro nombre de 'B; il ne correspondra pas simplement 'a'.
'?'
Causes de la RE résultante à 0 ou 1 répétitions de la RE précédente. ab? Correspondra soit 'A' ou 'ab'.
*? +? ??
Les '*' '+' et '?' Qualificatifs sont tous avides; ils correspondent à autant de texte que possible. Parfois, ce comportement est indésirable; si le RE <.*> est comparée à '

title

' il correspondra à la chaîne entière, et pas '

' Ajout de '?' Après la qualification rend effectuer le match de façon non-gourmand ou minime; que quelques caractères que possible seront jumelés. .*? Dans l'expression précédente correspondra seulement '

'
{m}
Indique que exactement m copies de la RE précédente doivent être adaptées; moins de matches provoquent l'ensemble RE pas correspondre. Par exemple, a{6} correspondra exactement à six 'a' caractères, mais pas cinq.
{m, n}
Fait correspondre la RE résultante à de m à n répétitions de la RE précédente, en essayant de faire correspondre autant de répétitions que possible. Par exemple, a{3,5} correspondra 3-5 'a' caractères. Omettre m spécifie une limite inférieure de zéro, et en omettant n spécifie une limite supérieure infinie. A titre d'exemple, a{4,}b correspondra aaaab ou mille 'a' caractères suivis par un b mais pas aaab La virgule ne peut être omise ou le modificateur serait confondu avec la forme décrite précédemment.
{m, n}?
Fait correspondre la RE résultante à de m à n répétitions de la RE précédente, en essayant de faire correspondre autant que possible quelques répétitions. Ceci est la version non gourmande de la qualification précédente. Par exemple, sur la 6-chaîne de caractères 'aaaaaa' a{3,5} correspondra 5 'a' caractères, tandis que a{3,5}? Ne correspondra 3 caractères.
'\'
Soit Protège les caractères spéciaux (permettant de faire correspondre des personnages comme '*' '?' Etc.), ou des signaux d'une séquence spéciale; séquences spécifiques sont discutés ci-dessous.

Si vous n'êtes pas en utilisant une chaîne brute d'exprimer le motif, rappelez-vous que Python utilise également la barre oblique inverse comme une séquence d'échappement dans des chaînes; si la séquence d'échappement est pas reconnu par l'analyseur de Python, la barre oblique inverse et le caractère ultérieurs sont inclus dans la chaîne résultante. Toutefois, si Python serait reconnaître la séquence résultante, la barre oblique inverse doit être répété deux fois. Ceci est compliqué et difficile à comprendre, il est fortement recommandé que vous utilisez des chaînes brutes pour tous, mais les expressions les plus simples.

[]
Utilisé pour indiquer un ensemble de caractères. Dans un ensemble:

Les caractères peuvent être répertoriés individuellement, par exemple [amk] correspondra à 'a' 'm' ou 'k'
Plages de caractères peuvent être indiquées en donnant deux personnages et en les séparant par un '-' par exemple [az] correspondra toute lettre ASCII minuscule, [0-5][0-9] correspond à tous les nombres à deux chiffres à partir de 00 à 59 et [0-9A-Fa-f] correspond à tout chiffre hexadécimal. Si - est échappé (par exemple [a\-z] ou si il est placé comme le premier ou le dernier caractère (par exemple [a-] il correspondra à un littéral '-'
Les caractères spéciaux perdent leur signification spéciale à l'intérieur des ensembles. Par exemple, [(+*)] va correspondre à l'un des caractères littérales '(' '+' '*' ou ')'
Les classes de caractères tels que \w ou \S (défini ci-dessous) sont également acceptés à l'intérieur d'un ensemble, bien que les personnages qu'ils correspondent dépend de si LOCALE ou UNICODE mode est en vigueur.
Caractères qui ne sont pas dans une plage peuvent être jumelés en complétant l'ensemble. Si le premier caractère de l'ensemble est '^' tous les caractères qui ne sont pas dans le jeu seront jumelés. Par exemple, [^5] correspond à tout caractère sauf '5' et [^^] correspond à tout caractère sauf '^' ^ N'a pas de signification particulière si elle est pas le premier caractère de l'ensemble.
Pour correspondre à un littéral ']' l'intérieur d'un ensemble, précéder d'une barre oblique inverse, ou le placer au début du jeu. Par exemple, à la fois [()[\]{}] et []()[{}] permettra à la fois correspondre à une parenthèse.
'|'
A|B où A et B peut être ER arbitraires, crée une expression régulière qui correspondent à A ou B. Un nombre arbitraire de RE peuvent être séparés par le '|' de cette façon. Ceci peut être utilisé à l'intérieur des groupes (voir ci-dessous) ainsi. Comme la chaîne cible est balayée, ER séparées par '|' sont jugés de gauche à droite. Quand un motif correspond complètement, cette branche est acceptée. Cela signifie qu'une fois A correspond, B ne sera pas testé plus loin, même si elle produirait un match plus globale. En d'autres termes, le '|' opérateur est jamais avide. Pour correspondre à un littéral '|' utilisez \| ou de l'enfermer dans une classe de caractère, comme dans [|]
(...)
Correspond à toute expression régulière est à l'intérieur des parenthèses, et indique le début et la fin d'un groupe; le contenu d'un groupe peuvent être récupérés après un match a été effectuée, et peuvent être adaptés plus tard dans la chaîne avec le \number séquence spéciale, décrit ci-dessous. Pour faire correspondre les littéraux '(' ou ')' l'utilisation \( \) ou mettez-les dans une classe de caractères: [(] [)]
(? ...)
Ceci est une notation d'extension (un '?' Après un '(' est non significatif autrement) Le premier caractère après le. '?' Détermine quelle est la signification et à la suite syntaxe de la construction est Extensions général ne créent pas un nouveau groupe. (?P...) est la seule exception à cette règle. Après les extensions sont actuellement pris en charge.
(? iLmsux)
(Une ou plusieurs lettres de l'ensemble 'i' 'L' 'm' 's' 'u' 'x' Le groupe correspond à la chaîne vide; les lettres fixent les drapeaux correspondants: re.I (ignorer la casse), re.L (selon les locales), re.M (multi-ligne), re.S (point correspond à tous), re.U (dépendante Unicode), et re.X (verbeux), pour la totalité de l'expression régulière. (Les drapeaux sont décrits dans matières Module.) Ceci est utile si vous souhaitez inclure les drapeaux dans le cadre de l'expression régulière, au lieu de passer un argument de drapeau pour la re.compile() de fonction.

Notez que les (?x) des changements de pavillon comment l'expression est analysée. Il devrait être utilisé en premier dans la chaîne d'expression, ou après un ou plusieurs caractères d'espacement. Si il ya des caractères non-espace avant le drapeau, les résultats sont indéfinis.

(?: ...)
Version de parenthèses réguliers Un non-capture. Correspond à toute expression régulière est à l'intérieur des parenthèses, mais la chaîne correspondante par le groupe ne peuvent pas être récupérés après l'exécution d'un match ou référencés plus tard dans le modèle.
(? P ...)
Similaire à parenthèses réguliers, mais la chaîne correspondante par le groupe est accessible via le nom symbolique de nom de groupe. Les noms de groupe doivent être des identifiants Python valides, et chaque nom de groupe doit être défini qu'une seule fois dans une expression régulière. Un groupe symbolique est aussi un groupe numéroté, comme si le groupe n'a pas été nommé.

Les groupes nommés peuvent être référencées dans trois contextes. Si le motif est (?P['"]).*?(?P=quote) (C.-à-correspondant d'une chaîne entourée de guillemets simples ou doubles):

Contexte de référence au groupe "citation" Façons de référencer
dans le même motif lui-même
(?P=quote) (comme indiqué)
\1
lors du traitement de correspondance objet m
m.group ('quote')
m.end('quote') (etc.)
dans une chaîne passée à la repl argument re.sub()
\ g
\ g <1>
\1
(? P = name)
Une référence arrière à un groupe nommé; elle correspond à ce que le texte a été adapté par le groupe nommé nom plus tôt.
(? # ...)
Un commentaire; le contenu des parenthèses sont tout simplement ignorés.
(? = ...)
Matches si ... Matches à venir, mais ne consomme pas de la chaîne. Ceci est appelé une assertion avant. Par exemple, Isaac (?=Asimov) correspondra 'Isaac ' que si elle est suivie par 'Asimov'
(?! ...)
Correspond si ... ne correspond pas à côté. Cette anticipation est une assertion négative. Par exemple, Isaac (?!Asimov) correspondra 'Isaac ' que si elle est pas suivie par 'Asimov'
(? <= ...) Matches si la position actuelle dans la chaîne est précédée d'un match pour ... qui se termine à la position actuelle. Ceci est appelé assertions arrières positive. (?<=abc)def trouveront une correspondance dans abcdef depuis le lookbehind va sauvegarder 3 caractères et de vérifier si le motif contenu correspond. Le motif contenu doit seul match cordes d'une certaine longueur fixe, ce qui signifie que abc ou a|b sont autorisés, mais a* et a{3,4} ne sont pas. Références de groupe ne sont pas pris en charge, même si elles correspondent à cordes d'une certaine longueur fixe. Notez que les modèles qui commencent par les assertions de lookbehind positifs ne correspondent pas au début de la chaîne recherchée; vous voudrez plus susceptibles d'utiliser la search() la fonction plutôt que le match() fonction: >>> Import re
>>> M = re. Recherche ('(? <= Abc) def', 'abcdef') >>> Groupe m. (0)
'def'
Cet exemple cherche un mot suivant un trait d'union:

>>> M = re recherche ('(<= -?) \ W +', 'spam œuf »). >>> Groupe m. (0)
'œuf'
(? ) Est un motif email correspondant pauvres, qui va correspondre avec '' ainsi que 'user@host.com' mais pas avec '>> Re. Split ('\ W + »,« Des mots, des mots, des mots.')
[«Mots», «mots», «Les mots ',' ']
>>> Re. Split ('(\ W +) »,« Des mots, des mots, des mots.')
['Words', ',', 'mots', ',', 'mots', '.', '']
>>> Re. Split ('\ W + »,« mots, des mots, des mots.', 1)
[«Mots», «des mots, des paroles.]
>>> Re. Split ('[af] +', '0a3B9', drapeaux = re. IGNORECASE)
[«0», «3», «9»]
Si il ya des groupes de capture dans le séparateur et il correspond au début de la chaîne, le résultat va commencer avec une chaîne vide. La même chose vaut pour la fin de la chaîne:

>>> Re. Split ('(\ W +) »,« ... des mots, des mots ... »)
['', '...', 'Mots', ',', 'mots', '...', '']
De cette façon, les composants de séparation se trouvent toujours dans les mêmes indices relatifs au sein de la liste des résultats (par exemple, si il ya un groupe de capture dans le séparateur, l'0th, le 2ème et ainsi de suite).

Notez que scission ne sera jamais découper une chaîne sur un schéma allumettes vide. Par exemple:

>>> Re. Split ('x *', 'foo')
['foo']
>>> Re. Split ("(? M) ^ $", "foo \ n \ n bar \ n")
['foo \ n \ nbar \ n']
Changé dans la version 2.7: Ajout de la optionnelle argument flags.

re. findall (motif, chaîne, drapeaux = 0)
Retour tous les matchs non-chevauchement de modèle dans la chaîne, comme une liste de chaînes. La chaîne est lue de gauche à droite, et les matchs sont retournés dans l'ordre trouvé. Si un ou plusieurs groupes sont présents dans le modèle, retourner une liste de groupes; ce sera une liste de tuples si le modèle a plus d'un groupe. Matchs vides sont inclus dans le résultat à moins qu'ils ne touchent le début de un autre match.

Nouveau dans la version 1.5.2.

Changé dans la version 2.4: Ajout de la optionnelle argument flags.

re. finditer (motif, chaîne, drapeaux = 0)
Retourne un itérateur cédant MatchObject cas sur toutes les correspondances qui ne se chevauchent pour le modèle de RE dans la chaîne. La chaîne est lue de gauche à droite, et les matchs sont retournés dans l'ordre trouvé. Matchs vides sont inclus dans le résultat à moins qu'ils ne touchent le début de un autre match.

Nouveau dans la version 2.2.

Changé dans la version 2.4: Ajout de la optionnelle argument flags.

re. sub (motif, repl, string, count = 0, drapeaux = 0)
Retourner la chaîne obtenue en remplaçant les plus à gauche occurrences non-chevauchement de modèle dans la chaîne par le rempl de remplacement. Si le modèle est introuvable, chaîne est retournée inchangée repl peut être une chaîne ou une fonction. si elle est une chaîne, toute barre oblique inverse échappe en elle sont traitées. Autrement dit, \n est converti en un caractère de nouvelle ligne unique, \r est converti en un retour chariot, et ainsi de suite. Évasions inconnus tels que \j sont laissés seuls. Les références arrières, comme \6 sont remplacées par la chaîne correspondante par le groupe 6 dans le motif. Par exemple:

. >>> Re sous (r'def \ s + ([a-zA-Z _] [a-zA-Z_0-9] *) \ S * \ (\ s * \): ',
... R'static PyObject * \ npy_ \ 1 (void) \ n {',
... 'Def myfunc ():')
'PyObject statique * \ npy_myfunc (void) \ n {'
Si rempl est une fonction, il est appelé pour chaque événement non-chevauchement de motif. La fonction prend un seul argument de match objet et renvoie la chaîne de remplacement. Par exemple:

>>> Def dashrepl (matchobj):
. ... Si matchobj groupe (0) == '-': retour ''
... Else: return '-'
. >>> Re sous ('- {1,2} ", dashrepl,' pro-gramme ---- fichiers ')
'fichiers de programme'
>>> Re. Sous (r '\ sable \' s, '&', 'fèves au lard et Spam ", drapeaux = re. IGNORECASE)
«Fèves au lard et Spam"
Le motif peut être une chaîne ou un objet de RE.

Le nombre de argument optionnel est le nombre maximum d'occurrences de modèle pour être remplacés; nombre doit être un entier non négatif. Si elle est omise ou zéro, toutes les occurrences seront remplacés. Matchs vides pour le motif sont remplacées que lorsqu'elles ne sont pas à côté d'un match précédent, donc sub('x*', '-', 'abc') retourne '-abc-'

Dans arguments de REPL-type de chaîne, en plus des évasions de caractères et des références arrières décrites ci-dessus, \g va utiliser la chaîne correspondante par le groupe nommé name tel que défini par le (?P...) syntaxe. \g utilise le numéro de groupe correspondant; \g<2> est donc équivalent à \2 mais est pas ambigu dans un remplacement tels que \g<2>0 \20 serait interprété comme un renvoi au groupe 20, pas un renvoi au groupe 2, suivi par le caractère littéral '0' La référence arrière \g<0> substituts dans l'ensemble du sous-chaîne correspondante par le RE.

Changé dans la version 2.7: Ajout de la optionnelle argument flags.

re. subn (modèle, repl, string, count = 0, drapeaux = 0)
Effectuez la même opération que sub() mais renvoie un tuple (new_string, number_of_subs_made)

Changé dans la version 2.7: Ajout de la optionnelle argument flags.

re. escape (string)
Chaîne de retour avec tous les non-alphanumériques backslashées; ce qui est utile si vous voulez faire correspondre une chaîne littérale arbitraire qui peut avoir métacaractères d'expressions régulières en elle.

re. purge ()
Vider le cache d'expression régulière.

exception re. error
Exception déclenchée quand une chaîne passée à l'une des fonctions est pas ici une expression régulière valide (par exemple, il peut contenir des parenthèses inégalées) ou quand une autre erreur se produit lors de la compilation ou de correspondance. Il est jamais une erreur si une chaîne contient pas de match pour un motif.

7.2.3. Expression régulière Objets
classe re. RegexObject
Le RegexObject classe prend en charge les méthodes et les attributs suivants:

search (string [, pos [, endpos]])
Parcourez chaîne à la recherche d'un endroit où cette expression régulière produit un match, et ​​retourner un correspondant MatchObject exemple. Retour None si aucune position dans la chaîne correspond au motif; Notez que ceci est différent de trouver un match de longueur nulle à un certain point dans la chaîne.

Le second paramètre optionnel pos donne un index dans la chaîne où la recherche est de commencer; il est par défaut à 0 Cela ne veut pas complètement équivalent à trancher la chaîne; le '^' caractère de modèle correspond à la véritable début de la chaîne et à des positions juste après un saut de ligne, mais pas nécessairement à l'index où la recherche est de commencer.

Les endpos paramètre optionnel limites jusqu'où la chaîne sera recherché; ce sera comme si la chaîne est endpos caractères, de sorte que seuls les personnages de pos à endpos - 1 seront recherchés pour un match. Si endpos est inférieure à pos, aucun match sera trouvée, sinon, si rx est un objet d'expression régulière compilée, rx.search(string, 0, 50) est équivalent à rx.search(string[:50], 0)

>>> Pattern = re. Compiler («D»)
>>> Motif. Recherche ("chien") # match à l'index 0
<_sre.SRE_Match objet à ...>
. >>> Motif de recherche ("chien", 1) # Pas de correspondance; la recherche ne comprend pas le "d"
match (string [, pos [, endpos]])
Si zéro ou plusieurs caractères au début de la chaîne correspondent à cette expression régulière, renvoyer un correspondant MatchObject exemple. Retour None si la chaîne ne correspond pas au modèle; Notez que ceci est différent d'un match de longueur nulle.

Les paramètres de POS et endpos optionnels ont la même signification que pour la search() méthode.

>>> Pattern = re. Compiler ("o")
>>> Motif. Correspondance ("chien") # Pas de correspondance comme "o" est pas au début de "chien".
>>> Motif. Correspondance ("chien", 1) # match "o" est le 2ème caractère de "chien".
<_sre.SRE_Match objet à ...>
Si vous souhaitez localiser un match n'importe où dans la chaîne, utilisez search() à la place (voir aussi la recherche () vs match ()).

split (string, maxsplit = 0)
Identique à la split() la fonction, en utilisant la forme compilée.

findall (string [, pos [, endpos]])
Similaires à findall() la fonction, en utilisant le motif compilé, mais accepte également pos et endpos option des paramètres qui limitent la région de recherche comme pour match()

finditer (string [, pos [, endpos]])
Similaires à finditer() la fonction, en utilisant le motif compilé, mais accepte également pos et endpos option des paramètres qui limitent la région de recherche comme pour match()

sub (repl, string, count = 0)
Identique à la sub() la fonction, en utilisant la forme compilée.

subn (repl, string, count = 0)
Identique à la subn() la fonction, en utilisant la forme compilée.

flags
Les drapeaux regex correspondants. Ceci est une combinaison des drapeaux donnés à compile() et toute (?...) Drapeaux de ligne dans le motif.

groups
Le nombre de groupes de capture dans le motif.

groupindex
Une cartographie dictionnaire des noms de groupe symboliques définies par (?P) pour les numéros de groupe. Le dictionnaire est vide si aucun des groupes symboliques ont été utilisés dans le modèle.

pattern
La chaîne de modèle à partir de laquelle l'objet de RE a été compilé.

7.2.4. Correspondre objets
classe re. MatchObject
Objets de match ont toujours une valeur booléenne True Depuis match() et search() retourner None quand il n'y a pas de match, vous pouvez tester si il y avait un match avec un if la déclaration:

match = re. search (pattern, string)
si MATCH:
processus (jeu)
Objets Match soutiennent les méthodes et les attributs suivants:

expand (modèle)
Retourner la chaîne obtenue en faisant la substitution barre oblique inverse sur le modèle de chaîne de modèle, comme cela se fait par le sub() méthode.Escapes tels que \ n sont convertis aux caractères appropriés, et des références arrières numériques (\ 1, \ 2) et des références arrières nommées (\ g <1>, \ g ) sont remplacés par le contenu du groupe correspondant.

groupe ([groupe1, ...])
Retourne un ou plusieurs sous-groupes du match. Si il ya un seul argument, le résultat est une chaîne unique; si il ya plusieurs arguments, le résultat est un tuple avec un élément par argument. Sans arguments, group1 zéro par défaut (l'ensemble du match est retournée). Si un groupeN argument est nul, la valeur de retour correspondante est la chaîne entière de correspondance; si elle est dans la gamme inclusive [1..99], il est la chaîne correspondant le groupe entre parenthèses correspondant. Si un numéro de groupe est négatif ou plus grand que le nombre de groupes définis dans le modèle, un IndexError exception est levée. Si un groupe est contenue dans une partie du motif qui ne correspond pas, le résultat correspondant est Aucun. Si un groupe est contenue dans une partie du motif qui correspondent à plusieurs reprises, le dernier match est retourné.

>>> M = re. Correspondance (r "(\ w +) (\ w +)", "Isaac Newton, physicien")
>>> m. Groupe (0) # tout le match
"Isaac Newton"
>>> m. groupe (1) # Le premier sous-groupe entre parenthèses.
"Isaac"
>>> m. groupe (2) # Le deuxième sous-groupe entre parenthèses.
"Newton"
>>> m. groupe (1, 2) # Plusieurs arguments nous donner un tuple.
('Isaac Newton')
Si l'expression régulière utilise le (? P ...) syntaxe, les GROUPEN arguments peuvent également être des chaînes d'identification des groupes par leur nom de groupe. Si un argument de chaîne ne soit pas utilisé comme un nom de groupe dans le modèle, un IndexError exception est levée.

Un exemple modérément compliquée:

>>> M = re. Correspondance (r "(? P \ w +) (? P \ w +)", "Malcolm Reynolds")
>>> m. Groupe ('prenom')
'Malcolm'
>>> m. groupe ('nom')
'Reynolds'
Les groupes nommés peuvent également être désignés par leur index:

>>> M. Groupe (1)
'Malcolm'
>>> m. Groupe (2)
«Reynolds»
Si un groupe correspond à plusieurs fois, seul le dernier match est accessible:

>>> M = re. Correspondance (r "(..) +", "a1b2c3") # Matchs 3 fois.
>>> M. Groupe (1) # Renvoie uniquement le dernier match.
'C3'
groupes ([défaut])
Retourne un tuple contenant tous les sous-groupes du match, à partir de 1 jusqu'à cependant de nombreux groupes sont dans le motif. Le défaut argument est utilisé pour les groupes qui ne participent pas dans le match; il est par défaut Aucun. (Incompatibilité Note:. Dans le Python 1.5 version d'origine, si le tuple était un élément de long, une chaîne serait renvoyé à la place Dans les versions ultérieures (de 1.5.1 sur), un tuple singleton est retourné dans de tels cas.)

Par exemple:

>>> M = re. Correspondance (r "(\ d +) \. (\ D +)", "24,1632")
>>> m. Groupes ()
('24', '1632')
Si nous faisons la décimale et tout ce qui suit option, tous les groupes ne pourrait participer au match. Ces groupes seront par défaut Aucun, sauf si le défaut argument est donné:

>>> M = re. Correspondance (r "(\ d +) \.? (\ D +)?", "24")
>>> m. Groupes () # Deuxième défaut de groupe à aucun.
('24', None )
>>> m. groupes ('0') # Maintenant, les deuxièmes de groupe par défaut à '0'.
('24', '0')
groupdict ([défaut])
Retourner un dictionnaire contenant tous les nommés sous-groupes du match, indexés par le nom du sous-groupe. Le défaut argument est utilisé pour les groupes qui ne participent pas dans le match; il est par défaut Aucun. Par exemple:

>>> M = re. Correspondance (r "(P \ w +) (P \ w +)?", "Malcolm Reynolds")
>>> m. Groupdict ()
{'prenom': ' Malcolm ',' nom ':' Reynolds '}
commencer ([groupe])
fin ([groupe])
Retourner les indices de début et de fin de la chaîne correspondante par groupe; groupe par défaut à zéro (ce ​​qui signifie toute chaîne correspondante). Retour -1 si le groupe existe, mais ne contribue pas à la rencontre. Pour un objet de correspondance m, et un groupe g qui ne contribuent à la correspondance, la chaîne correspondante par le groupe g (équivalent à m.group (g)) est

m. chaîne [m. démarrer (g): m. fin (g)]
Notez que m.start (groupe) sera égal m.end (groupe) si le groupe correspond une chaîne nulle. Par exemple, après m = re.search ('b (c?)', 'ABC'), m.start (0) est 1, m.end (0) est 2, m.start (1) et m. fin (1) sont à la fois 2 et m.start (2) soulève une IndexError exception.

Un exemple qui va enlever remove_this d'adresses e-mail:

>>> email = "tony@tiremove_thisger.net"
>>> m = re . search ( "remove_this" , email )
>>> email [: m . start ()] + email [ m . end ():]
'tony@tiger.net'
durée ([groupe])
Pour MatchObject m, retourner le 2-tuple (m.start (groupe), m.end (groupe)). Notez que si le groupe n'a pas contribué à le match, cela est (-1, -1). Groupes par défaut à zéro, tout le match.

pos
La valeur de pos qui a été transmis à la recherche () ou match () méthode de la RegexObject. Ceci est l'index dans la chaîne à laquelle le moteur de RE a commencé à chercher un match.

endpos
La valeur de endpos qui a été transmis à la recherche () ou match () méthode de la RegexObject. Ceci est l'indice dans la chaîne au-delà duquel le moteur de RE ne va pas.

lastIndex
L'indice entier de capturer le dernier groupe apparié, ou None si aucun groupe a été apparié à tous. Par exemple, les expressions (a) b, ((a) (b)) et ((ab)) aura == lastIndex 1 si elle est appliquée à la chaîne 'ab', tandis que l'expression (a) (b) sera avoir == lastIndex 2, si elle est appliquée à la même chaîne.

lastgroup
Le nom du dernier groupe capture adapté, ou None si le groupe ne disposent pas d'un nom, ou si aucun groupe a été appariés à tous.

re
L'objet expression régulière dont le match () ou la recherche () méthode a produit ce MatchObject exemple.

chaîne
La chaîne passée à match () ou la recherche ().

7.2.5. Exemples
7.2.5.1. Vérification pour une paire
Dans cet exemple, nous allons utiliser la fonction d'aide suivante pour afficher correspondance des objets un peu plus de grâce:

def displaymatch (correspondance):
si correspondance est Aucun:
retour Aucun
retour ''% (correspondance. groupe (), correspondance. groupes ())
Supposons que vous écrivez un programme de poker où la main d'un joueur est représenté comme une chaîne de 5 caractères avec chaque personnage représentant une carte, "a" pour ACE, "k" pour le roi, "q" pour la reine, "j" pour Jack, "t" de 10, et "2" à "neuf" représentant la carte de cette valeur.

Pour voir si une chaîne donnée est une main valide, on peut faire ce qui suit:

>>> Valide = re. Compiler (r "^ [a2-9tjqk] {5} $")
>>> displaymatch (valide. Correspondance ("akt5q")) # valide.
"
">>> displaymatch (valide. correspondance (" akt5e ")) # valide.
>>> displaymatch (valide. correspondance (" Akt ")) # valide.
>>> displaymatch (valide. correspondance (" 727ak " )) # valide.
""
Ce dernier part, "727ak", contenait une paire ou deux cartes de la même valeur. Pour correspondre avec une expression régulière, on pourrait utiliser des références arrières en tant que tels:

>>> Paire = re. Compiler ("... * () * \ 1" r)
>>> displaymatch (paire. Correspondance ("717ak")) # Paire de 7s.
"
">>> displaymatch (paire. correspondance (" "718ak)) # Pas de paires.
>>> displaymatch (paire. correspondance (354aa" ")) # Paire
d'as." "
Pour savoir ce que la carte se compose de la paire, on pourrait utiliser le groupe () méthode de MatchObject de la manière suivante:

>>> Paire. Correspondance ("717ak"). Groupe (1)
'7'

# Erreur parce re.match () retourne None, qui ne possède pas de méthode group ():
>>> paire. Correspondance ("718ak"). Groupe (1)
Retraçage (appel plus récente en dernier):
Fichier "", ligne 1, dans
re. Correspondance ("... * () * \ 1" r, "718ak"). Groupe (1)
AttributeError: objet 'NoneType' n'a pas attribut «groupe»

>>> Paire. Correspondance ("354aa"). Groupe (1)
'a'
7.2.5.2.Simulation de scanf ()
Python n'a pas actuellement l'équivalent de scanf (). Les expressions régulières sont généralement plus puissants, mais aussi plus détaillé, que scanf () chaînes de format. Le tableau ci-dessous offre quelques applications plus ou moins équivalentes entre scanf () jetons de format et des expressions régulières.

scanf () Token Expression régulière
% c .
% 5c . {5}
%ré [- +] \ d +?
% e,% E,% f,% g [- +] (\ d + (\ \ d *) | \ \ d +.?.) ([EE] [- +] \ d +?)?
%je [- +] (0 [xx] [\ dA-Fa-de f] + | 0 [0-7] * | \ d +)?
% o ? [- +] [0-7] +
% s \ S +
% u \ d +
x%,% X ? [- +] (0 [xx]) [\ dA-Fa-f] +
Pour extraire le nom de fichier et des numéros d'une chaîne comme

/ usr / sbin / sendmail - 0 erreurs, 4 avertissements
vous devez utiliser un scanf () format comme

% s -% d erreurs,% d avertissements
L'expression régulière équivalente serait

(\ S +) - (\ d +) erreurs, (\ d +) avertissements
7.2.5.3. search () vs match ()
Python offre deux opérations primitives différentes basées sur des expressions régulières: re.match () des chèques pour un match seulement au début de la chaîne, tandis que re.search () des chèques pour un match n'importe où dans la chaîne (ce que Perl fait par défaut ).

Par exemple:

>>> Re. Correspondance ("c", "abcdef") # Pas de correspondance
>>> re. Recherche ("c", "abcdef") # Correspondance
<_sre.SRE_Match objet à ...>
Les expressions régulières commençant par '^' peuvent être utilisés avec la recherche () pour restreindre le match au début de la chaîne:

>>> Re. Correspondance ("c", "abcdef") # Pas de correspondance
>>> re. Recherche ("^ c", "abcdef") # Pas de correspondance
>>> re. Recherche («un ^", " abcdef ") # Correspondance
<_sre.SRE_Match objet à ...>
Notez cependant que dans MULTILINE mode de match () correspond seulement au début de la chaîne, tandis que l'utilisation search () avec une expression régulière commençant par '^' correspondra au début de chaque ligne.

>>> Re. Correspondance ('X', 'A \ n B \ n X', re. MULTILINE) # Pas de correspondance
>>> re. Recherche ('^ X', 'A \ n B \ n X', re. MULTILINE) # Correspondance
<_sre.SRE_Match objet à ...>
7.2.5.4.Faire un répertoire
split () divise une chaîne en une liste délimitée par le motif passé. La méthode est inestimable pour convertir des données textuelles dans les structures de données qui peuvent être facilement lus et modifiés par Python comme démontré dans l'exemple suivant qui crée un répertoire.

D'abord, voici l'entrée. Normalement, il peut provenir d'un fichier, ici nous utilisons la syntaxe triple chaîne entre guillemets:

>>> Texte = "" "Ross McFluff: 834.345.1254 155, rue Elm
...
... Ronald Heathmore: 892.345.3428 436 Finley Avenue
... Frank Burger: 925.541.7625 662 South Dogwood Way
...
...
... Heather Albrecht: 548.326.4584 919 Park Place "" "
Les entrées sont séparées par un ou plusieurs sauts de ligne. Maintenant, nous convertissons la chaîne dans une liste avec chaque ligne non vide ayant sa propre entrée:

>>> Entrées = re. Partagé ("\ n +", texte)
>>> entrées
['Ross McFluff: 834.345.1254 155, rue Elm',
'Ronald Heathmore: 892.345.3428 436 Finley Avenue',
'Frank Burger: 925.541.7625 662 South Dogwood Way
',' Heather Albrecht: 548.326.4584 919 Park Place ']
Enfin, diviser chaque entrée dans une liste avec prénom, nom, numéro de téléphone et adresse. Nous utilisons le maxsplit paramètre de split () parce que l'adresse a des espaces, notre modèle de fractionnement, en elle:

>>> [Re. Partagé (":?", Entrée, 3) pour l'entrée dans les entrées]
[['Ross', 'McFluff', '834.345.1254 »,« 155, rue Elm'],
[«Ronald», 'Heathmore', '892.345.3428 »,« 436 Finley Avenue'],
[Frank »,« Burger »,« 925.541.7625 »,« 662 South Dogwood Way '],
[' Heather ',' Albrecht ',' 548.326.4584 »,« 919 Park Place ']]
L':? Motif correspond le côlon après le dernier nom, de sorte qu'il ne se produit pas dans la liste de résultats. Avec un maxsplit de 4, nous pourrions séparer le numéro de la maison du nom de la rue:

>>> [Re. Partagé (":?", Entrée, 4) pour l'entrée dans les entrées]
[['Ross', 'McFluff', '834.345.1254 »,« 155 »,« Elm Street'],
[' Ronald ',' Heathmore ',' 892.345.3428 »,« 436 »,« Finley Avenue '],
[Frank »,« Burger »,« 925.541.7625', '662', 'South Dogwood Way'],
[ «Heather», «Albrecht», «548.326.4584 ',' 919 ',' Park Place ']]
7.2.5.5. Texte munging
sub () remplace toutes les occurrences d'un motif avec une ficelle ou le résultat d'une fonction. Cet exemple illustre l'utilisation de sub () avec une fonction de texte "munge", ou aléatoire l'ordre de tous les caractères de chaque mot d'une phrase à l'exception des premier et dernier caractères:

>>> def repl ( m ):
... inner_word = list ( m . group ( 2 ))
... random . shuffle ( inner_word )
... return m . group ( 1 ) + "" . join ( inner_word ) + m . group ( 3 )
>>> text = "Professor Abdolmalek, s'il vous plaît signaler vos absences rapidement.
">>> Re. Sous (r" (\ w) (\ w +) (\ w) ", repl, texte)
'Poefsrosr Aealmlobdk, pslaee reorpt vos abnseces plmrptoy.
>>> re. sous (r "(\ w) (\ w +) (\ w)", repl, texte)
'Pofsroser Aodlambelk, plasee reoprt yuor asnebces potlmrpy.
7.2.5.6. Trouver tous les adverbes
findall () correspond à toutes les occurrences d'un motif, et pas seulement le premier comme search () le fait. Par exemple, si l'on était un écrivain et je voulais trouver tous les adverbes dans un texte, il ou elle pourrait utiliser findall () de la manière suivante:

>>> Texte = "Il a été soigneusement déguisé mais rapidement capturé par la police."
>>> Re. Findall (r "\ w + Ly», texte)
[«attentivement», «rapidement»]
7.2.5.7. Trouver tous les adverbes et leurs positions
Si l'on veut plus d'informations sur tous les matches d'un motif que le texte correspondant, finditer () est utile car elle fournit des instances de MatchObject au lieu de chaînes. En continuant avec l'exemple précédent, si l'on était un écrivain qui voulait trouver tous les adverbes et leurs positions dans un texte, il ou elle serait utiliser finditer () de la manière suivante:

>>> Texte = "Il a été soigneusement déguisé mais rapidement capturées par


soigneusement
40-47: rapidement
7.2.5.8. Raw cordes Notation
Notation chaîne brute (r "texte") maintient les expressions régulières sain d'esprit. Sans elle, chaque barre oblique inverse ('\') dans une expression régulière devra être précédée d'une autre pour y échapper. Par exemple, les deux lignes de code suivantes sont fonctionnellement identiques:

>>> Re. Correspondance (r "\ W (.) \ 1 \ W", "ff")
<_sre.SRE_Match objet à ...>
>>> re. Correspondance ("\\ W (.) \\ 1 \\ W "," ff ")
<_sre.SRE_Match objet à ...>
Quand on veut faire correspondre une barre oblique inverse littérale, il doit être échappé dans l'expression régulière. Avec la notation de chaîne brute, ce qui signifie r "\\". Sans notation chaîne brute, il faut utiliser "\\\\", rendant les lignes de code fonctionnellement identique suivantes:

>>> Re. Correspondance (r "\\", r "\\")
<_sre.SRE_Match objet à ...>
>>> re. Correspondance ("\\\\", r "\\")
< _sre.SRE_Match objet à ...>