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 un meilleur support 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).

Regular expressions can be concatenated to form new regular expressions; if A and B are both regular expressions, then AB is also a regular expression. In general, if a string p matches A and another string q matches B, the string pq will match AB. This holds unless A or B contain low precedence operations; boundary conditions between A and B; or have numbered group references. Thus, complex expressions can easily be constructed from simpler primitive expressions like the ones described here. For details of the theory and implementation of regular expressions, consult the Friedl book [Frie09], or almost any textbook about compiler construction.

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 (*, +, ?, {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 le parseur 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 non capturante 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 courrante 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 courrante 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 courrante 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 le parseur 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 inclues 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 en ligne (?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 debug à propos de l’expression compilée. N’a pas d’option en ligne é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 courrante n’affecte pas cette option, tant que l’option re.LOCALE n’est pas utilisée. Correspond au flag en ligne (?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 “K” (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 modifs 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. Correpond à l’option en ligne (?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 en ligne (?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 en ligne (?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*")

Corresponds to the inline flag (?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 capturantes 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 capturants 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)

Return all non-overlapping matches of pattern in string, as a list of strings. The string is scanned left-to-right, and matches are returned in the order found. If one or more groups are present in the pattern, return a list of groups; this will be a list of tuples if the pattern has more than one group. Empty matches are included in the result.

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)

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. See also the note about 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))))
\/|\-|\+|\*\*|\*

This functions must not be used for the replacement string in sub() and subn(), only backslashes should be escaped. For example:

>>> 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 capturants 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 email :

>>> 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() trouve toutes les occurrences d’un motif, pas juste la première comme le fait search(). Par exemple, si un(e) écrivain(e) voulait trouver tous les adverbes dans un texte, il/elle devrait utiliser findall() de la manière suivante :

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

Pour obtenir plus d’informations sur les correspondances que juste le texte trouvé, finditer() est utile en fournissant des objets de correspondance plutôt que des chaînes. En continuant avec le précédent exemple, si l’écrivain(e) voulait trouver tous les adverbes et leurs positions dans un texte, il/elle utiliserait finditer() de la manière suivante :

>>> 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', ['typ', '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(kind)
        if kind == 'NEWLINE':
            line_start = mo.end()
            line_num += 1
        elif kind == 'SKIP':
            pass
        elif kind == 'MISMATCH':
            raise RuntimeError(f'{value!r} unexpected on line {line_num}')
        else:
            if kind == 'ID' and value in keywords:
                kind = value
            column = mo.start() - line_start
            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(typ='IF', value='IF', line=2, column=4)
Token(typ='ID', value='quantity', line=2, column=7)
Token(typ='THEN', value='THEN', line=2, column=16)
Token(typ='ID', value='total', line=3, column=8)
Token(typ='ASSIGN', value=':=', line=3, column=14)
Token(typ='ID', value='total', line=3, column=17)
Token(typ='OP', value='+', line=3, column=23)
Token(typ='ID', value='price', line=3, column=25)
Token(typ='OP', value='*', line=3, column=31)
Token(typ='ID', value='quantity', line=3, column=33)
Token(typ='END', value=';', line=3, column=41)
Token(typ='ID', value='tax', line=4, column=8)
Token(typ='ASSIGN', value=':=', line=4, column=12)
Token(typ='ID', value='price', line=4, column=15)
Token(typ='OP', value='*', line=4, column=21)
Token(typ='NUMBER', value='0.05', line=4, column=23)
Token(typ='END', value=';', line=4, column=27)
Token(typ='ENDIF', value='ENDIF', line=5, column=4)
Token(typ='END', value=';', line=5, column=9)
[Frie09]Friedl, Jeffrey. Mastering Regular Expressions. 3rd ed., O’Reilly Media, 2009. The third edition of the book no longer covers Python at all, but the first edition covered writing good regular expression patterns in great detail.