# 6.2. `re` — Opérations à base d’expressions rationnelles

Code source : Lib/re.py

Ce module fournit des opérations sur les expressions rationnelles similaires à celles que l’on trouve dans Perl.

Les motifs, comme les chaînes, à analyser peuvent aussi bien être des chaînes Unicode (`str`) que des chaînes 8-bits (`bytes`). Cependant, les chaînes Unicode et 8-bits ne peuvent pas être mélangées : c’est à dire que vous ne pouvez pas analyser une chaîne Unicode avec un motif 8-bit, et inversement ; de même, lors d’une substitution, la chaîne de remplacement doit être du même type que le motif et la chaîne analysée.

Les expressions rationnelles utilisent le caractère backslash (`'\'`) pour indiquer des formes spéciales ou permettre d’utiliser des caractères spéciaux sans en invoquer le sens. Cela entre en conflit avec l’utilisation en Python du même caractère pour la même raison dans les chaînes littérales ; par exemple, pour rechercher un backslash littéral il faudrait écrire `'\\\\'` comme motif, parce que l’expression rationnelle devrait être `\\` et chaque backslash doit être représenté par `\\` au sein des chaînes littérales Python.

La solution est d’utiliser la notation des chaînes brutes en Python pour les expressions rationnelles ; Les backslashs ne provoquent aucun traitement spécifique dans les chaînes littérales préfixées par `'r'`. Ainsi, `r"\n"` est une chaîne de deux caractères contenant `'\'` et `'n'`, tandis que `"\n"` est une chaîne contenant un unique caractère : un saut de ligne. Généralement, les motifs seront exprimés en Python à l’aide de chaînes brutes.

Il est important de noter que la plupart des opérations sur les expressions rationnelles sont disponibles comme fonctions au niveau du module et comme méthodes des expressions rationnelles compilées. Les fonctions sont des raccourcis qui ne vous obligent pas à d’abord compiler un objet regex, mais auxquelles manquent certains paramètres de configuration fine.

Voir aussi

Le module tiers regex, dont l’interface est compatible avec le module `re` de la bibliothèque standard, mais offre des fonctionnalités additionnelles et une meilleure gestion de l’Unicode.

## 6.2.1. Syntaxe des expressions rationnelles

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

Les expressions rationnelles peuvent être concaténées pour former de nouvelles expressions : si A et B sont deux expressions rationnelles, alors AB est aussi une expression rationnelle. En général, si une chaîne p valide A et qu’une autre chaîne q valide B, la chaîne pq validera AB. Cela est vrai tant que A et B ne contiennent pas d’opérations de priorité ; de conditions de frontière entre A et B ; ou de références vers des groupes numérotés. Ainsi, des expressions complexes peuvent facilement être construites depuis de plus simples expressions primitives comme celles décrites ici. Pour plus de détails sur la théorie et l’implémentation des expressions rationnelles, consultez le livre de Friedl [Frie09], ou à peu près n’importe quel livre dédié à la construction de compilateurs.

Une brève explication sur le format des expressions rationnelles suit. Pour de plus amples informations et une présentation plus simple, référez-vous au Guide des expressions régulières.

Les expressions rationnelles peuvent contenir à la fois des caractères spéciaux et ordinaires. Les plus ordinaires, comme `'A'`, `'a'` ou `'0'` sont les expressions rationnelles les plus simples : elles correspondent simplement à elles-mêmes. Vous pouvez concaténer des caractères ordinaires, ainsi `last` correspond à la chaîne `'last'`. (Dans la suite de cette section, nous écrirons les expressions rationnelles dans `ce style spécifique`, généralement sans guillemets, et les chaînes à tester `'entourées de simples guillemets'`.)

Certains caractères, comme `'|'` ou `'('`, sont spéciaux. Des caractères spéciaux peuvent aussi exister pour les classes de caractères ordinaires, ou affecter comment les expressions rationnelles autour d’eux seront interprétées.

Les caractères de répétition (`*`, `+`, `?`, `{m,n}`, etc.) ne peuvent être directement imbriqués. Cela empêche l’ambiguïté avec le suffixe modificateur non gourmand `?` et avec les autres modificateurs dans d’autres implémentations. Pour appliquer une seconde répétition à une première, des parenthèses peuvent être utilisées. Par exemple, l’expression `(?:a{6})*` valide toutes les chaînes composées d’un nombre de caractères `'a'` multiple de six.

Les caractères spéciaux sont :

`.`

  (Point.) Dans le mode par défaut, il valide tout caractère à l’exception du saut de ligne. Si l’option `DOTALL` a été spécifiée, il valide tout caractère, saut de ligne compris.

`^`

  (Accent circonflexe.) Valide le début d’une chaîne de caractères, ainsi que ce qui suit chaque saut de ligne en mode `MULTILINE`.

`$`

  Valide la fin d’une chaîne de caractères, ou juste avant le saut de ligne à la fin de la chaîne, ainsi qu’avant chaque saut de ligne en mode `MULTILINE`. `foo` valide à la fois foo et foobar, tandis que l’expression rationnelle `foo$` ne correspond qu’à `'foo'`. Plus intéressant, chercher `foo.$` dans `'foo1\nfoo2\n'` trouve normalement `'foo2'`, mais `'foo1'` en mode `MULTILINE` ; chercher un simple `$` dans `'foo\n'` trouvera deux correspondances (vides) : une juste avant le saut de ligne, et une à la fin de la chaîne.

`*`

  Fait valider par l’expression rationnelle résultante 0 répétition ou plus de l’expression qui précède, avec autant de répétitions que possible. `ab*` validera “a”, “ab” ou “a” suivi de n’importe quel nombre de “b”.

`+`

  Fait valider par l’expression rationnelle résultante 1 répétition ou plus de l’expression qui précède. `ab+` validera “a” suivi de n’importe quel nombre non nul de “b” ; cela ne validera pas la chaîne “a”.

`?`

  Fait valider par l’expression rationnelle résultante 0 ou 1 répétition de l’expression qui précède. `ab?` correspondra à “a” ou “ab”.

`*?`, `+?`, `??`

  Les qualificateurs `'*'`, `'+'` et `'?'` sont tous greedy (gourmands) ; ils valident autant de texte que possible. Parfois ce comportement n’est pas désiré ; si l’expression rationnelle `<.*>` est testée avec la chaîne `'<a> b <c>'`, cela correspondra à la chaîne entière, et non juste à `'<a>'`. Ajouter `?` derrière le qualificateur lui fait réaliser l’opération de façon non-greedy (ou minimal) ; le moins de caractères possibles seront validés. Utiliser l’expression rationnelle `<.*?>` validera uniquement `'<a>'`.

`{m}`

  Spécifie qu’exactement m copies de l’expression rationnelle qui précède devront être validées ; un nombre plus faible de correspondances empêche l’expression entière de correspondre. Par exemple, `a{6}` correspondra exactement à six caractères `'a'`, mais pas à cinq.

`{m,n}`

  Fait valider par l’expression rationnelle résultante entre m et n répétitions de l’expression qui précède, cherchant à en valider le plus possible. Par exemple, `a{3,5}` validera entre 3 et 5 caractères `'a'`. Omettre m revient à spécifier 0 comme borne inférieure, et omettre n à avoir une borne supérieure infinie. Par exemple, `a{4,}b` correspondra à `'aaaab'` ou à un millier de caractères `'a'` suivis d’un `'b'`, mais pas à `'aaab'`. La virgule ne doit pas être omise, auquel cas le modificateur serait confondu avec la forme décrite précédemment.

`{m,n}?`

  Fait valider par l’expression rationnelle résultante entre m et n répétitions de l’expression qui précède, cherchant à en valider le moins possible. Il s’agit de la version non gourmande du précédent qualificateur. Par exemple, dans la chaîne de 6 caractères `'aaaaaa'`, `a{3,5}` trouvera 5 caractères `'a'`, alors que `a{3,5}?` n’en trouvera que 3.

`\`

  Échappe les caractères spéciaux (permettant d’identifier des caractères comme `'*'`, `'?'` et autres) ou signale une séquence spéciale ; les séquences spéciales sont décrites ci-dessous.

  Si vous n’utilisez pas de chaînes brutes pour exprimer le motif, souvenez-vous que Python utilise aussi le backslash comme une séquence d’échappement dans les chaînes littérales ; si la séquence d’échappement n’est pas reconnue par l’interpréteur Python, le backslash et les caractères qui le suivent sont inclus dans la chaîne renvoyée. Cependant, si Python reconnait la séquence, le backslash doit être doublé (pour ne plus être reconnu). C’est assez compliqué et difficile à comprendre, c’est pourquoi il est hautement recommandé d’utiliser des chaînes brutes pour tout sauf les expressions les plus simples.

`[]`

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

  - Les caractères peuvent être listés individuellement, e.g. `[amk]` correspondra à `'a'`, `'m'` ou `'k'`.

  - Des intervalles de caractères peuvent être indiqués en donnant deux caractères et les séparant par un `'-'`, par exemple `[a-z]` correspondra à toute lettre minuscule ASCII, `[0-5][0-9]` à tous nombres de deux chiffres entre `00` et ``59`, et `[0-9A-Fa-f]` correspondra à n’importe quel chiffre hexadécimal. Si `'-'` est échappé (`[a\-z]`) ou s’il est placé comme premier ou dernier caractère (e.g. `[-a]` ou `[a-]`), il correspondra à un `'-'` littéral.

  - Les caractères spéciaux perdent leur sens à l’intérieur des ensembles. Par exemple, `[(+*)]` validera chacun des caractères littéraux `'('`, `'+'`, `'*'` ou `')'`.

  - Les classes de caractères telles que `\w` ou `\S` (définies ci-dessous) sont aussi acceptées à l’intérieur d’un ensemble, bien que les caractères correspondant dépendent de quel mode est actif entre `ASCII` et `LOCALE`.

  - Les caractères qui ne sont pas dans un intervalle peuvent être trouvés avec l’ensemble complémentaire (complementing). Si le premier caractère de l’ensemble est `'^'`, tous les caractères qui ne sont pas dans l’ensemble seront validés. Par exemple, `[^5]` correspondra à tout caractère autre que `'5'` et `[^^]` validera n’importe quel caractère excepté `'^'`. `^` n’a pas de sens particulier s’il n’est pas le premier caractère de l’ensemble.

  - Pour insérer un `']'` littéral dans un ensemble, il faut le précéder d’un backslash ou le placer au début de l’ensemble. Par exemple, `[()[\]{}]` et `[]()[{}]` vont tous deux correspondre à une parenthèse, un crochet ou une accolade.

`|`

  `A|B`, où A et B peuvent être deux expressions rationnelles arbitraires, crée une expression rationnelle qui validera soit A soit B. Un nombre arbitraire d’expressions peuvent être séparées de cette façon par des `'|'`. Cela peut aussi être utilisé au sein de groupes (voir ci-dessous). Quand une chaîne cible est analysée, les expressions séparées par `'|'` sont essayées de la gauche vers la droite. Quand un motif correspond complètement, cette branche est acceptée. Cela signifie qu’une fois que A correspond, B ne sera pas testée plus loin, même si elle pourrait provoquer une plus ample correspondance. En d’autres termes, l’opérateur `'|'` n’est jamais gourmand. Pour valider un `'|'` littéral, utilisez `\|`, ou enveloppez-le dans une classe de caractères, comme `[|]`.

`(...)`

  Valide n’importe quelle expression rationnelle comprise entre les parenthèses, et indique le début et la fin d’un groupe ; le contenu d’un groupe peut être récupéré après qu’une analyse a été effectuée et peut être réutilisé plus loin dans la chaîne avec une séquence spéciale `\number`, décrite ci-dessous. Pour écrire des `'('` ou `')'` littéraux, utilisez `\(` ou `\)`, ou enveloppez-les dans une classe de caractères : `[(]`, `[)]`.

`(?...)`

  Il s’agit d’une notation pour les extensions (un `'?'` suivant une `'('` n’a pas de sens autrement). Le premier caractère après le `'?'` détermine quel sens donner à l’expression. Les extensions ne créent généralement pas de nouveaux groupes ; `(?P<name>...)` est la seule exception à la règle. Retrouvez ci-dessous la liste des extensions actuellement supportées.

`(?aiLmsux)`

  (Une lettre ou plus de l’ensemble `'a'`, `'i'`, `'L'`, `'m'`, `'s'`, `'u'`, `'x'`.) Le groupe valide la chaîne vide ; les lettres activent les modes correspondant : `re.A` (validation ASCII seulement), `re.I` (ignorer la casse)`, `re.L` (dépendant de la locale), `re.M` (multi-ligne), `re.S` (les points correspondent à tous les caractères), `re.U` (support d’Unicode) et `re.X` (verbeux), pour l’ensemble de l’expression rationnelle. (Les options dans décrites dans la section Contenu du module.) C’est utile si vous souhaitez préciser l’option dans l’expression rationnelle, plutôt qu’en passant un argument flag à la fonction `re.compile()`. Les options devraient être spécifiées en premier dans la chaîne de l’expression.

`(?:...)`

  Une version sans capture des parenthèses habituelles. Valide n’importe quelle expression rationnelle à l’intérieur des parenthèses, mais la sous-chaîne correspondant au groupe ne peut pas être récupérée après l’analyse ou être référencée plus loin dans le motif.

`(?imsx-imsx:...)`

  (Zéro lettres ou plus de l’ensemble `'i'`, `'m'`, `'s'`, `'x'`, optionnellement suivies par `'-'` ainsi qu’une ou plusieurs lettres du même ensemble.) Les lettres activent ou désactivent les options correspondantes : `re.I` (ignorer la casse), `re.M` (multi-ligne), `re.S` (les points correspondent à tous les caractères) et `re.X` (verbeux), pour cette partie de l’expression. (Les options sont décrites dans la section Contenu du module.)

  Nouveau dans la version 3.6.

`(?P<name>...)`

  Similaires aux parenthèses habituelles, mais la sous-chaîne validée par le groupe est accessible via le nom name du groupe symbolique. Les noms de groupes doivent être des identifiants Python valides, et chaque nom de groupe ne doit être défini qu’une seule fois dans une expression rationnelle. Un groupe symbolique est aussi un groupe numéroté, de la même manière que si le groupe n’était pas nommé.

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

  Contexte de référence au groupe quote | Manières de le référencer
  --- | ---
  lui-même dans le même motif | `(?P=quote)` (comme vu) `\1`
  en analysant l’objet résultat m | `m.group('quote')` `m.end('quote')` (etc.)
  dans une chaîne passée à l’argument repl de `re.sub()` | `\g<quote>` `\g<1>` `\1`

`(?P=name)`

  Une référence arrière à un groupe nommé ; elle correspond à n’importe quel texte validé plus tôt par le groupe nommé name.

`(?#...)`

  Un commentaire ; le contenu des parenthèses est simplement ignoré.

`(?=...)`

  Valide si `...` valide la suite, mais ne consomme rien de la chaîne. On appelle cela une assertion lookahead. Par exemple, `Isaac (?=Asimov)` correspondra à la chaîne `'Isaac' `` seulement si elle est suivie par ``'Asimov'`.

`(?!...)`

  Valide si `...` ne valide pas la suite. C’est une assertion negative lookahead. Par exemple, `Isaac (?!Asimov)` correspondra à la chaîne `'Isaac '` seulement si elle n’est pas suivie par `'Asimov'`.

`(?<=...)`

  Valide si la position courante dans la chaîne est précédée par une correspondance sur `...` qui se termine à la position courante. On appelle cela une positive lookbehind assertion. `(?<=abc)def` cherchera une correspondance dans `'abcdef'`, puisque le lookbehind* mettra de côté 3 caractères et vérifiera que le motif contenu correspond. Le motif ne devra correspondre qu’à des chaînes de taille fixe, cela veut dire que `abc` ou `a|b` sont autorisées, mais pas ``a*` ou `a{3,4}`. Notez que les motifs qui commencent par des assertions lookbehind positives ne peuvent pas correspondre au début de la chaîne analysée ; vous préférerez sûrement utiliser la fonction `search()` plutôt que la fonction `match()` :

      >>> import re
      >>> m = re.search('(?<=abc)def', 'abcdef')
      >>> m.group(0)
      'def'

  Cet exemple recherche un mot suivi d’un trait d’union :

      >>> m = re.search(r'(?<=-)\w+', 'spam-egg')
      >>> m.group(0)
      'egg'

  Modifié dans la version 3.5: Ajout du support des références aux groupes de taille fixe.

`(?<!...)`

  Valide si la position courante dans la chaîne n’est pas précédée par une correspondance sur `...`. On appelle cela une negative lookbehind assertion. À la manière des assertions lookbehind positives, le motif contenu ne peut que correspondre à des chaînes de taille fixe. Les motifs débutant par une assertion lookbehind négative peuvent correspondre au début de la chaîne analysée.

`(?(id/name)yes-pattern|no-pattern)`

  Essaiera de faire la correspondance avec `yes-pattern` si le groupe indiqué par id ou name existe, et avec `no-pattern` s’il n’existe pas. `no-pattern` est optionnel et peut être omis. Par exemple, `(<)?(\w+@\w+(?:\.\w+)+)(?(1)>|$)` est un motif simpliste pour identifier une adresse courriel, qui validera `'<user@host.com>'` ainsi que `'user@host.com'` mais pas `'<user@host.com'` ni `'user@host.com>'`.

Les séquences spéciales sont composées de `'\'` et d’un caractère de la liste qui suit. Si le caractère ordinaire n’est pas un chiffre ASCII ou une lettre ASCII, alors l’expression rationnelle résultante validera le second caractère de la séquence. Par exemple, `\$` correspond au caractère `'$'`.

`\number`

  Correspond au contenu du groupe du même nombre. Les groupes sont numérotés à partir de 1. Par exemple, `(.+) \1` correspond à `'the the'` ou `'55 55'`, mais pas à `'thethe'` (notez l’espace après le groupe). Cette séquence spéciale ne peut être utilisée que pour faire référence aux 99 premiers groupes. Si le premier chiffre de number est 0, ou si number est un nombre octal de 3 chiffres, il ne sera pas interprété comme une référence à un groupe, mais comme le caractère à la valeur octale number. À l’intérieur des `'['` et `']'` d’une classe de caractères, tous les échappements numériques sont traités comme des caractères.

`\A`

  Correspond uniquement au début d’une chaîne de caractères.

`\b`

  Correspond à la chaîne vide, mais uniquement au début ou à la fin d’un mot. Un mot est défini comme une séquence de « caractères de mots ». Notez que formellement, `\b` est défini comme la liaison entre `\w` et `\W` (et inversement), ou entre `\w` et le début/fin d’un mot. Cela signifie que `r'\bfoo\b'` validera `'foo'`, `'foo.'`, `'(foo)'` ou `'bar foo baz'` mais pas `'foobar'` ou `'foo3'`.

  Les caractères alphanumériques Unicode sont utilisés par défaut dans les motifs Unicode, mais cela peut être changé en utilisant l’option `ASCII`. Les délimitations de mots sont déterminées par la locale si l’option `LOCALE` est utilisée. À l’intérieur d’un intervalle de caractères, `\b` représente le caractère backspace, par compatibilité avec les chaînes littérales Python.

`\B`

  Correspond à la chaîne vide, mais uniquement quand elle n’est pas au début ou à la fin d’un mot. Cela signifie que `r'py\B'` valide `'python'`, `'py3'` ou `'py2'`, mais pas `'py'`, `'py.'` ou `'py!'`. `\B` est simplement l’opposé de `\b`, donc les caractères de mots dans les motifs Unicode sont les alphanumériques et tirets bas Unicode, bien que cela puisse être changé avec l’option `ASCII`. Les délimitations de mots sont déterminées par la locale si l’option `LOCALE` est utilisée.

`\d`
  Pour les motifs Unicode (`str`) :

    Valide n’importe quel chiffre décimal Unicode (soit tout caractère Unicode de catégorie [Nd]). Cela inclue `[0-9]`, mais aussi bien d’autres caractères de chiffres. Si l’option `ASCII` est utilisée, seuls les caractères de la classe `[0-9]` correspondront (mais l’option affectant l’expression rationnelle entière, il peut être préférable dans ce genre de cas d’utiliser un `[0-9]` explicite).

  Pour les motifs 8-bit (bytes) :

    Valide n’importe quel chiffre décimal ; équivalent à `[0-9]`.

`\D`

  Valide tout caractère qui n’est pas un chiffre décimal. C’est l’opposé de `\d`. Si l’option `ASCII` est utilisée, cela devient équivalent à `[^0-9]` (mais l’option affectant l’expression rationnelle entière, il peut être préférable dans ce genre de cas d’utiliser explicitement `[^0-9]`).

`\s`
  Pour les motifs Unicode (`str`) :

    Valide les caractères d’espacement Unicode (qui incluent `[ \t\n\r\f\v]` et bien d’autres, comme les espaces insécables requises par les règles typographiques de beaucoup de langues). Si l’option `ASCII` est utilisée, seuls les caractères de la classe `[ \t\n\r\f\v]` sont validés (mais l’option affectant l’expression rationnelle entière, il peut être préférable dans ce genre de cas d’utiliser un `[ \t\n\r\f\v]` explicite).

  Pour les motifs 8-bit (bytes) :

    Valide les caractères considérés comme des espacements dans la table ASCII ; équivalent à `[ \t\n\r\f\v]`.

`\S`

  Valide tout caractère qui n’est pas un caractère d’espacement. c’est l’opposé de `\s`. Si l’option `ASCII` est utilisée, cela devient équivalent à `[^ \t\n\r\f\v]` (mais l’option affectant l’expression rationnelle entière, il peut être préférable dans ce genre de cas d’utiliser un `[^ \t\n\r\f\v]` explicite).

`\w`
  Pour les motifs Unicode (`str`) :

    Valide les caractères Unicode de mot ; cela inclut la plupart des caractères qui peuvent être compris dans un mot d’une quelconque langue, aussi bien que les nombres et les tirets bas. Si l’option `ASCII` est utilisée, seuls les caractères de la classe `[a-zA-Z0-9_]` sont validés (mais l’option affectant l’expression rationnelle entière, il peut être préférable dans ce genre de cas d’utiliser un `[a-zA-Z0-9_]` explicite).

  Pour les motifs 8-bit (bytes) :

    Valide les caractères alphanumériques de la table ASCII ; équivalent à `[a-zA-Z0-9_]`. Si l’option `LOCALE` est utilisée, les caractères considérés alphanumériques dans la locale et le tiret bas seront acceptés.

`\W`

  Valide tout caractère qui n’est pas un caractère de mot. C’est l’opposé de `\w`. Si l’option `ASCII` est utilisée, cela devient équivalent à `[^a-zA-Z0-9_]` (mais l’option affectant l’expression rationnelle entière, il peut être préférable dans ce genre de cas d’utiliser un `[^a-zA-Z0-9_]` explicite). Si l’option `LOCALE` est utilisée, les caractères considérés alphanumériques dans la locale courrante, et le tiret bas, seront acceptés.

`\Z`

  Correspond uniquement à la fin d’une chaîne de caractères.

La plupart des échappements standards supportés par les chaînes littérales sont aussi acceptés par l’analyseur d’expressions rationnelles :

    \a      \b      \f      \n
    \r      \t      \u      \U
    \v      \x      \\

(Notez que `\b` est utilisé pour représenter les bornes d’un mot, et signifie « backspace » uniquement à l’intérieur d’une classe de caractères.)

Les séquences d’échappement `'\u'` et `'\U'` sont seulement reconnues dans les motifs Unicode. Dans les motifs de byte, ce sont des erreurs.

Les séquences octales d’échappement sont incluses dans une forme limitée. Si le premier chiffre est un 0, ou s’il y a trois chiffres octaux, la séquence est considérée comme octale. Autrement, il s’agit d’une référence vers un groupe. Comme pour les chaînes littérales, les séquences octales ne font jamais plus de 3 caractères de long.

Modifié dans la version 3.3: Les séquences d’échappement `'\u'` et `'\U'` ont été ajoutées.

Modifié dans la version 3.6: Les séquences inconnues composées de `'\'` et d’une lettre ASCII sont maintenant des erreurs.

## 6.2.2. Contenu du module

Le module définit plusieurs fonctions, constantes, et une exception. Certaines fonctions sont des versions simplifiées des méthodes plus complètes des expressions rationnelles compilées. La plupart des applications non triviales utilisent toujours la version compilée.

Modifié dans la version 3.6: Les constantes d’options sont maintenant des instances de `RegexFlag`, sous-classe de `enum.IntFlag`.

`re.``compile`(pattern, flags=0)

  Compile un motif vers une expression rationnelle compilée, dont les méthodes `match()` et `search()`, décrites ci-dessous, peuvent être utilisées pour analyser des textes.

  Le comportement des expressions peut être modifié en spécifiant une valeur flags. Les valeurs sont comprises dans les variables suivantes, et peuvent être combinées avec un ou bit-à-bit (opérateur `|`).

  La séquence

      prog = re.compile(pattern)
      result = prog.match(string)

  est équivalente à

      result = re.match(pattern, string)

  mais utiliser `re.compile()` et sauvegarder l’expression rationnelle renvoyée pour la réutiliser est plus efficace quand l’expression est amenée à être utilisée plusieurs fois dans un même programme.

  Note

  Les versions compilées des motifs les plus récents passés à `re.compile()` et autres fonctions d’analyse du module sont mises en cache, ainsi les programmes qui n’utilisent que quelques expressions rationnelles en même temps n’ont pas à s’inquiéter de la compilation de ces expressions.

`re.``A`
`re.``ASCII`

  Fait correspondre à `\w`, `\W`, `\b`, `\B`, `\d`, `\D`, `\s` et `\s` des caractères ASCII seulement, plutôt qu’Unicode. Cela n’a du sens que pour les motifs Unicode, et est ignoré pour les motifs 8-bit. Correspond à l’option de groupe `(?a)`.

  Notez que par compatibilité envers les versions précédentes, l’option `re.U` existe toujours (ainsi que son synonyme `re.UNICODE` et sa version embarquée `(?u)`), mais elles sont redondantes en Python 3 depuis que l’analyse est faite en Unicode par défaut pour les chaînes de caractères (et que l’analyse Unicode n’est pas permise pour les chaînes 8-bit).

`re.``DEBUG`

  Affiche des informations de débogage à propos de l’expression compilée. N’a pas d’option de groupe équivalente.

`re.``I`
`re.``IGNORECASE`

  Effectue une analyse indépendante de la casse. Les motifs tels que `[A-Z]` accepteront donc les caractères minuscules. L’analyse Unicode complète (tel que `Ü` correspondant à `ü`) fonctionne aussi, tant que l’option `re.ASCII` n’est pas utilisée. La locale n’affecte pas cette option, tant que l’option `re.LOCALE` n’est pas utilisée. Correspond au marqueur de groupe `(?i)`.

  Note that when the Unicode patterns `[a-z]` or `[A-Z]` are used in combination with the `IGNORECASE` flag, they will match the 52 ASCII letters and 4 additional non-ASCII letters: “İ” (U+0130, Latin capital letter I with dot above), “ı” (U+0131, Latin small letter dotless i), “ſ” (U+017F, Latin small letter long s) and “K” (U+212A, Kelvin sign). If the `ASCII` flag is used, only letters “a” to “z” and “A” to “Z” are matched (but the flag affects the entire regular expression, so in such cases using an explicit `(?-i:[a-zA-Z])` may be a better choice).

`re.``L`
`re.``LOCALE`

  Fait dépendre de la locale courante : `\w`, `\W`, `\b`, `\B`, et l’analyse insensible à la casse. Cette option peut être utilisée avec les motifs en bytes. L’utilisation de cette option est déconseillée à cause du mécanisme de locale très peu fiable, et ne gérant qu’une « culture » à la fois, et ne fonctionnant que pour les locales 8-bits. L’analyse Unicode est déjà activée par défaut dans Python 3 pour les motifs Unicode (str), et elle est capable de gérer plusieurs locales et langages. Correspond à l’option de groupe `(?L)`.

  Modifié dans la version 3.6: `re.LOCALE` ne peut être utilisée qu’avec les motifs 8-bit et n’est pas compatible avec `re.ASCII`.

`re.``M`
`re.``MULTILINE`

  Quand spécifiée, le caractère `'^'` correspond au début d’une chaîne et au début d’une ligne (caractère suivant directement le saut de ligne) ; et le caractère `'$'` correspond à la fin d’une chaîne et à la fin d’une ligne (juste avant le saut de ligne). Par défaut, `'^'` correspond uniquement au début de la chaîne, et `'$'` uniquement à la fin de la chaîne, ou immédiatement avant le saut de ligne (s’il y a) à la fin de la chaîne. Correspond à l’option de groupe `(?m)`.

`re.``S`
`re.``DOTALL`

  Fait correspondre tous les caractères possibles à `'.'`, incluant le saut de ligne ; sans cette option, `'.'` correspondrait à tout caractère à l’exception du saut de ligne. Correspond à l’option de groupe `(?s)`.

`re.``X`
`re.``VERBOSE`

  Cette option vous autorise à écrire des expressions rationnelles qui présentent mieux et sont plus lisibles en vous permettant de séparer visuellement les sections logiques du motif et d’ajouter des commentaires. Les caractères d’espacement à l’intérieur du motif sont ignorés, sauf à l’intérieur des classes de caractères ou quand précédés d’un backslash non échappé, ou dans des séquences comme `*?`, `(?:` or `(?P<...>`. Quand une ligne contient un `#` qui n’est pas dans une classe de caractères ou précédé d’un backslash non échappé, tous les caractères depuis le `#` le plus à gauche jusqu’à la fin de la ligne sont ignorés.

  Cela signifie que les deux expressions rationnelles suivantes qui valident un nombre décimal sont fonctionnellement égales :

      a = re.compile(r"""\d +  # the integral part
                         \.    # the decimal point
                         \d *  # some fractional digits""", re.X)
      b = re.compile(r"\d+\.\d*")

  Correspond à l’option de groupe `(?x)`.

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

  Analyse string à la recherche du premier emplacement où l’expression rationnelle pattern trouve une correspondance, et renvoie l”objet de correspondance trouvé. Renvoie `None` si aucune position dans la chaîne ne valide le motif ; notez que cela est différent de trouver une correspondance avec une chaîne vide à un certain endroit de la chaîne.

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

  Si zéro ou plus caractères au début de string correspondent à l’expression rationnelle pattern, renvoie l”objet de correspondance trouvé. Renvoie `None` si la chaîne ne correspond pas au motif ; notez que cela est différent d’une correspondance avec une chaîne vide.

  Notez que même en mode `MULTILINE`, `re.match()` ne validera qu’au début de la chaîne et non au début de chaque ligne.

  Si vous voulez trouver une correspondance n’importe où dans string, utilisez plutôt `search()` (voir aussi search() vs. match()).

`re.``fullmatch`(pattern, string, flags=0)

  Si l’entièreté de la chaîne string correspond à l’expression rationnelle pattern, renvoie l”objet de correspondance trouvé. Renvoie `None` si la chaîne ne correspond pas au motif ; notez que cela est différent d’une correspondance avec une chaîne vide.

  Nouveau dans la version 3.4.

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

  Sépare string selon les occurrences de pattern. Si des parenthèses de capture sont utilisées dans pattern, alors les textes des groupes du motif sont aussi renvoyés comme éléments de la liste résultante. Si maxsplit est différent de zéro, il ne pourra y avoir plus de maxsplit séparations, et le reste de la chaîne sera renvoyé comme le dernier élément de la liste.

      >>> re.split(r'\W+', 'Words, words, words.')
      ['Words', 'words', 'words', '']
      >>> re.split(r'(\W+)', 'Words, words, words.')
      ['Words', ', ', 'words', ', ', 'words', '.', '']
      >>> re.split(r'\W+', 'Words, words, words.', 1)
      ['Words', 'words, words.']
      >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
      ['0', '3', '9']

  S’il y a des groupes de capture dans le séparateur et qu’ils trouvent une correspondance au début de la chaîne, le résultat commencera par une chaîne vide. La même chose se produit pour la fin de la chaîne :

      >>> re.split(r'(\W+)', '...words, words...')
      ['', '...', 'words', ', ', 'words', '...', '']

  De cette manière, les séparateurs sont toujours trouvés aux mêmes indices relatifs dans la liste résultante.

  Note

  `split()` ne sépare actuellement pas une chaîne sur une correspondance vide. Par exemple :

      >>> re.split('x*', 'axbc')
      ['a', 'bc']

  Même si `'x*'` correspond aussi à 0 “x” avant “a”, entre “b” et “c”, et après “c”, ces correspondances sont actuellement ignorées. Le comportement correct (i.e. découper aussi sur les correspondances vides et renvoyer `['', 'a', 'b', 'c', '']`) sera implémenté dans les futures versions de Python, mais comme cela constitue un changement incompatible avec les précédentes, une `FutureWarning` sera levée pendant la transition.

  Les motifs qui ne peuvent correspondre qu’à des chaînes vides ne permettent actuellement pas de découper la chaîne. Puisque cela ne correspond pas au comportement voulu, une `ValueError` sera levée à partir de Python 3.5 :

      >>> re.split("^$", "foo\n\nbar\n", flags=re.M)
      Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
        ...
      ValueError: split() requires a non-empty pattern match.

  Modifié dans la version 3.1: Ajout de l’argument optionnel flags.

  Modifié dans la version 3.5: Découper sur un motif qui peut correspondre à une chaîne vide lève maintenant un avertissement. Les motifs qui ne peuvent correspondre qu’à des chaînes vides sont maintenant rejetés.

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

  Renvoie toutes les correspondances de pattern dans string qui ne se chevauchent pas, sous forme d’une liste de chaînes. Le chaîne string est analysée de la gauche vers la droite, et les correspondances sont renvoyées dans l’ordre où elles sont trouvées. Si un groupe ou plus sont présents dans le motif, renvoie une liste de groupes ; il s’agira d’une liste de tuples si le motif a plus d’un groupe. Les correspondances vides sont incluses dans le résultat.

  Note

  Due to the limitation of the current implementation the character following an empty match is not included in a next match, so `findall(r'^|\w+', 'two words')` returns `['', 'wo', 'words']` (note missed « t »). This is changed in Python 3.7.

`re.``finditer`(pattern, string, flags=0)

  Renvoie un iterator produisant des objets de correspondance pour toutes les correspondances non chevauchantes de l’expression rationnelle pattern sur la chaîne string. string est analysée de la gauche vers la droite, et les correspondances sont renvoyées dans l’ordre où elles sont trouvées. Les correspondances vides sont inclues dans le résultat. Consultez la note à propos de `findall()`.

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

  Renvoie la chaîne obtenue en remplaçant les occurrences (sans chevauchement) les plus à gauche de pattern dans string par le remplacement repl. Si le motif n’est pas trouvé, string est renvoyée inchangée. repl peut être une chaîne de caractères ou une fonction ; si c’est une chaîne, toutes les séquences d’échappement qu’elle contient sont traduites. Ainsi, `\n` est convertie en un simple saut de ligne, `\r` en un retour chariot, et ainsi de suite. Les séquences inconnues telles que `\&` sont laissées intactes. Les références arrières, telles que `\6`, sont remplacées par la sous-chaîne correspondant au groupe 6 dans le motif. Par exemple :

      >>> re.sub(r'def\s+([a-zA-Z_][a-zA-Z_0-9]*)\s*\(\s*\):',
      ...        r'static PyObject*\npy_\1(void)\n{',
      ...        'def myfunc():')
      'static PyObject*\npy_myfunc(void)\n{'

  Si repl est une fonction, elle est appelée pour chaque occurrence non chevauchante de pattern. La fonction prend comme argument un objet de correspondance, et renvoie la chaîne de remplacement. Par exemple :

      >>> def dashrepl(matchobj):
      ...     if matchobj.group(0) == '-': return ' '
      ...     else: return '-'
      >>> re.sub('-{1,2}', dashrepl, 'pro----gram-files')
      'pro--gram files'
      >>> re.sub(r'\sAND\s', ' & ', 'Baked Beans And Spam', flags=re.IGNORECASE)
      'Baked Beans & Spam'

  Le motif peut être une chaîne de caractères ou un objet expression rationnelle.

  L’argument optionnel count est le nombre maximum d’occurrences du motif à remplacer : count ne doit pas être un nombre négatif. Si omis ou nul, toutes les occurrences seront remplacées. Les correspondances vides avec le motif sont remplacées uniquement quand elles ne sont pas adjacentes à une précédente correspondance, ainsi `sub('x*', '-', 'abc')` renvoie `'-a-b-c-'`.

  Dans les arguments repl de type string, en plus des séquences d’échappement et références arrières décrites au-dessus, `\g<name>` utilisera la sous-chaîne correspondant au groupe nommé `name`, comme défini par la syntaxe `(?P<name>...)`. `\g<number>` utilise le groupe numéroté associé ; `\g<2>` est ainsi équivalent à `\2`, mais n’est pas ambigu dans un remplacement tel que `\g<2>0`, `\20` serait interprété comme une référence au groupe 20, et non une référence au groupe 2 suivie par un caractère littéral `'0'`. La référence arrière `\g<0>` est remplacée par la sous-chaîne entière validée par l’expression rationnelle.

  Modifié dans la version 3.1: Ajout de l’argument optionnel flags.

  Modifié dans la version 3.5: Les groupes sans correspondance sont remplacés par une chaîne vide.

  Modifié dans la version 3.6: Les séquences d’échappement inconnues dans pattern formées par `'\'` et une lettre ASCII sont maintenant des erreurs.

  Deprecated since version 3.5, will be removed in version 3.7: Les séquences d’échappement dans repl formées d’un `'\'` et d’une lettre ASCII lèvent maintenant un avertissement de dépréciation et seront interdites en Python 3.7.

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

  Réalise la même opération que `sub()`, mais renvoie un tuple `(nouvelle_chaîne, nombre_de_substitutions_réalisées)`.

  Modifié dans la version 3.1: Ajout de l’argument optionnel flags.

  Modifié dans la version 3.5: Les groupes sans correspondance sont remplacés par une chaîne vide.

`re.``escape`(pattern)

  Échappe tous les caractères de pattern à l’exception des lettres ASCII, des nombres et de `'_'`. Cela est utile si vous voulez valider une quelconque chaîne littérale qui pourrait contenir des métacaractères d’expressions rationnelles. Par exemple :

      >>> print(re.escape('python.exe'))
      python\.exe

      >>> legal_chars = string.ascii_lowercase + string.digits + "!#$%&'*+-.^_`|~:"
      >>> print('[%s]+' % re.escape(legal_chars))
      [abcdefghijklmnopqrstuvwxyz0123456789\!\#\$\%\&\'\*\+\-\.\^_\`\|\~\:]+

      >>> operators = ['+', '-', '*', '/', '**']
      >>> print('|'.join(map(re.escape, sorted(operators, reverse=True))))
      \/|\-|\+|\*\*|\*

  Ces fonctions ne doivent pas être utilisées pour la chaîne de remplacement dans `sub()` et `subn()`, seuls les antislash devraient être échappés. Par exemple :

      >>> digits_re = r'\d+'
      >>> sample = '/usr/sbin/sendmail - 0 errors, 12 warnings'
      >>> print(re.sub(digits_re, digits_re.replace('\\', r'\\'), sample))
      /usr/sbin/sendmail - \d+ errors, \d+ warnings

  Modifié dans la version 3.3: Le caractère `'_'` n’est plus échappé.

`re.``purge`()

  Vide le cache d’expressions rationnelles.

exception `re.``error`(msg, pattern=None, pos=None)

  Exception levée quand une chaîne passée à l’une des fonctions ici présentes n’est pas une expression rationnelle valide (contenant par exemple une parenthèse non fermée) ou quand d’autres erreurs se produisent durant la compilation ou l’analyse. Il ne se produit jamais d’erreur si une chaîne ne contient aucune correspondance pour un motif. Les instances de l’erreur ont les attributs additionnels suivants :

  `msg`

    Le message d’erreur non formaté.

  `pattern`

    Le motif d’expression rationnelle.

  `pos`

    L’index dans pattern où la compilation a échoué (peut valoir `None`).

  `lineno`

    La ligne correspondant à pos (peut valoir `None`).

  `colno`

    La colonne correspondant à pos (peut valoir `None`).

  Modifié dans la version 3.5: Ajout des attributs additionnels.

## 6.2.3. Objets d’expressions rationnelles

Les expressions rationnelles compilées supportent les méthodes et attributs suivants :

`regex.``search`(string[, pos[, endpos]])

  Analyse string à la recherche du premier emplacement où l’expression rationnelle trouve une correspondance, et envoie l”objet de correspondance trouvé. Renvoie `None` si aucune position dans la chaîne ne satisfait le motif ; notez que cela est différent que de trouver une correspondance vide dans la chaîne.

  Le second paramètre pos (optionnel) donne l’index dans la chaîne où la recherche doit débuter ; il vaut `0` par défaut. Cela n’est pas complètement équivalent à un slicing sur la chaîne ; le caractère de motif `'^'` correspond au début réel de la chaîne et aux positions juste après un saut de ligne, mais pas nécessairement à l’index où la recherche commence.

  Le paramètre optionnel endpos limite la longueur sur laquelle la chaîne sera analysée ; ce sera comme si la chaîne faisait endpos caractères de long, donc uniquement les caractères de pos à `endpos - 1` seront analysés pour trouver une correspondance. Si endpos est inférieur à pos, aucune correspondance ne sera trouvée ; dit autrement, avec rx une expression rationnelle compilée, `rx.search(string, 0, 50)` est équivalent à `rx.search(string[:50], 0)`.

      >>> pattern = re.compile("d")
      >>> pattern.search("dog")     # Match at index 0
      <_sre.SRE_Match object; span=(0, 1), match='d'>
      >>> pattern.search("dog", 1)  # No match; search doesn't include the "d"

`regex.``match`(string[, pos[, endpos]])

  Si zéro caractère ou plus au début de string correspondent à cette expression rationnelle, renvoie l”objet de correspondance trouvé. Renvoie `None` si la chaîne ne correspond pas au motif ; notez que cela est différent d’une correspondance vide.

  Les paramètres optionnels pos et endpos ont le même sens que pour la méthode `search()`.

      >>> pattern = re.compile("o")
      >>> pattern.match("dog")      # No match as "o" is not at the start of "dog".
      >>> pattern.match("dog", 1)   # Match as "o" is the 2nd character of "dog".
      <_sre.SRE_Match object; span=(1, 2), match='o'>

  Si vous voulez une recherche n’importe où dans string, utilisez plutôt `search()` (voir aussi search() vs. match()).

`regex.``fullmatch`(string[, pos[, endpos]])

  Si la chaîne string entière valide l’expression rationnelle, renvoie l”object de correspondance associé. Renvoie `None` si la chaîne ne correspond pas au motif ; notez que cela est différent d’une correspondance vide.

  Les paramètres optionnels pos et endpos ont le même sens que pour la méthode `search()`.

      >>> pattern = re.compile("o[gh]")
      >>> pattern.fullmatch("dog")      # No match as "o" is not at the start of "dog".
      >>> pattern.fullmatch("ogre")     # No match as not the full string matches.
      >>> pattern.fullmatch("doggie", 1, 3)   # Matches within given limits.
      <_sre.SRE_Match object; span=(1, 3), match='og'>

  Nouveau dans la version 3.4.

`regex.``split`(string, maxsplit=0)

  Identique à la fonction `split()`, en utilisant le motif compilé.

`regex.``findall`(string[, pos[, endpos]])

  Similaire à la fonction `findall()`, en utilisant le motif compilé, mais accepte aussi des paramètres pos et endpos optionnels qui limitent la région de recherche comme pour `search()`.

`regex.``finditer`(string[, pos[, endpos]])

  Similaire à la fonction `finditer()`, en utilisant le motif compilé, mais accepte aussi des paramètres pos et endpos optionnels qui limitent la région de recherche comme pour `search()`.

`regex.``sub`(repl, string, count=0)

  Identique à la fonction `sub()`, en utilisant le motif compilé.

`regex.``subn`(repl, string, count=0)

  Identique à la fonction `subn()`, en utilisant le motif compilé.

`regex.``flags`

  Les options de validation de l’expression rationnelle. Il s’agit d’une combinaison des options données à `compile()`, des potentielles options `(?...)` dans le motif, et des options implicites comme `UNICODE` si le motif est une chaîne Unicode.

`regex.``groups`

  Le nombre de groupes de capture dans le motif.

`regex.``groupindex`

  Un dictionnaire associant les noms de groupes symboliques définis par `(?P<id>)` aux groupes numérotés. Le dictionnaire est vide si aucun groupe symbolique n’est utilisé dans le motif.

`regex.``pattern`

  La chaîne de motif depuis laquelle l’objet expression rationnelle a été compilé.

## 6.2.4. Objets de correspondance

Les objets de correspondance ont toujours une valeur booléenne `True`. Puisque `match()` et `search()` renvoient `None` quand il n’y a pas de correspondance, vous pouvez tester s’il y a eu correspondance avec une simple instruction `if` :

    match = re.search(pattern, string)
    if match:
        process(match)

Les objets de correspondance supportent les méthodes et attributs suivants :

`match.``expand`(template)

  Renvoie la chaîne obtenue en substituant les séquences d’échappement du gabarit template, comme réalisé par la méthode `sub()`. Les séquences comme `\n` sont converties vers les caractères appropriés, et les références arrières numériques (`\1`, `\2`) et nommées (`\g<1>`, `\g<name>`) sont remplacées par les contenus des groupes correspondant.

  Modifié dans la version 3.5: Les groupes sans correspondance sont remplacés par une chaîne vide.

`match.``group`([group1, ...])

  Renvoie un ou plus sous-groupes de la correspondance. Si un seul argument est donné, le résultat est une chaîne simple ; s’il y a plusieurs arguments, le résultat est un tuple comprenant un élément par argument. Sans arguments, group1 vaut par défaut zéro (la correspondance entière est renvoyée). Si un argument groupN vaut zéro, l’élément associé sera la chaîne de correspondance entière ; s’il est dans l’intervalle fermé [1..99], c’est la correspondance avec le groupe de parenthèses associé. Si un numéro de groupe est négatif ou supérieur au nombre de groupes définis dans le motif, une exception `indexError` est levée. Si un groupe est contenu dans une partie du motif qui n’a aucune correspondance, l’élément associé sera `None`. Si un groupe est contenu dans une partie du motif qui a plusieurs correspondances, seule la dernière correspondance est renvoyée.

      >>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")
      >>> m.group(0)       # The entire match
      'Isaac Newton'
      >>> m.group(1)       # The first parenthesized subgroup.
      'Isaac'
      >>> m.group(2)       # The second parenthesized subgroup.
      'Newton'
      >>> m.group(1, 2)    # Multiple arguments give us a tuple.
      ('Isaac', 'Newton')

  Si l’expression rationnelle utilise la syntaxe `(?P<name>...)`, les arguments groupN peuvent alors aussi être des chaînes identifiant les groupes par leurs noms. Si une chaîne donnée en argument n’est pas utilisée comme nom de groupe dans le motif, une exception `IndexError` est levée.

  Un exemple modérément compliqué :

      >>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
      >>> m.group('first_name')
      'Malcolm'
      >>> m.group('last_name')
      'Reynolds'

  Les groupes nommés peuvent aussi être référencés par leur index :

      >>> m.group(1)
      'Malcolm'
      >>> m.group(2)
      'Reynolds'

  Si un groupe a plusieurs correspondances, seule la dernière est accessible :

      >>> m = re.match(r"(..)+", "a1b2c3")  # Matches 3 times.
      >>> m.group(1)                        # Returns only the last match.
      'c3'

`match.``__getitem__`(g)

  Cela est identique à `m.group(g)`. Cela permet un accès plus facile à un groupe individuel depuis une correspondance :

      >>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")
      >>> m[0]       # The entire match
      'Isaac Newton'
      >>> m[1]       # The first parenthesized subgroup.
      'Isaac'
      >>> m[2]       # The second parenthesized subgroup.
      'Newton'

  Nouveau dans la version 3.6.

`match.``groups`(default=None)

  Renvoie un tuple contenant tous les sous-groupes de la correspondance, de 1 jusqu’au nombre de groupes dans le motif. L’argument default est utilisé pour les groupes sans correspondance ; il vaut `None` par défaut.

  Par exemple :

      >>> m = re.match(r"(\d+)\.(\d+)", "24.1632")
      >>> m.groups()
      ('24', '1632')

  Si on rend la partie décimale et tout ce qui la suit optionnels, tous les groupes ne figureront pas dans la correspondance. Ces groupes sans correspondance vaudront `None` sauf si une autre valeur est donnée à l’argument default :

      >>> m = re.match(r"(\d+)\.?(\d+)?", "24")
      >>> m.groups()      # Second group defaults to None.
      ('24', None)
      >>> m.groups('0')   # Now, the second group defaults to '0'.
      ('24', '0')

`match.``groupdict`(default=None)

  Renvoie un dictionnaire contenant tous les sous-groupes nommés de la correspondance, accessibles par leurs noms. L’argument default est utilisé pour les groupes qui ne figurent pas dans la correspondance ; il vaut `None` par défaut. Par exemple :

      >>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
      >>> m.groupdict()
      {'first_name': 'Malcolm', 'last_name': 'Reynolds'}

`match.``start`([group])
`match.``end`([group])

  Renvoie les indices de début et de fin de la sous-chaîne correspondant au groupe group ; group vaut par défaut zéro (pour récupérer les indices de la correspondance complète). Renvoie `-1` si group existe mais ne figure pas dans la correspondance. Pour un objet de correspondance m, et un groupe g qui y figure, la sous-chaîne correspondant au groupe g (équivalente à `m.group(g)`) est

      m.string[m.start(g):m.end(g)]

  Notez que `m.start(group)` sera égal à `m.end(group)` si group correspond à une chaîne vide. Par exemple, après `m = re.search('b(c?)', 'cba')`, `m.start(0)` vaut 1, `m.end(0)` vaut 2, `m.start(1)` et `m.end(1)` valent tous deux 2, et `m.start(2)` lève une exception `IndexError`.

  Un exemple qui supprimera remove_this d’une adresse mail :

      >>> email = "tony@tiremove_thisger.net"
      >>> m = re.search("remove_this", email)
      >>> email[:m.start()] + email[m.end():]
      'tony@tiger.net'

`match.``span`([group])

  Pour un objet de correspondance m, renvoie le tuple `(m.start(group), m.end(group))`. Notez que si group ne figure pas dans la correspondance, `(-1, -1)` est renvoyé. group vaut par défaut zéro, pour la correspondance entière.

`match.``pos`

  La valeur de pos qui a été passée à la méthode `search()` ou `match()` d’un objet expression rationnelle. C’est l’index dans la chaîne à partir duquel le moteur d’expressions rationnelles recherche une correspondance.

`match.``endpos`

  La valeur de endpos qui a été passée à la méthode `search()` ou `match()` d’un objet expression rationnelle. C’est l’index dans la chaîne que le moteur d’expressions rationnelles ne dépassera pas.

`match.``lastindex`

  L’index entier du dernier groupe de capture validé, ou `None` si aucun groupe ne correspondait. Par exemple, les expressions `(a)b`, `((a)(b))` et `((ab))` auront un `lastindex == 1` si appliquées à la chaîne `'ab'`, alors que l’expression `(a)(b)` aura un `lastindex == 2` si appliquée à la même chaîne.

`match.``lastgroup`

  Le nom du dernier groupe capturant validé, ou `None` si le groupe n’a pas de nom, ou si aucun groupe ne correspondait.

`match.``re`

  L’expression rationnelle dont la méthode `match()` ou `search()` a produit cet objet de correspondance.

`match.``string`

  La chaîne passée à `match()` ou `search()`.

## 6.2.5. Exemples d’expressions rationnelles

### 6.2.5.1. Rechercher une paire

Dans cet exemple, nous utiliserons cette fonction de facilité pour afficher les objets de correspondance sous une meilleure forme :

    def displaymatch(match):
        if match is None:
            return None
        return '<Match: %r, groups=%r>' % (match.group(), match.groups())

Supposez que vous écriviez un jeu de poker où la main d’un joueur est représentée par une chaîne de 5 caractères avec chaque caractère représentant une carte, « a » pour l’as, « k » pour le roi (king), « q » pour la reine (queen), « j » pour le valet (jack), « t » pour 10 (ten), et les caractères de « 2 » à « 9 » représentant les cartes avec ces valeurs.

Pour vérifier qu’une chaîne donnée est une main valide, on pourrait faire comme suit :

    >>> valid = re.compile(r"^[a2-9tjqk]{5}$")
    >>> displaymatch(valid.match("akt5q"))  # Valid.
    "<Match: 'akt5q', groups=()>"
    >>> displaymatch(valid.match("akt5e"))  # Invalid.
    >>> displaymatch(valid.match("akt"))    # Invalid.
    >>> displaymatch(valid.match("727ak"))  # Valid.
    "<Match: '727ak', groups=()>"

La dernière main, `"727ak"`, contenait une paire, deux cartes de la même valeur. Pour valider cela avec une expression rationnelle, on pourrait utiliser des références arrière comme :

    >>> pair = re.compile(r".*(.).*\1")
    >>> displaymatch(pair.match("717ak"))     # Pair of 7s.
    "<Match: '717', groups=('7',)>"
    >>> displaymatch(pair.match("718ak"))     # No pairs.
    >>> displaymatch(pair.match("354aa"))     # Pair of aces.
    "<Match: '354aa', groups=('a',)>"

Pour trouver de quelle carte est composée la paire, on pourrait utiliser la méthode `group()` de l’objet de correspondance de la manière suivante :

    >>> pair.match("717ak").group(1)
    '7'

    # Error because re.match() returns None, which doesn't have a group() method:
    >>> pair.match("718ak").group(1)
    Traceback (most recent call last):
      File "<pyshell#23>", line 1, in <module>
        re.match(r".*(.).*\1", "718ak").group(1)
    AttributeError: 'NoneType' object has no attribute 'group'

    >>> pair.match("354aa").group(1)
    'a'

### 6.2.5.2. Simuler scanf()

Python n’a actuellement pas d’équivalent à la fonction C `scanf()`. Les expressions rationnelles sont généralement plus puissantes, mais aussi plus verbeuses, que les chaînes de format `scanf()`. Le tableau suivant présente des expressions rationnelles plus ou moins équivalentes aux éléments de formats de `scanf()`.

Élément de `scanf()` | Expression rationnelle
--- | ---
`%c` | `.`
`%5c` | `.{5}`
`%d` | `[-+]?\d+`
`%e`, `%E`, `%f`, `%g` | `[-+]?(\d+(\.\d*)?|\.\d+)([eE][-+]?\d+)?`
`%i` | `[-+]?(0[xX][\dA-Fa-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 les nombres depuis une chaîne comme

    /usr/sbin/sendmail - 0 errors, 4 warnings

vous utiliseriez un format `scanf()` comme

    %s - %d errors, %d warnings

L’expression rationnelle équivalente serait

    (\S+) - (\d+) errors, (\d+) warnings

### 6.2.5.3. search() vs. match()

Python offre deux opérations primitives basées sur les expressions rationnelles : `re.match()` cherche une correspondance uniquement au début de la chaîne, tandis que `re.search()` en recherche une n’importe où dans la chaîne (ce que fait Perl par défaut).

Par exemple :

    >>> re.match("c", "abcdef")    # No match
    >>> re.search("c", "abcdef")   # Match
    <_sre.SRE_Match object; span=(2, 3), match='c'>

Les expressions rationnelles commençant par `'^'` peuvent être utilisées avec `search()` pour restreindre la recherche au début de la chaîne :

    >>> re.match("c", "abcdef")    # No match
    >>> re.search("^c", "abcdef")  # No match
    >>> re.search("^a", "abcdef")  # Match
    <_sre.SRE_Match object; span=(0, 1), match='a'>

Notez cependant qu’en mode `MULTILINE`, `match()` ne recherche qu’au début de la chaîne, alors que `search()` avec une expression rationnelle commençant par `'^'` recherchera au début de chaque ligne.

    >>> re.match('X', 'A\nB\nX', re.MULTILINE)  # No match
    >>> re.search('^X', 'A\nB\nX', re.MULTILINE)  # Match
    <_sre.SRE_Match object; span=(4, 5), match='X'>

### 6.2.5.4. Construire un répertoire téléphonique

`split()` découpe une chaîne en une liste délimitée par le motif donné. La méthode est inestimable pour convertir des données textuelles vers des structures de données qui peuvent être lues et modifiées par Python comme démontré dans l’exemple suivant qui crée un répertoire téléphonique.

Premièrement, voici l’entrée. Elle provient normalement d’un fichier, nous utilisons ici une chaîne à guillemets triples :

    >>> text = """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"""

Les entrées sont séparées par un saut de ligne ou plus. Nous convertissons maintenant la chaîne en une liste où chaque ligne non vide aura sa propre entrée :

    >>> entries = re.split("\n+", text)
    >>> entries
    ['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']

Finalement, on sépare chaque entrée en une liste avec prénom, nom, numéro de téléphone et adresse. Nous utilisons le paramètre `maxsplit` de `split()` parce que l’adresse contient des espaces, qui sont notre motif de séparation :

    >>> [re.split(":? ", entry, 3) for entry in entries]
    [['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']]

Le motif `:?` trouve les deux points derrière le nom de famille, pour qu’ils n’apparaissent pas dans la liste résultante. Avec un `maxsplit` de `4`, nous pourrions séparer le numéro du nom de la rue :

    >>> [re.split(":? ", entry, 4) for entry in entries]
    [['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']]

### 6.2.5.5. Mélanger les lettres des mots

`sub()` remplace toutes les occurrences d’un motif par une chaîne ou le résultat d’une fonction. Cet exemple le montre, en utilisant `sub()` avec une fonction qui mélange aléatoirement les caractères de chaque mot dans une phrase (à l’exception des premiers et derniers 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, please report your absences promptly."
    >>> re.sub(r"(\w)(\w+)(\w)", repl, text)
    'Poefsrosr Aealmlobdk, pslaee reorpt your abnseces plmrptoy.'
    >>> re.sub(r"(\w)(\w+)(\w)", repl, text)
    'Pofsroser Aodlambelk, plasee reoprt yuor asnebces potlmrpy.'

### 6.2.5.6. Trouver tous les adverbes

`findall()` matches all occurrences of a pattern, not just the first one as `search()` does. For example, if a writer wanted to find all of the adverbs in some text, they might use `findall()` in the following manner:

    >>> text = "He was carefully disguised but captured quickly by police."
    >>> re.findall(r"\w+ly", text)
    ['carefully', 'quickly']

### 6.2.5.7. Trouver tous les adverbes et leurs positions

If one wants more information about all matches of a pattern than the matched text, `finditer()` is useful as it provides match objects instead of strings. Continuing with the previous example, if a writer wanted to find all of the adverbs and their positions in some text, they would use `finditer()` in the following manner:

    >>> text = "He was carefully disguised but captured quickly by police."
    >>> for m in re.finditer(r"\w+ly", text):
    ...     print('%02d-%02d: %s' % (m.start(), m.end(), m.group(0)))
    07-16: carefully
    40-47: quickly

### 6.2.5.8. Notation brutes de chaînes

La notation brute de chaînes (`r"text"`) garde saines les expressions rationnelles. Sans elle, chaque backslash (`'\'`) dans une expression rationnelle devrait être préfixé d’un autre backslash pour l’échapper. Par exemple, les deux lignes de code suivantes sont fonctionnellement identiques :

    >>> re.match(r"\W(.)\1\W", " ff ")
    <_sre.SRE_Match object; span=(0, 4), match=' ff '>
    >>> re.match("\\W(.)\\1\\W", " ff ")
    <_sre.SRE_Match object; span=(0, 4), match=' ff '>

Pour rechercher un backslash littéral, il faut l’échapper dans l’expression rationnelle. Avec la notation brute, cela signifie `r"\\"`. Sans elle, il faudrait utiliser `"\\\\"`, faisant que les deux lignes de code suivantes sont fonctionnellement identiques :

    >>> re.match(r"\\", r"\\")
    <_sre.SRE_Match object; span=(0, 1), match='\\'>
    >>> re.match("\\\\", r"\\")
    <_sre.SRE_Match object; span=(0, 1), match='\\'>

### 6.2.5.9. Écrire un analyseur lexical

Un analyseur lexical ou scanner analyse une chaîne pour catégoriser les groupes de caractères. C’est une première étape utile dans l’écriture d’un compilateur ou d’un interpréteur.

Les catégories de texte sont spécifiées par des expressions rationnelles. La technique est de les combiner dans une unique expression rationnelle maîtresse, et de boucler sur les correspondances successives :

    import collections
    import re

    Token = collections.namedtuple('Token', ['type', 'value', 'line', 'column'])

    def tokenize(code):
        keywords = {'IF', 'THEN', 'ENDIF', 'FOR', 'NEXT', 'GOSUB', 'RETURN'}
        token_specification = [
            ('NUMBER',   r'\d+(\.\d*)?'),  # Integer or decimal number
            ('ASSIGN',   r':='),           # Assignment operator
            ('END',      r';'),            # Statement terminator
            ('ID',       r'[A-Za-z]+'),    # Identifiers
            ('OP',       r'[+\-*/]'),      # Arithmetic operators
            ('NEWLINE',  r'\n'),           # Line endings
            ('SKIP',     r'[ \t]+'),       # Skip over spaces and tabs
            ('MISMATCH', r'.'),            # Any other character
        ]
        tok_regex = '|'.join('(?P<%s>%s)' % pair for pair in token_specification)
        line_num = 1
        line_start = 0
        for mo in re.finditer(tok_regex, code):
            kind = mo.lastgroup
            value = mo.group()
            column = mo.start() - line_start
            if kind == 'NUMBER':
                value = float(value) if '.' in value else int(value)
            elif kind == 'ID' and value in keywords:
                kind = value
            elif kind == 'NEWLINE':
                line_start = mo.end()
                line_num += 1
                continue
            elif kind == 'SKIP':
                continue
            elif kind == 'MISMATCH':
                raise RuntimeError(f'{value!r} unexpected on line {line_num}')
            yield Token(kind, value, line_num, column)

    statements = '''
        IF quantity THEN
            total := total + price * quantity;
            tax := price * 0.05;
        ENDIF;
    '''

    for token in tokenize(statements):
        print(token)

L’analyseur produit la sortie suivante :

    Token(type='IF', value='IF', line=2, column=4)
    Token(type='ID', value='quantity', line=2, column=7)
    Token(type='THEN', value='THEN', line=2, column=16)
    Token(type='ID', value='total', line=3, column=8)
    Token(type='ASSIGN', value=':=', line=3, column=14)
    Token(type='ID', value='total', line=3, column=17)
    Token(type='OP', value='+', line=3, column=23)
    Token(type='ID', value='price', line=3, column=25)
    Token(type='OP', value='*', line=3, column=31)
    Token(type='ID', value='quantity', line=3, column=33)
    Token(type='END', value=';', line=3, column=41)
    Token(type='ID', value='tax', line=4, column=8)
    Token(type='ASSIGN', value=':=', line=4, column=12)
    Token(type='ID', value='price', line=4, column=15)
    Token(type='OP', value='*', line=4, column=21)
    Token(type='NUMBER', value=0.05, line=4, column=23)
    Token(type='END', value=';', line=4, column=27)
    Token(type='ENDIF', value='ENDIF', line=5, column=4)
    Token(type='END', value=';', line=5, column=9)

Frie09

  Friedl, Jeffrey. Mastering Regular Expressions. 3rd ed., O’Reilly Media, 2009. La troisième édition de ce livre ne couvre plus du tout Python, mais la première version explique en détails comment écrire de bonnes expressions rationnelles.