Regexes en Python – Real Python

By | avril 29, 2020
0 Comment

Formation Python

La plupart des fonctions du ré module prendre une option argument. Cela inclut la fonction que vous connaissez maintenant très bien, recherche().

Les indicateurs modifient le comportement d'analyse des expressions rationnelles, vous permettant d'affiner encore plus votre correspondance de motifs.

Indicateurs d'expression régulière pris en charge

Le tableau ci-dessous résume brièvement les indicateurs disponibles. Tous les drapeaux sauf re.DEBUG avoir un nom court à une seule lettre et également un nom plus long à mot complet:

Nom court Nom long Effet
re.I re.IGNORECASE Rend la correspondance des caractères alphabétiques insensible à la casse
re.M re.MULTILINE Fait en sorte que les ancres de début de chaîne et de fin de chaîne correspondent aux nouvelles lignes incorporées
re.S re.DOTALL Force le métacaractère point à correspondre à une nouvelle ligne
re.X re.VERBOSE Permet l'inclusion d'espaces et de commentaires dans une expression régulière
---- re.DEBUG Amène l'analyseur d'expressions régulières à afficher des informations de débogage sur la console
re.A re.ASCII Spécifie le codage ASCII pour la classification des caractères
re.U re.UNICODE Spécifie le codage Unicode pour la classification des caractères
re.L re.LOCALE Spécifie le codage pour la classification des caractères en fonction des paramètres régionaux actuels

Les sections suivantes décrivent plus en détail comment ces indicateurs affectent le comportement de correspondance.

re.I
re.IGNORECASE

Rend la casse assortie insensible.

Quand IGNORECASE est en vigueur, la correspondance des caractères est insensible à la casse:

>>>

    1 >>> ré.chercher(«a +», «aaaAAA»)
    2 <_sre.SRE_Match object; span=(0, 3), match='aaa'>
    3 >>> ré.chercher(«A +», «aaaAAA»)
    4 <_sre.SRE_Match object; span=(3, 6), match='AAA'>
    5 
    6 >>> ré.chercher(«a +», «aaaAAA», ré.je)
    7 <_sre.SRE_Match object; span=(0, 6), match='aaaAAA'>
    8 >>> ré.chercher(«A +», «aaaAAA», ré.IGNORECASE)
    9 <_sre.SRE_Match object; span=(0, 6), match='aaaAAA'>

Dans la recherche sur ligne 1, a + ne correspond qu'aux trois premiers caractères de «aaaAAA». De même, le ligne 3, A + ne correspond qu'aux trois derniers caractères. Mais dans les recherches suivantes, l'analyseur ignore la casse, donc les deux a + et A + correspondre à la chaîne entière.

IGNORECASE affecte également la correspondance alphabétique impliquant des classes de caractères:

>>>

>>> ré.chercher("[a-z]+ ', 'a B c d e F')
<_sre.SRE_Match object; span=(0, 1), match='a'>
>>> ré.chercher("[a-z]+ ', 'a B c d e F', ré.je)
<_sre.SRE_Match object; span=(0, 6), match='aBcDeF'>

Lorsque le cas est important, la portion la plus longue 'a B c d e F' cette [a-z]+ correspond à l'initiale 'une'. En précisant re.I rend le cas de recherche insensible, donc [a-z]+ correspond à la chaîne entière.

re.M
re.MULTILINE

Fait correspondre les ancres de début de chaîne et de fin de chaîne aux sauts de ligne incorporés.

Par défaut, le ^ (début de chaîne) et $ (fin de chaîne) les ancres ne correspondent qu'au début et à la fin de la chaîne de recherche:

>>>

>>> s = 'foo nbar nbaz '

>>> ré.chercher('^ foo', s)
<_sre.SRE_Match object; span=(0, 3), match='foo'>
>>> impression(ré.chercher('^ bar', s))
Aucun
>>> impression(ré.chercher('^ baz', s))
Aucun

>>> impression(ré.chercher('foo $', s))
Aucun
>>> impression(ré.chercher('bar $', s))
Aucun
>>> ré.chercher('baz $', s)
<_sre.SRE_Match object; span=(8, 11), match='baz'>

Dans ce cas, même si la chaîne de recherche 'foo nbar nbaz' contient des caractères de nouvelle ligne intégrés, uniquement 'foo' correspond lorsqu'il est ancré au début de la chaîne, et uniquement «baz» correspond lorsqu'il est ancré à la fin.

Cependant, si une chaîne contient des sauts de ligne, vous pouvez la considérer comme constituée de plusieurs lignes internes. Dans ce cas, si le MULTILINE est défini, le ^ et $ les métacaractères d'ancrage correspondent également aux lignes internes:

  • ^ correspond au début de la chaîne ou au début de n'importe quelle ligne de la chaîne (c'est-à-dire immédiatement après une nouvelle ligne).
  • $ correspond à la fin de la chaîne ou à la fin d'une ligne de la chaîne (précédant immédiatement une nouvelle ligne).

Voici les mêmes recherches que celles indiquées ci-dessus:

>>>

>>> s = 'foo nbar nbaz '
>>> impression(s)
foo
bar
baz

>>> ré.chercher('^ foo', s, ré.MULTILINE)
<_sre.SRE_Match object; span=(0, 3), match='foo'>
>>> ré.chercher('^ bar', s, ré.MULTILINE)
<_sre.SRE_Match object; span=(4, 7), match='bar'>
>>> ré.chercher('^ baz', s, ré.MULTILINE)
<_sre.SRE_Match object; span=(8, 11), match='baz'>

>>> ré.chercher('foo $', s, ré.M)
<_sre.SRE_Match object; span=(0, 3), match='foo'>
>>> ré.chercher('bar $', s, ré.M)
<_sre.SRE_Match object; span=(4, 7), match='bar'>
>>> ré.chercher('baz $', s, ré.M)
<_sre.SRE_Match object; span=(8, 11), match='baz'>

Dans la chaîne 'foo nbar nbaz', les trois 'foo', 'bar', et «baz» se produire au début ou à la fin de la chaîne ou au début ou à la fin d'une ligne dans la chaîne. Avec le MULTILINE jeu de drapeaux, les trois correspondent lorsqu'ils sont ancrés avec ^ ou $.

re.S
re.DOTALL

Provoque le point (.) métacaractère pour correspondre à une nouvelle ligne.

N'oubliez pas que par défaut, le métacaractère point correspond à n'importe quel caractère à l'exception du caractère de nouvelle ligne. le DOTALL drapeau lève cette restriction:

>>>

    1 >>> impression(ré.chercher('foo.bar', 'foo nbar'))
    2 Aucun
    3 >>> ré.chercher('foo.bar', 'foo nbar', ré.DOTALL)
    4 <_sre.SRE_Match object; span=(0, 7), match='foonbar'>
    5 >>> ré.chercher('foo.bar', 'foo nbar', ré.S)
    6 <_sre.SRE_Match object; span=(0, 7), match='foonbar'>

Dans cet exemple, le ligne 1 le métacaractère point ne correspond pas à la nouvelle ligne dans 'foo nbar'. Sur lignes 3 et 5, DOTALL est en vigueur, donc le point correspond à la nouvelle ligne. Notez que le nom court du DOTALL le drapeau est re.S, ne pas rouge comme on pouvait s'y attendre.

re.X
re.VERBOSE

Permet l'inclusion d'espaces et de commentaires dans une expression régulière.

le VERBEUX flag spécifie quelques comportements spéciaux:

  • L'analyseur syntaxique regex ignore tous les espaces, sauf s'il se trouve dans une classe de caractères ou s'il s'est échappé avec une barre oblique inverse.

  • Si l'expression régulière contient un # caractère qui n'est pas contenu dans une classe de caractères ou échappé avec une barre oblique inverse, alors l'analyseur l'ignore et tous les caractères à sa droite.

À quoi ça sert? Il vous permet de formater une expression régulière en Python afin qu'elle soit plus lisible et auto-documentée.

Voici un exemple montrant comment vous pourriez utiliser cela. Supposons que vous souhaitiez analyser les numéros de téléphone au format suivant:

  • Indicatif régional à trois chiffres facultatif, entre parenthèses
  • Espace en option
  • Préfixe à trois chiffres
  • Séparateur (soit «-» ou ".")
  • Numéro de ligne à quatre chiffres

Le regex suivant fait l'affaire:

>>>

>>> regex = r'^ ( ( d3))?Dakota du Sud3[-.]ré4$ '

>>> ré.chercher(regex, «414.9229»)
<_sre.SRE_Match object; span=(0, 8), match='414.9229'>
>>> ré.chercher(regex, «414-9229»)
<_sre.SRE_Match object; span=(0, 8), match='414-9229'>
>>> ré.chercher(regex, «(712) 414-9229»)
<_sre.SRE_Match object; span=(0, 13), match='(712)414-9229'>
>>> ré.chercher(regex, «(712) 414-9229»)
<_sre.SRE_Match object; span=(0, 14), match='(712) 414-9229'>

Mais r '^ ( ( d 3 ))? s * d 3[-.] d 4 $ ' est plein d’œil, n’est-ce pas? En utilisant le VERBEUX , vous pouvez écrire le même regex en Python comme ceci à la place:

>>>

>>> regex = r'' '^ # Début de chaîne
...                                                 ((ré3))? # Indicatif régional facultatif
...                                                  s * # Espace blanc facultatif
...                                                 ré3                                            # Préfixe à trois chiffres
...             [-.]                                                # Caractère séparateur
...                                                 ré4                                            # Numéro de ligne à quatre chiffres
...                                                 $ # Ancre en fin de ligne
...                                                 '' '

>>> ré.chercher(regex, «414.9229», ré.VERBEUX)
<_sre.SRE_Match object; span=(0, 8), match='414.9229'>
>>> ré.chercher(regex, «414-9229», ré.VERBEUX)
<_sre.SRE_Match object; span=(0, 8), match='414-9229'>
>>> ré.chercher(regex, «(712) 414-9229», ré.X)
<_sre.SRE_Match object; span=(0, 13), match='(712)414-9229'>
>>> ré.chercher(regex, «(712) 414-9229», ré.X)
<_sre.SRE_Match object; span=(0, 14), match='(712) 414-9229'>

le recherche() les appels sont les mêmes que ceux indiqués ci-dessus, vous pouvez donc voir que cette expression régulière fonctionne de la même manière que celle spécifiée précédemment. Mais c'est moins difficile à comprendre à première vue.

Notez que les guillemets triples rendent particulièrement pratique l'inclusion de nouvelles lignes imbriquées, qui peuvent être considérées comme des espaces blancs ignorés dans VERBEUX mode.

Lorsque vous utilisez le VERBEUX drapeau, faites attention aux espaces que vous avez l'intention de représenter. Considérez ces exemples:

>>>

    1 >>> ré.chercher('foo bar', 'foo bar')
    2 <_sre.SRE_Match object; span=(0, 7), match='foo bar'>
    3 
    4 >>> impression(ré.chercher('foo bar', 'foo bar', ré.VERBEUX))
    5 Aucun
    6 
    7 >>> ré.chercher('foo  bar', 'foo bar', ré.VERBEUX)
    8 <_sre.SRE_Match object; span=(0, 7), match='foo bar'>
    9 >>> ré.chercher('foo[ ]bar', 'foo bar', ré.VERBEUX)
dix <_sre.SRE_Match object; span=(0, 7), match='foo bar'>

Après tout ce que vous avez vu jusqu'ici, vous vous demandez peut-être pourquoi ligne 4 le regex foo bar ne correspond pas à la chaîne 'foo bar'. Ce n'est pas parce que le VERBEUX L'indicateur fait en sorte que l'analyseur ignore le caractère espace.

Pour faire cette correspondance comme prévu, échappez le caractère espace avec une barre oblique inverse ou incluez-le dans une classe de caractères, comme indiqué sur lignes 7 et 9.

Comme avec le DOTALL drapeau, notez que le VERBEUX le drapeau a un nom abrégé non intuitif: re.X, ne pas tour.

re.DEBUG

Affiche les informations de débogage.

le DÉBOGUER L'indicateur amène l'analyseur d'expressions régulières en Python à afficher des informations de débogage sur le processus d'analyse sur la console:

>>>

>>> ré.chercher('foo.bar', «fooxbar», ré.DÉBOGUER)
LITERAL 102
LITERAL 111
LITERAL 111
AUCUN
LITERAL 98
LITERAL 97
LITERAL 114
<_sre.SRE_Match object; span=(0, 7), match='fooxbar'>

Lorsque l'analyseur s'affiche LITERAL nnn dans la sortie de débogage, il affiche le code ASCII d'un caractère littéral dans l'expression régulière. Dans ce cas, les caractères littéraux sont 'F', «o», «o» et «b», 'une', 'r'.

Voici un exemple plus compliqué. Ceci est le regex de numéro de téléphone indiqué dans la discussion sur le VERBEUX drapeau plus tôt:

>>>

>>> regex = r'^ ( ( d3))?Dakota du Sud3[-.]ré4$ '

>>> ré.chercher(regex, «414.9229», ré.DÉBOGUER)
À AT_BEGINNING
MAX_REPEAT 0 1
        SOUS-MOTIF 1 0 0
                LITERAL 40
                MAX_REPEAT 3 3
                        DANS
                                CATÉGORIE CATEGORY_DIGIT
                LITERAL 41
MAX_REPEAT 0 MAXREPEAT
        DANS
                CATÉGORIE CATEGORY_SPACE
MAX_REPEAT 3 3
        DANS
                CATÉGORIE CATEGORY_DIGIT
DANS
        LITERAL 45
        LITERAL 46
MAX_REPEAT 4 4
        DANS
                CATÉGORIE CATEGORY_DIGIT
À AT_END
<_sre.SRE_Match object; span=(0, 8), match='414.9229'>

Cela ressemble à beaucoup d'informations ésotériques dont vous n'auriez jamais besoin, mais cela peut être utile. Voir la plongée profonde ci-dessous pour une application pratique.

Deep Dive: débogage de l'analyse des expressions régulières

Comme vous le savez d'en haut, la séquence de métacaractères m, n indique un nombre spécifique de répétitions. Il correspond partout de m à n répétitions de ce qui le précède:

>>>

>>> ré.chercher('X[123]2,4 y ', «x222y»)
<_sre.SRE_Match object; span=(0, 5), match='x222y'>

Vous pouvez le vérifier avec le DÉBOGUER drapeau:

>>>

>>> ré.chercher('X[123]2,4 y ', «x222y», ré.DÉBOGUER)
LITERAL 120
MAX_REPEAT 2 4
        DANS
                LITERAL 49
                LITERAL 50
                LITERAL 51
LITERAL 121
<_sre.SRE_Match object; span=(0, 5), match='x222y'>

MAX_REPEAT 2 4 confirme que l'analyseur d'expressions rationnelles reconnaît la séquence de métacaractères 2,4 et l'interprète comme un quantificateur de plage.

Mais, comme indiqué précédemment, si une paire d'accolades dans une expression régulière en Python contient autre chose qu'un nombre ou une plage numérique valide, elle perd alors sa signification particulière.

Vous pouvez également le vérifier:

>>>

>>> ré.chercher('X[123]fooy ', «x222y», ré.DÉBOGUER)
LITERAL 120
DANS
        LITERAL 49
        LITERAL 50
        LITERAL 51
LITERAL 123
LITERAL 102
LITERAL 111
LITERAL 111
LITERAL 125
LITERAL 121

Vous pouvez voir qu'il n'y a pas MAX_REPEAT jeton dans la sortie de débogage. le LITTÉRAL les jetons indiquent que l'analyseur traite foo littéralement et non pas comme une séquence de métacaractère quantificateur. 123, 102, 111, 111, et 125 sont les codes ASCII des caractères de la chaîne littérale 'foo'.

Informations affichées par le DÉBOGUER peut vous aider à résoudre les problèmes en vous montrant comment l'analyseur interprète votre expression régulière.

Curieusement, le ré Le module ne définit pas de version à une lettre du DÉBOGUER drapeau. Vous pouvez définir le vôtre si vous souhaitez:

>>>

>>> importation ré
>>> ré.ré
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
AttributeError: le module «re» n'a pas d'attribut «D»

>>> ré.ré = ré.DÉBOGUER
>>> ré.chercher('foo', 'foo', ré.ré)
LITERAL 102
LITERAL 111
LITERAL 111
<_sre.SRE_Match object; span=(0, 3), match='foo'>

Mais cela peut être plus déroutant qu'utile, car les lecteurs de votre code peuvent le interpréter comme une abréviation pour le DOTALL drapeau. Si vous avez fait cette tâche, ce serait une bonne idée de la documenter en profondeur.

re.A
re.ASCII
re.U
re.UNICODE
re.L
re.LOCALE

Spécifiez le codage de caractères utilisé pour l'analyse des classes de caractères regex spéciales.

Plusieurs séquences de métacaractères d'expression régulière ( w, W, b, B, ré, RÉ, s, et S) vous obligent à affecter des caractères à certaines classes comme les mots, les chiffres ou les espaces. Les drapeaux de ce groupe déterminent le schéma de codage utilisé pour affecter des caractères à ces classes. Les codages possibles sont ASCII, Unicode ou selon les paramètres régionaux actuels.

Vous avez eu une brève introduction à l'encodage de caractères et Unicode dans le tutoriel sur les chaînes et les données de caractères en Python, sous la discussion de la ord () fonction intégrée. Pour des informations plus détaillées, consultez ces ressources:

Pourquoi le codage de caractères est-il si important dans le contexte des expressions régulières en Python? Voici un petit exemple.

Vous avez appris plus tôt que ré spécifie un caractère à un chiffre. La description du ré la séquence de métacaractères indique qu'elle est équivalente à la classe de caractères [0-9]. Cela se trouve être vrai pour les langues anglaises et occidentales, mais pour la plupart des langues du monde, les caractères '0' par «9» ne représentent pas tout ou même tout des chiffres.

Par exemple, voici une chaîne composée de trois caractères numériques devanagari:

>>>

>>> s = " u0967  u096a  u096c"
>>> s
«१४६»

Pour que l'analyseur d'expressions rationnelles rende correctement compte du script Devanagari, la séquence de métacaractères numérique ré doit également correspondre à chacun de ces caractères.

Le consortium Unicode a créé Unicode pour gérer ce problème. Unicode est une norme de codage de caractères conçue pour représenter tous les systèmes d'écriture du monde. Toutes les chaînes en Python 3, y compris les expressions rationnelles, sont par défaut Unicode.

Alors, revenons aux drapeaux listés ci-dessus. Ces indicateurs aident à déterminer si un caractère appartient à une classe donnée en spécifiant si le codage utilisé est ASCII, Unicode ou les paramètres régionaux actuels:

  • re.U et re.UNICODE spécifiez le codage Unicode. Unicode est la valeur par défaut, donc ces drapeaux sont superflus. Ils sont principalement pris en charge pour la compatibilité descendante.
  • re.A et re.ASCII forcer une détermination basée sur le codage ASCII. Si vous opérez en anglais, cela se produit de toute façon, donc le drapeau n'affectera pas la recherche d'une correspondance.
  • re.L et re.LOCALE effectuer la détermination en fonction des paramètres régionaux actuels. Les paramètres régionaux sont un concept obsolète et ne sont pas considérés comme fiables. Sauf dans de rares circonstances, il est peu probable que vous en ayez besoin.

En utilisant l'encodage Unicode par défaut, l'analyseur d'expressions rationnelles devrait être capable de gérer n'importe quelle langue que vous lui lancez. Dans l'exemple suivant, il reconnaît correctement chacun des caractères de la chaîne «१४६» sous forme de chiffre:

>>>

>>> s = " u0967  u096a  u096c"
>>> s
«१४६»
>>> ré.chercher(' d +', s)
<_sre.SRE_Match object; span=(0, 3), match='१४६'>

Voici un autre exemple qui illustre comment l'encodage de caractères peut affecter une correspondance d'expression régulière en Python. Considérez cette chaîne:

>>>

>>> s = 'sch u00f6n '
>>> s
«schön»

«schön» (le mot allemand pour joli ou agréable) contient le «ö» caractère, qui a la valeur Unicode hexadécimal 16 bits 00f6. Ce caractère n'est pas représentable en ASCII 7 bits traditionnel.

Si vous travaillez en allemand, vous devez raisonnablement vous attendre à ce que l'analyseur d'expressions rationnelles tienne compte de tous les caractères de «schön» être des caractères de mot. Mais regardez ce qui se passe si vous recherchez s pour les caractères de mot en utilisant le w classe de caractères et forcer un encodage ASCII:

>>>

>>> ré.chercher(' w +', s, ré.ASCII)
<_sre.SRE_Match object; span=(0, 3), match='sch'>

Lorsque vous limitez l'encodage en ASCII, l'analyseur d'expressions régulières ne reconnaît que les trois premiers caractères en tant que caractères de mot. Le match s'arrête à «ö».

En revanche, si vous spécifiez re.UNICODE ou autoriser le codage par défaut à Unicode, puis tous les caractères de «schön» qualifier de caractères de mot:

>>>

>>> ré.chercher(' w +', s, ré.UNICODE)
<_sre.SRE_Match object; span=(0, 5), match='schön'>
>>> ré.chercher(' w +', s)
<_sre.SRE_Match object; span=(0, 5), match='schön'>

le ASCII et LIEU des drapeaux sont disponibles au cas où vous en auriez besoin dans des circonstances particulières. Mais en général, la meilleure stratégie consiste à utiliser l'encodage Unicode par défaut. Cela devrait gérer correctement n'importe quelle langue du monde.

Combiner Arguments dans un appel de fonction

Les valeurs d'indicateur sont définies de sorte que vous pouvez les combiner à l'aide de l'opérateur OR au niveau du bit (|) opérateur. Cela vous permet de spécifier plusieurs indicateurs dans un seul appel de fonction:

>>>

>>> ré.chercher('^ bar', «FOO nBAR nBAZ ', ré.je|ré.M)
<_sre.SRE_Match object; span=(4, 7), match='BAR'>

Cette recherche() l'appel utilise OR au niveau du bit pour spécifier à la fois la IGNORECASE et MULTILINE drapeaux à la fois.

Définition et suppression des indicateurs dans une expression régulière

En plus de pouvoir passer un argument à la plupart ré les appels de fonction du module, vous pouvez également modifier les valeurs des indicateurs dans une expression régulière en Python. Il existe deux séquences de métacaractères d'expression régulière qui offrent cette capacité.

(?)

Définit la ou les valeurs d'indicateur pour la durée d'une expression régulière.

Dans une expression régulière, la séquence de métacaractères (?) définit les indicateurs spécifiés pour l'expression entière.

La valeur de est une ou plusieurs lettres de l'ensemble une, je, L, m, s, u, et X. Voici comment ils correspondent aux ré drapeaux de module:

Lettre Drapeaux
une re.A re.ASCII
je re.I re.IGNORECASE
L re.L re.LOCALE
m re.M re.MULTILINE
s re.S re.DOTALL
u re.U re.UNICODE
X re.X re.VERBOSE

le (?) la séquence de métacaractères dans son ensemble correspond à la chaîne vide. Il correspond toujours avec succès et ne consomme aucune des chaînes de recherche.

Les exemples suivants sont des moyens équivalents de définir IGNORECASE et MULTILINE drapeaux:

>>>

>>> ré.chercher('^ bar', «FOO nBAR nBAZ n", ré.je|ré.M)
<_sre.SRE_Match object; span=(4, 7), match='BAR'>

>>> ré.chercher('(? im) ^ bar', «FOO nBAR nBAZ n")
<_sre.SRE_Match object; span=(4, 7), match='BAR'>

Notez qu'un (?) la séquence de métacaractères définit le ou les indicateurs donnés pour toute l'expression régulière, peu importe où vous la placez dans l'expression:

>>>

>>> ré.chercher('foo.bar (? s) .baz', 'foo nbar nbaz ')
<_sre.SRE_Match object; span=(0, 11), match='foonbarnbaz'>

>>> ré.chercher('foo.bar.baz (? s)', 'foo nbar nbaz ')
<_sre.SRE_Match object; span=(0, 11), match='foonbarnbaz'>

Dans les exemples ci-dessus, les deux métacaractères de point correspondent à des retours à la ligne car le DOTALL le drapeau est en vigueur. Cela est vrai même lorsque (? s) apparaît au milieu ou à la fin de l'expression.

Depuis Python 3.7, il est déconseillé de spécifier (?) n'importe où dans une expression régulière autre qu'au début:

>>>

>>> importation sys
>>> sys.version
'3.8.0 (par défaut, 14 octobre 2019, 21:29:03)  n[GCC 7.4.0]"

>>> ré.chercher('foo.bar.baz (? s)', 'foo nbar nbaz ')
: 1: DeprecationWarning: Drapeaux pas au début
                de l'expression «foo.bar.baz (? s)»

Il produit toujours la correspondance appropriée, mais vous recevrez un message d'avertissement.

(?-:)

Définit ou supprime la ou les valeurs d'indicateur pour la durée d'un groupe.

(?-:) définit un groupe non capturant qui correspond à . Pour le contenu dans le groupe, l'analyseur syntaxique regex définit tous les drapeaux spécifiés dans et efface tous les drapeaux spécifiés dans .

Valeurs pour et sont le plus souvent je, m, s ou X.

Dans l'exemple suivant, le IGNORECASE l'indicateur est défini pour le groupe spécifié:

>>>

>>> ré.chercher('(? i: foo) bar', «FOObar»)

Cela produit une correspondance car (? i: foo) dicte que le match contre «FOO» est insensible à la casse.

Maintenant, contrastez avec cet exemple:

>>>

>>> impression(ré.chercher('(? i: foo) bar', «FOOBAR»))
Aucun

Comme dans l'exemple précédent, le match contre «FOO» réussirait car il est insensible à la casse. Mais une fois hors du groupe, IGNORECASE n'est plus en vigueur, donc le match contre 'BAR' est sensible à la casse et échoue.

Voici un exemple qui montre comment désactiver un indicateur pour un groupe:

>>>

>>> impression(ré.chercher('(? -i: foo) bar', «FOOBAR», ré.IGNORECASE))
Aucun

Encore une fois, il n'y a pas de correspondance. Bien que re.IGNORECASE permet une correspondance insensible à la casse pour tout l'appel, la séquence de métacaractères (? -i: foo) éteint IGNORECASE pour la durée de ce groupe, donc le match contre «FOO» échoue.

Depuis Python 3.7, vous pouvez spécifier u, une, ou L comme pour remplacer le codage par défaut pour le groupe spécifié:

>>>

>>> s = 'sch u00f6n '
>>> s
«schön»

>>> # Nécessite Python 3.7 ou version ultérieure
>>> ré.chercher('(? a:  w +)', s)

>>> ré.chercher(«(? u:  w +)», s)

Cependant, vous ne pouvez définir l'encodage que de cette façon. Vous ne pouvez pas le supprimer:

>>>

>>> ré.chercher('(? -a:  w +)', s)
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
  
  
  
  Fichier "/usr/lib/python3.8/re.py", ligne 199, dans chercher
    revenir _compiler(modèle, drapeaux).chercher(chaîne)
  Fichier "/usr/lib/python3.8/re.py", ligne 302, dans _compiler
    p = sre_compile.compiler(modèle, drapeaux)
  Fichier "/usr/lib/python3.8/sre_compile.py", ligne 764, dans compiler
    p = sre_parse.analyser(p, drapeaux)
  Fichier "/usr/lib/python3.8/sre_parse.py", ligne 948, dans analyser
    p = _parse_sub(la source, Etat, drapeaux & SRE_FLAG_VERBOSE, 0)
  Fichier "/usr/lib/python3.8/sre_parse.py", ligne 443, dans _parse_sub
    ajouter des éléments(_parse(la source, Etat, verbeux, imbriqué + 1,
  Fichier "/usr/lib/python3.8/sre_parse.py", ligne 805, dans _parse
    drapeaux = _parse_flags(la source, Etat, carboniser)
  Fichier "/usr/lib/python3.8/sre_parse.py", ligne 904, dans _parse_flags
    élever la source.Erreur(msg)
re.error: mauvais drapeaux en ligne: ne peuvent pas désactiver les drapeaux «a», «u» et «L» à
position 4

u, une, et L s'excluent mutuellement. Un seul d'entre eux peut apparaître par groupe.

[ad_2]

Articles relatifs: