# `re` --- Regular expression operations

Code source : Lib/re/

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

Both patterns and strings to be searched can be Unicode strings (`str`) as well as 8-bit strings (`bytes`). However, Unicode strings and 8-bit strings cannot be mixed: that is, you cannot match a Unicode string with a bytes pattern or vice-versa; similarly, when asking for a substitution, the replacement string must be of the same type as both the pattern and the search string.

Regular expressions use the backslash character (`'\'`) to indicate special forms or to allow special characters to be used without invoking their special meaning. This collides with Python's usage of the same character for the same purpose in string literals; for example, to match a literal backslash, one might have to write `'\\\\'` as the pattern string, because the regular expression must be `\\`, and each backslash must be expressed as `\\` inside a regular Python string literal. Also, please note that any invalid escape sequences in Python's usage of the backslash in string literals now generate a `SyntaxWarning` and in the future this will become a `SyntaxError`. This behaviour will happen even if it is a valid escape sequence for a regular expression.

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

The third-party regex module, which has an API compatible with the standard library `re` module, but offers additional functionality and a more thorough Unicode support.

## Regular expression syntax

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 Regular expression HOWTO.

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 ou quantificateurs (`*`, `+`, `?`, `{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 :

`.`

  (Dot.) In the default mode, this matches any character except a newline. If the `DOTALL` flag has been specified, this matches any character including a newline. `(?s:.)` matches any character regardless of flags.

`^`

  (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 quantificateurs `'*'`, `'+'` 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 quantificateur 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>'`.

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

  Like the `'*'`, `'+'`, and `'?'` quantifiers, those where `'+'` is appended also match as many times as possible. However, unlike the true greedy quantifiers, these do not allow back-tracking when the expression following it fails to match. These are known as possessive quantifiers. For example, `a*a` will match `'aaaa'` because the `a*` will match all 4 `'a'`s, but, when the final `'a'` is encountered, the expression is backtracked so that in the end the `a*` ends up matching 3 `'a'`s total, and the fourth `'a'` is matched by the final `'a'`. However, when `a*+a` is used to match `'aaaa'`, the `a*+` will match all 4 `'a'`, but when the final `'a'` fails to find any more characters to match, the expression cannot be backtracked and will thus fail to match. `x*+`, `x++` and `x?+` are equivalent to `(?>x*)`, `(?>x+)` and `(?>x?)` correspondingly.

  Ajouté dans la version 3.11.

`{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 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 quantificateur. 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.

`{m,n}+`

  Causes the resulting RE to match from m to n repetitions of the preceding RE, attempting to match as many repetitions as possible without establishing any backtracking points. This is the possessive version of the quantifier above. For example, on the 6-character string `'aaaaaa'`, `a{3,5}+aa` attempts to match 5 `'a'` characters, then, requiring 2 more `'a'`s, will need more characters than available and thus fail, while `a{3,5}aa` will match with `a{3,5}` capturing 5, then 4 `'a'`s by backtracking and then the final 2 `'a'`s are matched by the final `aa` in the pattern. `x{m,n}+` is equivalent to `(?>x{m,n})`.

  Ajouté dans la version 3.11.

`\`

  É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.

  - Special characters except backslash lose their special meaning inside sets. For example, `[(+*)]` will match any of the literal characters `'('`, `'+'`, `'*'`, or `')'`.

  - Backslash either escapes characters which have special meaning in a set such as `'-'`, `']'`, `'^'` and `'\\'` itself or signals a special sequence which represents a single character such as `\xa0` or `\n` or a character class such as `\w` or `\S` (defined below). Note that `\b` represents a single "backspace" character, not a word boundary as outside a set, and numeric escapes such as `\1` are always octal escapes, not group references. Special sequences which do not match a single character such as `\A` and `\z` are not allowed.

  - 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.

  - To match a literal `']'` inside a set, precede it with a backslash, or place it at the beginning of the set. For example, both `[()[\]{}]` and `[]()[{}]` will match a right bracket, as well as left bracket, braces, and parentheses.

  - La gestion des ensembles inclus l'un dans l'autre et les opérations d'ensemble comme dans Unicode Technical Standard #18 pourrait être ajoutée par la suite. Ceci changerait la syntaxe, donc pour faciliter ce changement, une exception `FutureWarning` sera levée dans les cas ambigus pour le moment. Ceci inclut les ensembles commençant avec le caractère `'['` ou contenant les séquences de caractères `'--'`, `'&&'`, `'~~'` et `'||'`. Pour éviter un message d'avertissement, échapper les séquences avec le caractère antislash (`"\"`).

  Modifié dans la version 3.7: L'exception `FutureWarning` est levée si un ensemble de caractères contient une construction dont la sémantique changera dans le futur.

`|`

  `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)`

  (One or more letters from the set `'a'`, `'i'`, `'L'`, `'m'`, `'s'`, `'u'`, `'x'`.) The group matches the empty string; the letters set the corresponding flags for the entire regular expression:

  - `re.A` (ASCII-only matching)

  - `re.I` (ignore case)

  - `re.L` (locale dependent)

  - `re.M` (multi-line)

  - `re.S` (dot matches all)

  - `re.U` (Unicode matching)

  - `re.X` (verbose)

  (The flags are described in Module contents.) This is useful if you wish to include the flags as part of the regular expression, instead of passing a flag argument to the `re.compile()` function. Flags should be used first in the expression string.

  Modifié dans la version 3.11: Cette construction ne peut être utilisée qu'au début d'une chaîne de caractères.

`(?:...)`

  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.

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

  (Zero or more letters from the set `'a'`, `'i'`, `'L'`, `'m'`, `'s'`, `'u'`, `'x'`, optionally followed by `'-'` followed by one or more letters from the `'i'`, `'m'`, `'s'`, `'x'`.) The letters set or remove the corresponding flags for the part of the expression:

  - `re.A` (ASCII-only matching)

  - `re.I` (ignore case)

  - `re.L` (locale dependent)

  - `re.M` (multi-line)

  - `re.S` (dot matches all)

  - `re.U` (Unicode matching)

  - `re.X` (verbose)

  (The flags are described in Module contents.)

  The letters `'a'`, `'L'` and `'u'` are mutually exclusive when used as inline flags, so they can't be combined or follow `'-'`. Instead, when one of them appears in an inline group, it overrides the matching mode in the enclosing group. In Unicode patterns `(?a:...)` switches to ASCII-only matching, and `(?u:...)` switches to Unicode matching (default). In bytes patterns `(?L:...)` switches to locale dependent matching, and `(?a:...)` switches to ASCII-only matching (default). This override is only in effect for the narrow inline group, and the original matching mode is restored outside of the group.

  Ajouté dans la version 3.6.

  Modifié dans la version 3.7: Les lettres `'a'`, `'L'` et `'u'` peuvent aussi être utilisées dans un groupe.

`(?>...)`

  Attempts to match `...` as if it was a separate regular expression, and if successful, continues to match the rest of the pattern following it. If the subsequent pattern fails to match, the stack can only be unwound to a point before the `(?>...)` because once exited, the expression, known as an atomic group, has thrown away all stack points within itself. Thus, `(?>.*).` would never match anything because first the `.*` would match all characters possible, then, having nothing left to match, the final `.` would fail to match. Since there are no stack points saved in the Atomic Group, and there is no stack point before it, the entire expression would thus fail to match.

  Ajouté dans la version 3.11.

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

  Similar to regular parentheses, but the substring matched by the group is accessible via the symbolic group name name. Group names must be valid Python identifiers, and in `bytes` patterns they can only contain bytes in the ASCII range. Each group name must be defined only once within a regular expression. A symbolic group is also a numbered group, just as if the group were not named.

  Les groupes nommés peuvent être référencés dans trois contextes. Si le motif est `(?P<quote>['"]).*?(?P=quote)` (c.-à-d. 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`

  Modifié dans la version 3.12: In `bytes` patterns, group name can only contain bytes in the ASCII range (`b'\x00'`-`b'\x7f'`).

`(?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>'`.

  Modifié dans la version 3.12: Group id can only contain ASCII digits. In `bytes` patterns, group name can only contain bytes in the ASCII range (`b'\x00'`-`b'\x7f'`).

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`

  Matches the empty string, but only at the beginning or end of a word. A word is defined as a sequence of word characters. Note that formally, `\b` is defined as the boundary between a `\w` and a `\W` character (or vice versa), or between `\w` and the beginning or end of the string. This means that `r'\bat\b'` matches `'at'`, `'at.'`, `'(at)'`, and `'as at ay'` but not `'attempt'` or `'atlas'`.

  The default word characters in Unicode (str) patterns are Unicode alphanumerics and the underscore, but this can be changed by using the `ASCII` flag. Word boundaries are determined by the current locale if the `LOCALE` flag is used.

  Note

  Inside a character range, `\b` represents the backspace character, for compatibility with Python's string literals.

`\B`

  Matches the empty string, but only when it is not at the beginning or end of a word. This means that `r'at\B'` matches `'athens'`, `'atom'`, `'attorney'`, but not `'at'`, `'at.'`, or `'at!'`. `\B` is the opposite of `\b`, so word characters in Unicode (str) patterns are Unicode alphanumerics or the underscore, although this can be changed by using the `ASCII` flag. Word boundaries are determined by the current locale if the `LOCALE` flag is used.

  Modifié dans la version 3.14: `\B` now matches empty input string.

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

    Matches any Unicode decimal digit (that is, any character in Unicode character category [Nd]). This includes `[0-9]`, and also many other digit characters.

    Matches `[0-9]` if the `ASCII` flag is used.

  Pour les motifs 8-bits (bytes) :

    Matches any decimal digit in the ASCII character set; this is equivalent to `[0-9]`.

`\D`

  Matches any character which is not a decimal digit. This is the opposite of `\d`.

  Matches `[^0-9]` if the `ASCII` flag is used.

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

    Matches Unicode whitespace characters (as defined by `str.isspace()`). This includes `[ \t\n\r\f\v]`, and also many other characters, for example the non-breaking spaces mandated by typography rules in many languages.

    Matches `[ \t\n\r\f\v]` if the `ASCII` flag is used.

  Pour les motifs 8-bits (bytes) :

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

`\S`

  Matches any character which is not a whitespace character. This is the opposite of `\s`.

  Matches `[^ \t\n\r\f\v]` if the `ASCII` flag is used.

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

    Matches Unicode word characters; this includes all Unicode alphanumeric characters (as defined by `str.isalnum()`), as well as the underscore (`_`).

    Matches `[a-zA-Z0-9_]` if the `ASCII` flag is used.

  Pour les motifs 8-bits (bytes) :

    Matches characters considered alphanumeric in the ASCII character set; this is equivalent to `[a-zA-Z0-9_]`. If the `LOCALE` flag is used, matches characters considered alphanumeric in the current locale and the underscore.

`\W`

  Matches any character which is not a word character. This is the opposite of `\w`. By default, matches non-underscore (`_`) characters for which `str.isalnum()` returns `False`.

  Matches `[^a-zA-Z0-9_]` if the `ASCII` flag is used.

  If the `LOCALE` flag is used, matches characters which are neither alphanumeric in the current locale nor the underscore.

`\z`

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

  Ajouté dans la version 3.14.

`\Z`

  The same as `\z`. For compatibility with old Python versions.

Most of the escape sequences supported by Python string literals are also accepted by the regular expression parser:

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

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

`'\u'`, `'\U'`, and `'\N'` escape sequences are only recognized in Unicode (str) patterns. In bytes patterns they are errors. Unknown escapes of ASCII letters are reserved for future use and treated as errors.

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.

Modifié dans la version 3.8: The `'\N{name}'` escape sequence has been added. As in string literals, it expands to the named Unicode character (e.g. `'\N{EM DASH}'`).

## Module contents

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.

### Flags

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

class re.RegexFlag

  An `enum.IntFlag` class containing the regex options listed below.

  Ajouté dans la version 3.11: - added to `__all__`

re.A
re.ASCII

  Make `\w`, `\W`, `\b`, `\B`, `\d`, `\D`, `\s` and `\S` perform ASCII-only matching instead of full Unicode matching. This is only meaningful for Unicode (str) patterns, and is ignored for bytes patterns.

  Corresponds to the inline flag `(?a)`.

  Note

  The `U` flag still exists for backward compatibility, but is redundant in Python 3 since matches are Unicode by default for `str` patterns, and Unicode matching isn't allowed for bytes patterns. `UNICODE` and the inline flag `(?u)` are similarly redundant.

re.DEBUG

  Display debug information about compiled expression.

  No corresponding inline flag.

re.I
re.IGNORECASE

  Perform case-insensitive matching; expressions like `[A-Z]` will also match lowercase letters. Full Unicode matching (such as `Ü` matching `ü`) also works unless the `ASCII` flag is used to disable non-ASCII matches. The current locale does not change the effect of this flag unless the `LOCALE` flag is also used.

  Corresponds to the inline flag `(?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.

re.L
re.LOCALE

  Make `\w`, `\W`, `\b`, `\B` and case-insensitive matching dependent on the current locale. This flag can be used only with bytes patterns.

  Corresponds to the inline flag `(?L)`.

  Avertissement

  This flag is discouraged; consider Unicode matching instead. The locale mechanism is very unreliable as it only handles one "culture" at a time and only works with 8-bit locales. Unicode matching is enabled by default for Unicode (str) patterns and it is able to handle different locales and languages.

  Modifié dans la version 3.6: `LOCALE` can be used only with bytes patterns and is not compatible with `ASCII`.

  Modifié dans la version 3.7: Compiled regular expression objects with the `LOCALE` flag no longer depend on the locale at compile time. Only the locale at matching time affects the result of matching.

re.M
re.MULTILINE

  When specified, the pattern character `'^'` matches at the beginning of the string and at the beginning of each line (immediately following each newline); and the pattern character `'$'` matches at the end of the string and at the end of each line (immediately preceding each newline). By default, `'^'` matches only at the beginning of the string, and `'$'` only at the end of the string and immediately before the newline (if any) at the end of the string.

  Corresponds to the inline flag `(?m)`.

re.NOFLAG

  Indicates no flag being applied, the value is `0`. This flag may be used as a default value for a function keyword argument or as a base value that will be conditionally ORed with other flags. Example of use as a default value:

      def myfunc(pattern, text, flag=re.NOFLAG):
          return re.search(pattern, text, flag)

  Ajouté dans la version 3.11.

re.S
re.DOTALL

  Make the `'.'` special character match any character at all, including a newline; without this flag, `'.'` will match anything except a newline.

  Corresponds to the inline flag `(?s)`.

re.U
re.UNICODE

  In Python 3, Unicode characters are matched by default for `str` patterns. This flag is therefore redundant with no effect and is only kept for backward compatibility.

  See `ASCII` to restrict matching to ASCII characters instead.

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 ils sont précédés d'un backslash non échappé, ou dans des séquences comme `*?`, `(?:` ou `(?P<...>`.Par exemple, `(? :` et `* ?` ne sont pas autorisés. Quand une ligne contient un `#` qui n'est ni dans une classe de caractères, ni 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)`.

### Fonctions

re.compile(pattern, flags=0)

  Compile a regular expression pattern into a regular expression object, which can be used for matching using its `prefixmatch()`, `search()`, and other methods, described below.

  The expression's behaviour can be modified by specifying a flags value. Values can be any of the flags variables, combined using bitwise OR (the `|` operator).

  La séquence

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

  est équivalente à

      result = re.search(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.search(pattern, string, flags=0)

  Scan through string looking for the first location where the regular expression pattern produces a match, and return a corresponding `Match`. Return `None` if no position in the string matches the pattern; note that this is different from finding a zero-length match at some point in the string.

  The expression's behaviour can be modified by specifying a flags value. Values can be any of the flags variables, combined using bitwise OR (the `|` operator).

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

  If zero or more characters at the beginning of string match the regular expression pattern, return a corresponding `Match`. Return `None` if the string does not match the pattern; note that this is different from a zero-length match.

  Note

  Even in `MULTILINE` mode, this will only match at the beginning of the string and not at the beginning of each line.

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

  The expression's behaviour can be modified by specifying a flags value. Values can be any of the flags variables, combined using bitwise OR (the `|` operator).

  This function now has two names and has long been known as `match()`. Use that name when you need to retain compatibility with older Python versions.

  Ajouté dans la version 3.15.

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

  Soft deprecated since version 3.15: `match()` has been soft deprecated in favor of the alternate `prefixmatch()` name of this API which is more explicitly descriptive. Use it to better express intent. The norm in other languages and regular expression implementations is to use the term match to refer to the behavior of what Python has always called `search()`. See prefixmatch() vs. match().

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

  If the whole string matches the regular expression pattern, return a corresponding `Match`. Return `None` if the string does not match the pattern; note that this is different from a zero-length match.

  The expression's behaviour can be modified by specifying a flags value. Values can be any of the flags variables, combined using bitwise OR (the `|` operator).

  Ajouté 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.', maxsplit=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.

  Adjacent empty matches are not possible, but an empty match can occur immediately after a non-empty match.

      >>> re.split(r'\b', 'Words, words, words.')
      ['', 'Words', ', ', 'words', ', ', 'words', '.']
      >>> re.split(r'\W*', '...words...')
      ['', '', 'w', 'o', 'r', 'd', 's', '', '']
      >>> re.split(r'(\W*)', '...words...')
      ['', '...', '', '', 'w', '', 'o', '', 'r', '', 'd', '', 's', '...', '', '', '']

  The expression's behaviour can be modified by specifying a flags value. Values can be any of the flags variables, combined using bitwise OR (the `|` operator).

  Modifié dans la version 3.1: ajout de l'argument optionnel flags.

  Modifié dans la version 3.7: Gestion du découpage avec un motif qui pourrait correspondre à une chaine de caractère vide.

  Obsolète depuis la version 3.13: Passing maxsplit and flags as positional arguments is deprecated. In future Python versions they will be keyword-only parameters.

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

  Renvoie toutes les correspondances, sans chevauchements, entre le motif pattern et la chaîne string, comme une liste de chaînes ou de n-uplets. La chaîne string est examinée de gauche à droite, et les correspondances sont données dans cet ordre. Le résultat peut contenir des correspondances vides.

  Le type du résultat dépend du nombre de groupes capturants dans le motif. S'il n'y en a pas, le résultat est une liste de sous-chaînes de caractères qui correspondent au motif. S'il y a exactement un groupe, le résultat est une liste constituée des sous-chaînes qui correspondaient à ce groupe pour chaque correspondance entre le motif et la chaîne. S'il y a plusieurs groupes, le résultat est formé de n-uplets avec les sous-chaînes correspondant aux différents groupes.

      >>> re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest')
      ['foot', 'fell', 'fastest']
      >>> re.findall(r'(\w+)=(\d+)', 'set width=20 and height=10')
      [('width', '20'), ('height', '10')]

  The expression's behaviour can be modified by specifying a flags value. Values can be any of the flags variables, combined using bitwise OR (the `|` operator).

  Modifié dans la version 3.7: Les correspondances non vides peuvent maintenant démarrer juste après une correspondance vide précédente.

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

  Return an iterator yielding `Match` objects over all non-overlapping matches for the RE pattern in string. The string is scanned left-to-right, and matches are returned in the order found. Empty matches are included in the result.

  The expression's behaviour can be modified by specifying a flags value. Values can be any of the flags variables, combined using bitwise OR (the `|` operator).

  Modifié dans la version 3.7: Les correspondances non vides peuvent maintenant démarrer juste après une correspondance vide précédente.

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 échappements inconnus de lettres ASCII sont réservés pour une utilisation future et sont considérés comme des erreurs. Les autres échappements tels que `\&` sont laissés intacts. 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{'

  If repl is a function, it is called for every non-overlapping occurrence of pattern. The function takes a single `Match` argument, and returns the replacement string. For example:

      >>> 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'

  The pattern may be a string or a `Pattern`.

  The optional argument count is the maximum number of pattern occurrences to be replaced; count must be a non-negative integer. If omitted or zero, all occurrences will be replaced.

  Adjacent empty matches are not possible, but an empty match can occur immediately after a non-empty match. As a result, `sub('x*', '-', 'abxd')` returns `'-a-b--d-'` instead of `'-a-b-d-'`.

  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.

  The expression's behaviour can be modified by specifying a flags value. Values can be any of the flags variables, combined using bitwise OR (the `|` operator).

  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.

  Modifié dans la version 3.7: Unknown escapes in repl consisting of `'\'` and an ASCII letter now are errors. An empty match can occur immediately after a non-empty match.

  Modifié dans la version 3.12: Group id can only contain ASCII digits. In `bytes` replacement strings, group name can only contain bytes in the ASCII range (`b'\x00'`-`b'\x7f'`).

  Obsolète depuis la version 3.13: Passing count and flags as positional arguments is deprecated. In future Python versions they will be keyword-only parameters.

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

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

  The expression's behaviour can be modified by specifying a flags value. Values can be any of the flags variables, combined using bitwise OR (the `|` operator).

re.escape(pattern)

  Échappe tous les caractères spéciaux de pattern. 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('https://www.python.org'))
      https://www\.python\.org

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

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

  Cette fonction ne doit pas être utilisée pour la chaîne de remplacement dans `sub()` et `subn()`, seuls les antislashs 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é.

  Modifié dans la version 3.7: Seuls les caractères qui peuvent avoir une signification spéciale dans une expression rationnelle sont échappés. De ce fait, `'!'`, `'"'`, `'%'`, `"'"`, `','`, `'/'`, `':'`, `';'`, `'<'`, `'='`, `'>'`, `'@'`, et `"`"` ne sont plus échappés.

re.purge()

  Vide le cache d'expressions rationnelles.

### Exceptions

exception re.PatternError(msg, pattern=None, pos=None)

  Exception raised when a string passed to one of the functions here is not a valid regular expression (for example, it might contain unmatched parentheses) or when some other error occurs during compilation or matching. It is never an error if a string contains no match for a pattern. The `PatternError` instance has the following additional attributes:

  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.

  Modifié dans la version 3.13: `PatternError` was originally named `error`; the latter is kept as an alias for backward compatibility.

## Regular expression objects

class re.Pattern

  Compiled regular expression object returned by `re.compile()`.

  Modifié dans la version 3.9: `re.Pattern` supports `[]` to indicate a Unicode (str) or bytes pattern. See Type Alias générique.

Pattern.search(string[, pos[, endpos]])

  Scan through string looking for the first location where this regular expression produces a match, and return a corresponding `Match`. Return `None` if no position in the string matches the pattern; note that this is different from finding a zero-length match at some point in the string.

  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
      <re.Match object; span=(0, 1), match='d'>
      >>> pattern.search("dog", 1)  # No match; search doesn't include the "d"

Pattern.prefixmatch(string[, pos[, endpos]])

  If zero or more characters at the beginning of string match this regular expression, return a corresponding `Match`. Return `None` if the string does not match the pattern; note that this is different from a zero-length match.

  Note that even in `MULTILINE` mode, this will only match at the beginning of the string and not at the beginning of each line.

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

      >>> pattern = re.compile("o")
      >>> pattern.prefixmatch("dog")     # No match as "o" is not at the start of "dog".
      >>> pattern.prefixmatch("dog", 1)  # Match as "o" is the 2nd character of "dog".
      <re.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. prefixmatch()).

  This method now has two names and has long been known as `match()`. Use that name when you need to retain compatibility with older Python versions.

  Ajouté dans la version 3.15.

Pattern.match(string[, pos[, endpos]])

  Soft deprecated since version 3.15: `match()` has been soft deprecated in favor of the alternate `prefixmatch()` name of this API which is more explicitly descriptive. Use it to better express intent. The norm in other languages and regular expression implementations is to use the term match to refer to the behavior of what Python has always called `search()`. See prefixmatch() vs. match().

Pattern.fullmatch(string[, pos[, endpos]])

  If the whole string matches this regular expression, return a corresponding `Match`. Return `None` if the string does not match the pattern; note that this is different from a zero-length match.

  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.
      <re.Match object; span=(1, 3), match='og'>

  Ajouté dans la version 3.4.

Pattern.split(string, maxsplit=0)

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

Pattern.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()`.

Pattern.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()`.

Pattern.sub(repl, string, count=0)

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

Pattern.subn(repl, string, count=0)

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

Pattern.flags

  The regex matching flags. This is a combination of the flags given to `compile()`, any `(?...)` inline flags in the pattern, and implicit flags such as `UNICODE` if the pattern is a Unicode string.

Pattern.groups

  Le nombre de groupes de capture dans le motif.

Pattern.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.

Pattern.pattern

  La chaîne de motif depuis laquelle l'objet motif a été compilé.

Modifié dans la version 3.7: Ajout du support des fonctions `copy.copy()` et `copy.deepcopy()`. Les expressions régulières compilées sont considérées atomiques.

## Match objects

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` :

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

class re.Match

  Match object returned by successful `match`es and `search`es.

  Modifié dans la version 3.9: `re.Match` supports `[]` to indicate a Unicode (str) or bytes match. See Type Alias générique.

Match.expand(template)

  Return the string obtained by doing backslash substitution on the template string template, as done by the `sub()` method. Escapes such as `\n` are converted to the appropriate characters, and numeric backreferences (`\1`, `\2`) and named backreferences (`\g<1>`, `\g<name>`) are replaced by the contents of the corresponding group. The backreference `\g<0>` will be replaced by the entire match.

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

Match.group([group1, ...])

  Returns one or more subgroups of the match. If there is a single argument, the result is a single string; if there are multiple arguments, the result is a tuple with one item per argument. Without arguments, group1 defaults to zero (the whole match is returned). If a groupN argument is zero, the corresponding return value is the entire matching string; if it is a positive integer, it is the string matching the corresponding parenthesized group. If a group number is negative or larger than the number of groups defined in the pattern, an `IndexError` exception is raised. If a group is contained in a part of the pattern that did not match, the corresponding result is `None`. If a group is contained in a part of the pattern that matched multiple times, the last match is returned.

      >>> m = re.search(r"\A(\w+) (\w+)", "Norwegian Blue, pining for the fjords")
      >>> m.group(0)       # The entire match
      'Norwegian Blue'
      >>> m.group(1)       # The first parenthesized subgroup.
      'Norwegian'
      >>> m.group(2)       # The second parenthesized subgroup.
      'Blue'
      >>> m.group(1, 2)    # Multiple arguments give us a tuple.
      ('Norwegian', 'Blue')

  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.search(r"(?P<adjective>\w+) (?P<animal>\w+)", "killer rabbit")
      >>> m.group('adjective')
      'killer'
      >>> m.group('animal')
      'rabbit'

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

      >>> m.group(1)
      'killer'
      >>> m.group(2)
      'rabbit'

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

      >>> m = re.search(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.search(r"(\w+) (\w+)", "Norwegian Blue, pining for the fjords")
      >>> m[0]       # The entire match
      'Norwegian Blue'
      >>> m[1]       # The first parenthesized subgroup.
      'Norwegian'
      >>> m[2]       # The second parenthesized subgroup.
      'Blue'

  Named groups are supported as well:

      >>> m = re.search(r"(?P<adjective>\w+) (?P<animal>\w+)", "killer rabbit")
      >>> m['adjective']
      'killer'
      >>> m['animal']
      'rabbit'

  Ajouté dans la version 3.6.

Match.groups(default=None)

  Renvoie un n-uplet 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.search(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.search(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.search(r"(?P<adjective>\w+) (?P<animal>\w+)", "killer rabbit")
      >>> m.groupdict()
      {'adjective': 'killer', 'animal': 'rabbit'}

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 la paire `(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()`.

Modifié dans la version 3.7: Ajout du support des fonctions `copy.copy()` et `copy.deepcopy()`. Les objets correspondants sont considérés atomiques.

## Regular expression examples

### Checking for a pair

Dans cet exemple, nous nous aidons de la fonction suivante pour afficher de manière plus jolie les objets qui correspondent :

    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_hand_re = re.compile(r"^[a2-9tjqk]{5}$")
    >>> displaymatch(valid_hand_re.search("akt5q"))  # Valid.
    "<Match: 'akt5q', groups=()>"
    >>> displaymatch(valid_hand_re.search("akt5e"))  # Invalid.
    >>> displaymatch(valid_hand_re.search("akt"))    # Invalid.
    >>> displaymatch(valid_hand_re.search("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 = re.compile(r".*(.).*\1")
    >>> displaymatch(pair_re.prefixmatch("717ak"))     # Pair of 7s.
    "<Match: '717', groups=('7',)>"
    >>> displaymatch(pair_re.prefixmatch("718ak"))     # No pairs.
    >>> displaymatch(pair_re.prefixmatch("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_re = re.compile(r".*(.).*\1")
    >>> pair_re.prefixmatch("717ak").group(1)
    '7'

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

    >>> pair_re.prefixmatch("354aa").group(1)
    'a'

### Simuler scanf()

Python does not currently have an equivalent to `scanf()`. Regular expressions are generally more powerful, though also more verbose, than `scanf()` format strings. The table below offers some more-or-less equivalent mappings between `scanf()` format tokens and regular expressions.

`scanf()` Token | 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]+`

To extract the filename and numbers from a string like:

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

you would use a `scanf()` format like:

    %s - %d errors, %d warnings

The equivalent regular expression would be:

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

### search() vs. prefixmatch()

Python offre différentes opérations primitives basées sur des expressions régulières :

- `re.prefixmatch()` checks for a match only at the beginning of the string

- `re.search()` cherche une correspondance n'importe où dans la chaîne de caractères (ce que fait Perl par défaut)

- `re.fullmatch()` cherche une correspondance avec l'intégralité de la chaîne de caractères.

Par exemple :

    >>> re.prefixmatch("c", "abcdef")  # No match
    >>> re.search("c", "abcdef")       # Match
    <re.Match object; span=(2, 3), match='c'>
    >>> re.fullmatch("p.*n", "python") # Match
    <re.Match object; span=(0, 6), match='python'>
    >>> re.fullmatch("r.*n", "python") # No match

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

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

Note however that in `MULTILINE` mode `prefixmatch()` only matches at the beginning of the string, whereas using `search()` with a regular expression beginning with `'^'` will match at the beginning of each line.

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

### prefixmatch() vs. match()

Why is the `match()` function and method discouraged in favor of the longer `prefixmatch()` spelling?

Many other languages have gained regex support libraries since regular expressions were added to Python. However in the most popular of those, they use the term match in their APIs to mean the unanchored behavior provided in Python by `search()`. Thus use of the plain term match can be unclear to those used to other languages when reading or writing code and not familiar with the Python API's divergence from what otherwise become the industry norm.

Quoting from the Zen Of Python (`python3 -m this`): "Explicit is better than implicit". Anyone reading the name `prefixmatch()` is likely to understand the intended semantics. When reading `match()` there remains a seed of doubt about the intended behavior to anyone not already familiar with this old Python gotcha.

We do not plan to remove the older `match()` name, as it has been used in code for over 30 years. It has been soft deprecated: code supporting older versions of Python should continue to use `match()`, while new code should prefer `prefixmatch()`.

Ajouté dans la version 3.15: `prefixmatch()`

Soft deprecated since version 3.15: `match()`

### Making a phonebook

`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.

Tout d'abord, 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, maxsplit=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, maxsplit=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']]

### Text munging

`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.'

### Finding all adverbs

`findall()` trouve toutes les occurrences d'un motif, pas juste la première comme le fait `search()`. Par exemple, si un écrivain voulait trouver tous les adverbes dans un texte, il devrait utiliser `findall()` de la manière suivante :

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

### Finding all adverbs and their 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\b", text):
    ...     print('%02d-%02d: %s' % (m.start(), m.end(), m.group(0)))
    07-16: carefully
    40-47: quickly

### Raw string notation

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.search(r"\W(.)\1\W", " ff ")
    <re.Match object; span=(0, 4), match=' ff '>
    >>> re.search("\\W(.)\\1\\W", " ff ")
    <re.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.search(r"\\", r"\\")
    <re.Match object; span=(0, 1), match='\\'>
    >>> re.search("\\\\", r"\\")
    <re.Match object; span=(0, 1), match='\\'>

### Writing a tokenizer

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 :

    from typing import NamedTuple
    import re

    class Token(NamedTuple):
        type: str
        value: int | float | str
        line: int
        column: int

    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.