Python pas cher
Comme vous l’avez vu, la plupart des fonctions et méthodes du ré
module retourner un faire correspondre l'objet en cas de match réussi. Parce qu'un objet de correspondance est véridique, vous pouvez l'utiliser dans une condition:
Mais les objets de correspondance contiennent également un certain nombre d'informations utiles sur la correspondance. Vous en avez déjà vu une partie – le span =
et match =
données que l'interpréteur affiche lorsqu'il affiche un objet de correspondance. Vous pouvez obtenir beaucoup plus d'un objet match en utilisant ses méthodes et attributs.
Méthodes d'objet de correspondance
Le tableau ci-dessous résume les méthodes disponibles pour un objet de correspondance rencontre
:
Méthode | Retour |
---|---|
match.group () |
Le ou les groupes capturés spécifiés de rencontre |
match .__ getitem __ () |
Un groupe capturé de rencontre |
match.groups () |
Tous les groupes capturés de rencontre |
match.groupdict () |
Un dictionnaire des groupes capturés nommés de rencontre |
match.expand () |
Le résultat de la substitution de références rencontre |
match.start () |
L'index de départ de rencontre |
match.end () |
L'indice final de rencontre |
match.span () |
Les indices de départ et de fin de rencontre comme un tuple |
Les sections suivantes décrivent ces méthodes plus en détail.
match.group ([[[[
Renvoie le ou les groupes capturés spécifiés à partir d'une correspondance.
Pour les groupes numérotés, match.group (n)
renvoie le n
e
groupe:
>>> m = ré.chercher(r«( w +), ( w +), ( w +)», 'foo, bar, baz')
>>> m.groupe(1)
'foo'
>>> m.groupe(3)
«baz»
Rappelles toi: Les groupes capturés numérotés sont basés sur un, et non sur zéro.
Si vous capturez des groupes à l'aide (? P
, puis match.group (
renvoie le groupe nommé correspondant:
>>> m = ré.rencontre(r«(? P w +), (? P w +), (? P w +) ' , «quux, corge, grault»)
>>> m.groupe(«w1»)
«quux»
>>> m.groupe(«w3»)
«grault»
Avec plus d'un argument, .groupe()
renvoie un tuple de tous les groupes spécifiés. Un groupe donné peut apparaître plusieurs fois et vous pouvez spécifier n'importe quel groupe capturé dans n'importe quel ordre:
>>> m = ré.chercher(r«( w +), ( w +), ( w +)», 'foo, bar, baz')
>>> m.groupe(1, 3)
('foo', 'baz')
>>> m.groupe(3, 3, 1, 1, 2, 2)
('baz', 'baz', 'foo', 'foo', 'bar', 'bar')
>>> m = ré.rencontre(r«(? P w +), (? P w +), (? P w +) ' , «quux, corge, grault»)
>>> m.groupe(«w3», «w1», «w1», «w2»)
('grault', 'quux', 'quux', 'corge')
Si vous spécifiez un groupe hors de portée ou inexistant, .groupe()
soulève un IndexError
exception:
>>> m = ré.chercher(r«( w +), ( w +), ( w +)», 'foo, bar, baz')
>>> m.groupe(4)
Traceback (dernier appel le plus récent):
Fichier "" , ligne 1, dans
IndexError: pas un tel groupe
>>> m = ré.rencontre(r«(? P w +), (? P w +), (? P w +) ' , «quux, corge, grault»)
>>> m.groupe('foo')
Traceback (dernier appel le plus récent):
Fichier "" , ligne 1, dans
IndexError: pas un tel groupe
Il est possible pour une expression régulière en Python de correspondre dans son ensemble mais de contenir un groupe qui ne participe pas au match. Dans ce cas, .groupe()
Retour Aucun
pour le groupe non participant. Considérez cet exemple:
>>> m = ré.chercher(r'( w +), ( w +), ( w +)?', 'foo, bar,')
>>> m
<_sre.SRE_Match object; span=(0, 8), match='foo,bar,'>
>>> m.groupe(1, 2)
('foo', 'bar')
Cette expression régulière correspond, comme vous pouvez le voir sur l'objet de correspondance. Les deux premiers groupes capturés contiennent 'foo'
et 'bar'
, respectivement.
Un point d'interrogation (?
), le métacaractère quantificateur suit le troisième groupe, de sorte que ce groupe est facultatif. Une correspondance se produit s'il existe une troisième séquence de caractères de mot après la deuxième virgule (,
) mais aussi s'il n'y en a pas.
Dans ce cas, il n'y en a pas. Il y a donc match global, mais le troisième groupe n'y participe pas. Par conséquent, m.group (3)
est toujours défini et est une référence valide, mais il renvoie Aucun
:
>>> impression(m.groupe(3))
Aucun
Il peut également arriver qu'un groupe participe plusieurs fois au match global. Si vous appelez .groupe()
pour ce numéro de groupe, il ne renvoie alors que la partie de la chaîne de recherche correspondant à la dernière fois. Les matchs précédents ne sont pas accessibles:
>>> m = ré.rencontre(r'( w3,) + ', «foo, bar, baz, qux»)
>>> m
<_sre.SRE_Match object; span=(0, 12), match='foo,bar,baz,'>
>>> m.groupe(1)
«baz»
Dans cet exemple, la correspondance complète est «foo, bar, baz,»
, comme le montre l'objet de correspondance affiché. Chacun des «foo»
, 'bar,'
, et «baz»
correspond à ce qui est à l'intérieur du groupe, mais m.group (1)
ne renvoie que le dernier match, «baz»
.
Si vous appelez .groupe()
avec un argument de 0
ou aucun argument du tout, il retourne la correspondance entière:
1 >>> m = ré.chercher(r«( w +), ( w +), ( w +)», 'foo, bar, baz')
2 >>> m
3 <_sre.SRE_Match object; span=(0, 11), match='foo,bar,baz'>
4
5 >>> m.groupe(0)
6 'foo, bar, baz'
7 >>> m.groupe()
8 'foo, bar, baz'
Ce sont les mêmes données que l'interprète montre après match =
quand il affiche l'objet de correspondance, comme vous pouvez le voir sur ligne 3 au dessus de.
match .__ getitem __ (
Renvoie un groupe capturé d'une correspondance.
match .__ getitem __ (
est identique à match.group (
et renvoie le seul groupe spécifié par
:
>>> m = ré.chercher(r«( w +), ( w +), ( w +)», 'foo, bar, baz')
>>> m.groupe(2)
'bar'
>>> m.__obtenir l'article__(2)
'bar'
Si .__obtenir l'article__()
reproduit simplement la fonctionnalité de .groupe()
, alors pourquoi l'utiliseriez-vous? Vous ne le feriez probablement pas directement, mais vous pourriez le faire indirectement. Lisez la suite pour voir pourquoi.
Une brève introduction aux méthodes magiques
.__obtenir l'article__()
fait partie d'une collection de méthodes en Python appelée méthodes magiques. Ce sont des méthodes spéciales que l'interpréteur appelle lorsqu'une instruction Python contient des éléments syntaxiques correspondants spécifiques.
Remarque: Les méthodes magiques sont également appelées méthodes de dunder en raison de l réouble en dessous descore au début et à la fin du nom de la méthode.
Plus loin dans cette série, il existe plusieurs didacticiels sur la programmation orientée objet. Vous en apprendrez beaucoup plus sur les méthodes magiques là-bas.
La syntaxe particulière .__obtenir l'article__()
correspond à l'indexation entre crochets. Pour tout objet obj
, chaque fois que vous utilisez l'expression obj[n]
, dans les coulisses Python le traduit tranquillement en un appel à .__obtenir l'article__()
. Les expressions suivantes sont effectivement équivalentes:
obj[[[[n]
obj.__obtenir l'article__(n)
La syntaxe obj[n]
n'a de sens que si un .__obtenir l'article()__
existe pour la classe ou le type auquel obj
fait parti. Exactement comment Python interprète obj[n]
dépendra alors de la mise en œuvre de .__obtenir l'article__()
pour cette classe.
Retour à Match Objects
Depuis Python version 3.6, le ré
le module met en œuvre .__obtenir l'article__()
pour faire correspondre les objets. La mise en œuvre est telle que match .__ getitem __ (n)
est le même que match.group (n)
.
Le résultat de tout cela est qu'au lieu d'appeler .groupe()
directement, vous pouvez accéder aux groupes capturés à partir d'un objet de correspondance à l'aide de la syntaxe d'indexation entre crochets à la place:
>>> m = ré.chercher(r«( w +), ( w +), ( w +)», 'foo, bar, baz')
>>> m.groupe(2)
'bar'
>>> m.__obtenir l'article__(2)
'bar'
>>> m[[[[2]
'bar'
Cela fonctionne également avec les groupes capturés nommés:
>>> m = ré.rencontre(
... r'foo, (? P w +), (? P w +), qux ' ,
... «foo, bar, baz, qux»)
>>> m.groupe(«w2»)
«baz»
>>> m[[[[«w2»]
«baz»
C'est quelque chose que vous pourriez réaliser en appelant simplement .groupe()
explicitement, mais c'est quand même une jolie notation de raccourci.
Lorsqu'un langage de programmation fournit une syntaxe alternative qui n'est pas strictement nécessaire mais permet l'expression de quelque chose d'une manière plus propre et plus facile à lire, on l'appelle sucre syntaxique. Pour un objet de correspondance, rencontre[n]
est du sucre syntaxique pour match.group (n)
.
Remarque: De nombreux objets en Python ont un .__obtenir l'article()
définie, permettant l'utilisation de la syntaxe d'indexation entre crochets. Cependant, cette fonctionnalité n'est disponible que pour les objets de correspondance d'expression régulière dans Python version 3.6 ou ultérieure.
match.groups (par défaut = Aucun)
Renvoie tous les groupes capturés d'une correspondance.
match.groups ()
renvoie un tuple de tous les groupes capturés:
>>> m = ré.chercher(r«( w +), ( w +), ( w +)», 'foo, bar, baz')
>>> m.groupes()
('foo', 'bar', 'baz')
Comme vous l'avez vu précédemment, lorsqu'un groupe dans une expression régulière en Python ne participe pas au match global, .groupe()
Retour Aucun
pour ce groupe. Par défaut, .groupes()
fait de même.
Si tu veux .groupes()
pour renvoyer autre chose dans cette situation, vous pouvez utiliser le défaut
argument de mot clé:
1 >>> m = ré.chercher(r'( w +), ( w +), ( w +)?', 'foo, bar,')
2 >>> m
3 <_sre.SRE_Match object; span=(0, 8), match='foo,bar,'>
4 >>> impression(m.groupe(3))
5 Aucun
6
7 >>> m.groupes()
8 ('foo', 'bar', Aucun)
9 >>> m.groupes(défaut=«---»)
dix ('foo', 'bar', '---')
Ici, le troisième ( w +)
le groupe ne participe pas au match car le point d'interrogation (?
), le métacaractère le rend facultatif, et la chaîne 'foo, bar,'
ne contient pas une troisième séquence de caractères de mot. Par défaut, m.groups ()
Retour Aucun
pour le troisième groupe, comme indiqué sur ligne 8. Sur ligne 10, vous pouvez voir que la spécification par défaut = '---'
le fait retourner la chaîne «---»
au lieu.
Il n'y a pas de correspondance défaut
mot-clé pour .groupe()
. Il revient toujours Aucun
pour les groupes non participants.
match.groupdict (défaut = Aucun)
Renvoie un dictionnaire des groupes capturés nommés.
match.groupdict ()
renvoie un dictionnaire de tous les groupes nommés capturés avec le (? P
séquence de métacaractères. Les clés de dictionnaire sont les noms de groupe et les valeurs de dictionnaire sont les valeurs de groupe correspondantes:
>>> m = ré.rencontre(
... r'foo, (? P w +), (? P w +), qux ' ,
... «foo, bar, baz, qux»)
>>> m.groupdict()
'w1': 'bar', 'w2': 'baz'
>>> m.groupdict()[[[[«w2»]
«baz»
Comme avec .groupes()
, pour .groupdict ()
le défaut
L'argument détermine la valeur de retour pour les groupes non participants:
>>> m = ré.rencontre(
... r'foo, (? P w +), (? P w +) ?, qux ' ,
... 'foo, bar ,, qux')
>>> m.groupdict()
'w1': 'bar', 'w2': Aucun
>>> m.groupdict(défaut=«---»)
'w1': 'bar', 'w2': '---'
Encore une fois, le dernier groupe (? P
ne participe pas au match global en raison du point d'interrogation (?
) métacaractère. Par défaut, m.groupdict ()
Retour Aucun
pour ce groupe, mais vous pouvez le changer avec le défaut
argument.
match.expand ()
Effectue des substitutions de référence arrière à partir d'un match.
match.expand ()
renvoie la chaîne qui résulte de l'exécution de la substitution de référence arrière sur exactement comme
re.sub ()
ferait:
1 >>> m = ré.chercher(r«( w +), ( w +), ( w +)», 'foo, bar, baz')
2 >>> m
3 <_sre.SRE_Match object; span=(0, 11), match='foo,bar,baz'>
4 >>> m.groupes()
5 ('foo', 'bar', 'baz')
6
7 >>> m.développer(r' 2')
8 'bar'
9 >>> m.développer(r"[3] -> [1]")
dix "[baz] -> [foo]"
11
12 >>> m = ré.chercher(r«(? P d +) ' , «foo123qux»)
13 >>> m
14 <_sre.SRE_Match object; span=(3, 6), match='123'>
15 >>> m.groupe(1)
16 «123»
17
18 >>> m.développer(r'--- g --- ' )
19 «--- 123 ---»
Cela fonctionne pour les références numériques, comme sur lignes 7 et 9 ci-dessus, ainsi que pour les références ligne 18.
match.start ([[[[
match.end ([[[[
Renvoie les indices de début et de fin de la correspondance.
match.start ()
renvoie l'index dans la chaîne de recherche où commence la correspondance, et match.end ()
renvoie l'index immédiatement après la fin de la correspondance:
1 >>> s = «foo123bar456baz»
2 >>> m = ré.chercher(' d +', s)
3 >>> m
4 <_sre.SRE_Match object; span=(3, 6), match='123'>
5 >>> m.début()
6 3
7 >>> m.fin()
8 6
Lorsque Python affiche un objet de correspondance, ce sont les valeurs répertoriées avec le span =
mot-clé, comme indiqué sur ligne 4 au dessus de. Ils se comportent comme des valeurs de découpage de chaîne, donc si vous les utilisez pour découper la chaîne de recherche d'origine, vous devriez obtenir la sous-chaîne correspondante:
>>> m
<_sre.SRE_Match object; span=(3, 6), match='123'>
>>> s[[[[m.début():m.fin()]
«123»
match.start (
et match.end (
renvoie les indices de début et de fin de la sous-chaîne correspondant à
, qui peut être un groupe numéroté ou nommé:
>>> s = «foo123bar456baz»
>>> m = ré.chercher(r'( d +) D * (? P d +) ' , s)
>>> m.groupe(1)
«123»
>>> m.début(1), m.fin(1)
(3, 6)
>>> s[[[[m.début(1):m.fin(1)]
«123»
>>> m.groupe('num')
«456»
>>> m.début('num'), m.fin('num')
(9, 12)
>>> s[[[[m.début('num'):m.fin('num')]
«456»
Si le groupe spécifié correspond à une chaîne nulle, alors .début()
et .fin()
sont égaux:
>>> m = ré.chercher('foo ( d *) bar', «foobar»)
>>> m[[[[1]
''
>>> m.début(1), m.fin(1)
(3, 3)
Cela a du sens si vous vous souvenez que .début()
et .fin()
agir comme des indices de découpage. Toute tranche de chaîne où les indices de début et de fin sont égaux sera toujours une chaîne vide.
Un cas spécial se produit lorsque l'expression régulière contient un groupe qui ne participe pas au match:
>>> m = ré.chercher(r'( w +), ( w +), ( w +)?', 'foo, bar,')
>>> impression(m.groupe(3))
Aucun
>>> m.début(3), m.fin(3)
(-1, -1)
Comme vous l'avez vu précédemment, dans ce cas, le troisième groupe ne participe pas. m.start (3)
et m.end (3)
n’ont pas vraiment de sens ici, alors ils reviennent -1
.
match.span ([[[[
Renvoie les indices de début et de fin de la correspondance.
match.span ()
renvoie les indices de début et de fin de la correspondance sous forme de tuple. Si vous avez spécifié
, le tuple de retour s'applique au groupe donné:
>>> s = «foo123bar456baz»
>>> m = ré.chercher(r'( d +) D * (? P d +) ' , s)
>>> m
<_sre.SRE_Match object; span=(3, 12), match='123bar456'>
>>> m[[[[0]
«123bar456»
>>> m.envergure()
(3, 12)
>>> m[[[[1]
«123»
>>> m.envergure(1)
(3, 6)
>>> m[[[['num']
«456»
>>> m.envergure('num')
(9, 12)
Les éléments suivants sont effectivement équivalents:
match.span (
) (match.start (
), match.end ( ))
match.span ()
fournit simplement un moyen pratique d'obtenir les deux match.start ()
et match.end ()
dans un appel de méthode.
Faire correspondre les attributs d'objet
Comme un objet d'expression régulière compilé, un objet de correspondance a également plusieurs attributs utiles disponibles:
Attribut | Sens |
---|---|
match.pos match.endpos |
Les valeurs effectives du et arguments pour la correspondance |
match.lastindex |
L'index du dernier groupe capturé |
match.lastgroup |
Le nom du dernier groupe capturé |
match.re |
L'objet d'expression régulière compilé pour la correspondance |
match.string |
La chaîne de recherche pour la correspondance |
Les sections suivantes fournissent plus de détails sur ces attributs d'objet de correspondance.
match.pos
match.endpos
Contiennent les valeurs effectives de
et
pour la recherche.
N'oubliez pas que certaines méthodes, lorsqu'elles sont invoquées sur une expression régulière compilée, acceptent facultatif
et
des arguments qui limitent la recherche à une partie de la chaîne de recherche spécifiée. Ces valeurs sont accessibles à partir de l'objet de correspondance avec le .pos
et .endpos
les attributs:
>>> re_obj = ré.compiler(r' d +')
>>> m = re_obj.chercher('foo123bar', 2, 7)
>>> m
<_sre.SRE_Match object; span=(3, 6), match='123'>
>>> m.pos, m.endpos
(2, 7)
Si la
et
les arguments ne sont pas inclus dans l'appel, soit parce qu'ils ont été omis, soit parce que la fonction en question ne les accepte pas, alors le .pos
et .endpos
les attributs indiquent effectivement le début et la fin de la chaîne:
1 >>> re_obj = ré.compiler(r' d +')
2 >>> m = re_obj.chercher('foo123bar')
3 >>> m
4 <_sre.SRE_Match object; span=(3, 6), match='123'>
5 >>> m.pos, m.endpos
6 (0, 9)
7
8 >>> m = ré.chercher(r' d +', 'foo123bar')
9 >>> m
dix <_sre.SRE_Match object; span=(3, 6), match='123'>
11 >>> m.pos, m.endpos
12 (0, 9)
le re_obj.search ()
appeler ci-dessus ligne 2 pourrait prendre
et
mais ils ne sont pas spécifiés. le recherche()
appeler ligne 8 ne peut pas les prendre du tout. Dans tous les cas, m.pos
et m.endpos
sont 0
et 9
, les indices de début et de fin de la chaîne de recherche 'foo123bar'
.
match.lastindex
Contient l'index du dernier groupe capturé.
match.lastindex
est égal à l'indice entier du dernier groupe capturé:
>>> m = ré.chercher(r«( w +), ( w +), ( w +)», 'foo, bar, baz')
>>> m.lastindex
3
>>> m[[[[m.lastindex]
«baz»
Dans les cas où l'expression régulière contient des groupes potentiellement non participants, cela vous permet de déterminer combien de groupes ont réellement participé au match:
>>> m = ré.chercher(r'( w +), ( w +), ( w +)?', 'foo, bar, baz')
>>> m.groupes()
('foo', 'bar', 'baz')
>>> m.lastindex, m[[[[m.lastindex]
(3, «baz»)
>>> m = ré.chercher(r'( w +), ( w +), ( w +)?', 'foo, bar,')
>>> m.groupes()
('foo', 'bar', Aucun)
>>> m.lastindex, m[[[[m.lastindex]
(2, «bar»)
Dans le premier exemple, le troisième groupe, qui est facultatif en raison du point d'interrogation (?
) métacaractère, participe au match. Mais dans le deuxième exemple, ce n'est pas le cas. Vous pouvez le dire parce que m.lastindex
est 3
dans le premier cas et 2
dans la seconde.
Il y a un point subtil à prendre en compte concernant .lastindex
. Il n’est pas toujours vrai que le dernier groupe à mettre en correspondance soit également le dernier groupe rencontré syntaxiquement. La documentation Python donne cet exemple:
>>> m = ré.rencontre('((un B))', 'un B')
>>> m.groupes()
('ab', 'a', 'b')
>>> m.lastindex
1
>>> m[[[[m.lastindex]
'un B'
Le groupe le plus à l'extérieur est ((un B))
, qui correspond 'un B'
. C'est le premier groupe que l'analyseur rencontre, il devient donc le groupe 1. Mais c'est aussi le dernier groupe à correspondre, c'est pourquoi m.lastindex
est 1
.
Les deuxième et troisième groupes reconnus par l'analyseur sont (une)
et b)
. Ce sont des groupes 2
et 3
, mais ils correspondent avant le groupe 1
Est-ce que.
match.lastgroup
Contient le nom du dernier groupe capturé.
Si le dernier groupe capturé provient de la (? P
séquence de métacaractères, puis match.lastgroup
renvoie le nom de ce groupe:
>>> s = «foo123bar456baz»
>>> m = ré.chercher(r«(? P d +) D * (? P d +) ' , s)
>>> m.dernier groupe
«n2»
match.lastgroup
Retour Aucun
si le dernier groupe capturé n'est pas un groupe nommé:
>>> s = «foo123bar456baz»
>>> m = ré.chercher(r«( d +) D * ( d +)», s)
>>> m.groupes()
(«123», «456»)
>>> impression(m.dernier groupe)
Aucun
>>> m = ré.chercher(r« d + D * d +», s)
>>> m.groupes()
()
>>> impression(m.dernier groupe)
Aucun
Comme illustré ci-dessus, cela peut être dû au fait que le dernier groupe capturé n'est pas un groupe nommé ou à l'absence de groupes capturés.
match.re
Contient l'objet d'expression régulière pour la correspondance.
match.re
contient l'objet d'expression régulière qui a produit la correspondance. C'est le même objet que vous obtiendriez si vous passiez l'expression régulière à re.compile ()
:
1 >>> regex = r«( w +), ( w +), ( w +)»
2
3 >>> m1 = ré.chercher(regex, 'foo, bar, baz')
4 >>> m1
5 <_sre.SRE_Match object; span=(0, 11), match='foo,bar,baz'>
6 >>> m1.ré
7 re.compile ('(\ w +), (\ w +), (\ w +)')
8
9 >>> re_obj = ré.compiler(regex)
dix >>> re_obj
11 re.compile ('(\ w +), (\ w +), (\ w +)')
12 >>> re_obj est m1.ré
13 Vrai
14
15 >>> m2 = re_obj.chercher(«qux, quux, corge»)
16 >>> m2
17 <_sre.SRE_Match object; span=(0, 14), match='qux,quux,corge'>
18 >>> m2.ré
19 re.compile ('(\ w +), (\ w +), (\ w +)')
20 >>> m2.ré est re_obj est m1.ré
21 Vrai
N'oubliez pas que plus tôt ré
le module met en cache les expressions régulières après les avoir compilées, elles n'ont donc pas besoin d'être recompilées si elles sont réutilisées. Pour cette raison, comme les comparaisons d'identité sur lignes 12 et 20 montrer, tous les divers objets d'expression régulière dans l'exemple ci-dessus sont exactement le même objet.
Une fois que vous avez accès à l'objet d'expression régulière pour la correspondance, tous les attributs de cet objet sont également disponibles:
>>> m1.ré.groupes
3
>>> m1.ré.modèle
«(\ w +), (\ w +), (\ w +)»
>>> m1.ré.modèle == regex
Vrai
>>> m1.ré.drapeaux
32
Vous pouvez également appeler l'une des méthodes définies pour un objet d'expression régulière compilé sur celui-ci:
>>> m = ré.chercher(r«( w +), ( w +), ( w +)», 'foo, bar, baz')
>>> m.ré
re.compile ('(\ w +), (\ w +), (\ w +)')
>>> m.ré.rencontre(«quux, corge, grault»)
<_sre.SRE_Match object; span=(0, 17), match='quux,corge,grault'>
Ici, .rencontre()
est invoqué le m.re
pour effectuer une autre recherche en utilisant la même expression régulière mais sur une chaîne de recherche différente.
match.string
Contient la chaîne de recherche pour une correspondance.
match.string
contient la chaîne de recherche qui est la cible de la correspondance:
>>> m = ré.chercher(r«( w +), ( w +), ( w +)», 'foo, bar, baz')
>>> m.chaîne
'foo, bar, baz'
>>> re_obj = ré.compiler(r«( w +), ( w +), ( w +)»)
>>> m = re_obj.chercher('foo, bar, baz')
>>> m.chaîne
'foo, bar, baz'
Comme vous pouvez le voir dans l'exemple, le .chaîne
est disponible lorsque l'objet de correspondance dérive également d'un objet d'expression régulière compilé.
[ad_2]