Working on library/re.po

2017-05-27 16:30:14 +02:00 · 2017-05-27 16:30:14 +02:00 · 4c33153639
commit 4c33153639
parent 3d5892f27c
1 changed files with 268 additions and 17 deletions
--- a/library/re.po
+++ b/library/re.po
@ -19,17 +19,19 @@ msgstr ""
  
 #: ../Doc/library/re.rst:2 
 msgid ":mod:`re` --- Regular expression operations" 
-msgstr "" 
+msgstr ":mod:`re` --- Opérations à base d'expressions rationnelles" 
  
 #: ../Doc/library/re.rst:10 
 msgid "**Source code:** :source:`Lib/re.py`" 
-msgstr "" 
+msgstr "**Code source :** :source:`Lib/re.py`" 
  
 #: ../Doc/library/re.rst:14 
 msgid "" 
 "This module provides regular expression matching operations similar to those " 
 "found in Perl." 
 msgstr "" 
+"Ce module fournit des opérations sur les expressions rationnelles " 
+"similaires à celles que l'on trouve dans Perl." 
  
 #: ../Doc/library/re.rst:17 
 msgid "" 
@ -39,6 +41,12 @@ msgid ""
 "versa; similarly, when asking for a substitution, the replacement string " 
 "must be of the same type as both the pattern and the search string." 
 msgstr "" 
+"Motifs comme chaînes à analyser peuvent aussi bien être des chaînes Unicode " 
+"que des chaînes 8-bit. Cependant, chaînes Unicode et 8-bit ne peuvent pas " 
+"être mélangées : vous ne pouvez ainsi pas analyser une chaîne Unicode avec " 
+"un motif 8-bit, et inversement ; similairement, lors d'une substitution, la " 
+"chaîne de remplacement doit être du même type que le motif et la chaîne " 
+"analysée." 
  
 #: ../Doc/library/re.rst:23 
 msgid "" 
@ -50,6 +58,14 @@ msgid ""
 "string, because the regular expression must be ``\\\\``, and each backslash " 
 "must be expressed as ``\\\\`` inside a regular Python string literal." 
 msgstr "" 
+"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* exprimé par ``\\" 
+"\\`` au sein des chaînes littérales Python." 
  
 #: ../Doc/library/re.rst:32 
 msgid "" 
@ -60,6 +76,13 @@ msgid ""
 "a newline. Usually patterns will be expressed in Python code using this raw " 
 "string notation." 
 msgstr "" 
+"La solution est d'utiliser la notation des chaînes brutes en Python pour les " 
+"expressions rationnelles ; Les *backslashes* 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." 
  
 #: ../Doc/library/re.rst:39 
 msgid "" 
@ -68,6 +91,12 @@ msgid ""
 "expressions <re-objects>`. The functions are shortcuts that don't require " 
 "you to compile a regex object first, but miss some fine-tuning parameters." 
 msgstr "" 
+"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 :ref:`expressions rationnelles compilées <re-objects>`. 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." 
  
 #: ../Doc/library/re.rst:47 
 msgid "" 
@ -75,10 +104,14 @@ msgid ""
 "has an API compatible with the standard library :mod:`re` module, but offers " 
 "additional functionality and a more thorough Unicode support." 
 msgstr "" 
+"Le module tiers `regex <https://pypi.python.org/pypi/regex/>`_, dont " 
+"l'interface est compatible avec le module :mod:`re` de la bibliothèque " 
+"standard, mais offre des fonctionnalités additionnelles et un meilleur " 
+"support de l'Unicode." 
  
 #: ../Doc/library/re.rst:55 
 msgid "Regular Expression Syntax" 
-msgstr "" 
+msgstr "Syntaxe des Expressions Rationnelles" 
  
 #: ../Doc/library/re.rst:57 
 msgid "" 
@ -87,6 +120,11 @@ msgid ""
 "given regular expression (or if a given regular expression matches a " 
 "particular string, which comes down to the same thing)." 
 msgstr "" 
+"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)." 
  
 #: ../Doc/library/re.rst:62 
 msgid "" 
@ -101,6 +139,18 @@ msgid ""
 "consult the Friedl book referenced above, or almost any textbook about " 
 "compiler construction." 
 msgstr "" 
+"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 précédence ; de conditions liées 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 " 
+"Frield référencé plus tôt, ou à peu près n'importe quel livre dédié à la " 
+"construction de compilateurs." 
  
 #: ../Doc/library/re.rst:72 
 msgid "" 
@ -108,6 +158,9 @@ msgid ""
 "further information and a gentler presentation, consult the :ref:`regex-" 
 "howto`." 
 msgstr "" 
+"Une brève explication sur le format des expressions rationnelles suit. Pour " 
+"de plus amples informations, et une meilleure présentation, référez-vous au :" 
+"ref:`regex-howto`." 
  
 #: ../Doc/library/re.rst:75 
 msgid "" 
@ -118,6 +171,14 @@ msgid ""
 "rest of this section, we'll write RE's in ``this special style``, usually " 
 "without quotes, and strings to be matched ``'in single quotes'``.)" 
 msgstr "" 
+"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 deux " 
+"caractères ordinaires, donc ``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'``.)" 
  
 #: ../Doc/library/re.rst:82 
 msgid "" 
@ -127,6 +188,12 @@ msgid ""
 "may not contain null bytes, but can specify the null byte using a ``" 
 "\\number`` notation such as ``'\\x00'``." 
 msgstr "" 
+"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 motifs d'expressions rationnelles ne devraient pas " 
+"contenir de caractères nuls, mais peuvent spécifier le caractère nul en " 
+"utilisant une notation ``\\number`` comme ``\\x00``." 
  
 #: ../Doc/library/re.rst:88 
 msgid "" 
@ -136,10 +203,17 @@ msgid ""
 "repetition to an inner repetition, parentheses may be used. For example, the " 
 "expression ``(?:a{6})*`` matches any multiple of six ``'a'`` characters." 
 msgstr "" 
+"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." 
  
 #: ../Doc/library/re.rst:95 
 msgid "The special characters are:" 
-msgstr "" 
+msgstr "Les caractères spéciaux sont :" 
  
 #: ../Doc/library/re.rst:100 
 msgid "``'.'``" 
@ -151,6 +225,9 @@ msgid ""
 "If the :const:`DOTALL` flag has been specified, this matches any character " 
 "including a newline." 
 msgstr "" 
+"(Point.) Dans le mode par défaut, il valide tout caractère à l'exception du " 
+"saut de ligne. Si l'option :const:`DOTALL` a été spécifiée, il valide tout " 
+"caractère, saut de ligne compris." 
  
 #: ../Doc/library/re.rst:104 
 msgid "``'^'``" 
@ -161,6 +238,8 @@ msgid ""
 "(Caret.) Matches the start of the string, and in :const:`MULTILINE` mode " 
 "also matches immediately after each newline." 
 msgstr "" 
+"(Accent circonflexe.) Valide le début d'une chaîne de caractères, ainsi que " 
+"ce qui suit chaque saut de ligne en mode :const:`MULTILINE`." 
  
 #: ../Doc/library/re.rst:113 
 msgid "``'$'``" 
@ -177,6 +256,14 @@ msgid ""
 "(empty) matches: one just before the newline, and one at the end of the " 
 "string." 
 msgstr "" 
+"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 :const:" 
+"`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 :const:`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." 
  
 #: ../Doc/library/re.rst:118 
 msgid "``'*'``" 
@ -188,6 +275,9 @@ msgid ""
 "as many repetitions as are possible. ``ab*`` will match 'a', 'ab', or 'a' " 
 "followed by any number of 'b's." 
 msgstr "" 
+"Implique à l'expression rationnelle résultante de valider 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'." 
  
 #: ../Doc/library/re.rst:123 
 msgid "``'+'``" 
@ -199,6 +289,9 @@ msgid ""
 "``ab+`` will match 'a' followed by any non-zero number of 'b's; it will not " 
 "match just 'a'." 
 msgstr "" 
+"Implique à l'expression rationnelle résultante de valider une 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' ; ça ne validera pas la chaîne 'a'." 
  
 #: ../Doc/library/re.rst:127 
 msgid "``'?'``" 
@ -209,6 +302,8 @@ msgid ""
 "Causes the resulting RE to match 0 or 1 repetitions of the preceding RE. " 
 "``ab?`` will match either 'a' or 'ab'." 
 msgstr "" 
+"Implique à l'expression rationnelle résultante de valider 0 ou 1 répétition " 
+"de l'expression qui précède. ``ab?`` correspondra à la fois à 'a' et 'ab'." 
  
 #: ../Doc/library/re.rst:136 
 msgid "``*?``, ``+?``, ``??``" 
@ -224,6 +319,14 @@ msgid ""
 "characters as possible will be matched. Using the RE ``<.*?>`` will match " 
 "only ``<a>``." 
 msgstr "" 
+"Les qualificateurs ``'*'``, ``'+'`` et ``'?'`` sont tous :dfn:`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 :dfn:`non-greedy` (ou :dfn:`minimal`) ; le " 
+"*moins* de caractères possibles seront validés. Utiliser l'expression " 
+"rationnelle ``<.*?>`` validera uniquement ``<a>``." 
  
 #: ../Doc/library/re.rst:141 
 msgid "``{m}``" 
@ -235,6 +338,10 @@ msgid ""
 "fewer matches cause the entire RE not to match. For example, ``a{6}`` will " 
 "match exactly six ``'a'`` characters, but not five." 
 msgstr "" 
+"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." 
  
 #: ../Doc/library/re.rst:150 
 msgid "``{m,n}``" 
@ -251,6 +358,14 @@ msgid ""
 "be omitted or the modifier would be confused with the previously described " 
 "form." 
 msgstr "" 
+"Implique à l'expression rationnelle résultante de valider 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." 
  
 #: ../Doc/library/re.rst:157 
 msgid "``{m,n}?``" 
@ -264,6 +379,12 @@ msgid ""
 "character string ``'aaaaaa'``, ``a{3,5}`` will match 5 ``'a'`` characters, " 
 "while ``a{3,5}?`` will only match 3 characters." 
 msgstr "" 
+"Implique à l'expression rationnelle résultante de valider 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." 
  
 #: ../Doc/library/re.rst:170 
 msgid "``'\\'``" 
@ -275,6 +396,9 @@ msgid ""
 "``'*'``, ``'?'``, and so forth), or signals a special sequence; special " 
 "sequences are discussed below." 
 msgstr "" 
+"Échappe à la fois les caractères spéciaux (permettant d'utiliser des " 
+"caractères comme ``'*'``, ``'?'`` et autres), ou signale une séquence " 
+"spéciale ; les séquences spéciales sont décrites ci-dessous." 
  
 #: ../Doc/library/re.rst:164 
 msgid "" 
@ -286,6 +410,15 @@ msgid ""
 "repeated twice. This is complicated and hard to understand, so it's highly " 
 "recommended that you use raw strings for all but the simplest expressions." 
 msgstr "" 
+"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 retournée. Cependant, si Python " 
+"avait reconnu la séquence, le *backslash* aurait dû être doublé. 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." 
  
 #: ../Doc/library/re.rst:202 
 msgid "``[]``" 
@ -293,13 +426,15 @@ msgstr "``[]``"
  
 #: ../Doc/library/re.rst:173 
 msgid "Used to indicate a set of characters. In a set:" 
-msgstr "" 
+msgstr "Utilisé pour indiquer un ensemble de caractères. Dans un ensemble :" 
  
 #: ../Doc/library/re.rst:175 
 msgid "" 
 "Characters can be listed individually, e.g. ``[amk]`` will match ``'a'``, " 
 "``'m'``, or ``'k'``." 
 msgstr "" 
+"Les caractères peuvent être listés individuellement, e.g. ``[amk]`` " 
+"correspondra à ``'a'``, ``'m'`` ou ``'k'``." 
  
 #: ../Doc/library/re.rst:178 
 msgid "" 
@ -310,6 +445,13 @@ msgid ""
 "``-`` is escaped (e.g. ``[a\\-z]``) or if it's placed as the first or last " 
 "character (e.g. ``[a-]``), it will match a literal ``'-'``." 
 msgstr "" 
+"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-]``), il " 
+"correspondra à un ``'-'`` littéral." 
  
 #: ../Doc/library/re.rst:185 
 msgid "" 
@ -317,6 +459,9 @@ msgid ""
 "``[(+*)]`` will match any of the literal characters ``'('``, ``'+'``, " 
 "``'*'``, or ``')'``." 
 msgstr "" 
+"Les caractères spéciaux perdent leur sens à l'intérieur des ensembles. Par " 
+"exemple, ``[(+*)]`` validera chacun des caractères littéraux ``'('``, " 
+"``'+'``, ``'*'`` ou ``')'``." 
  
 #: ../Doc/library/re.rst:189 
 msgid "" 
@ -324,6 +469,10 @@ msgid ""
 "accepted inside a set, although the characters they match depends on " 
 "whether :const:`ASCII` or :const:`LOCALE` mode is in force." 
 msgstr "" 
+"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 :const:" 
+"`ASCII` et :const:`LOCALE`." 
  
 #: ../Doc/library/re.rst:193 
 msgid "" 
@ -334,6 +483,13 @@ msgid ""
 "any character except ``'^'``. ``^`` has no special meaning if it's not the " 
 "first character in the set." 
 msgstr "" 
+"Les caractères qui ne sont pas dans un intervalle peuvent être trouvés avec " 
+"l'ensemble complémentaire (:dfn:`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." 
  
 #: ../Doc/library/re.rst:200 
 msgid "" 
@ -341,6 +497,10 @@ msgid ""
 "place it at the beginning of the set. For example, both ``[()[\\]{}]`` and " 
 "``[]()[{}]`` will both match a parenthesis." 
 msgstr "" 
+"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." 
  
 #: ../Doc/library/re.rst:213 
 msgid "``'|'``" 
@ -358,6 +518,17 @@ msgid ""
 "the ``'|'`` operator is never greedy. To match a literal ``'|'``, use ``\\|" 
 "``, or enclose it inside a character class, as in ``[|]``." 
 msgstr "" 
+"``A|B``, où A et B peuvent être deux expressions rationnelles arbitraires, " 
+"crée une expression rationnelle qui validera à la fois A et 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 ``[|]``." 
  
 #: ../Doc/library/re.rst:220 
 msgid "``(...)``" 
@ -372,6 +543,13 @@ msgid ""
 "``'('`` or ``')'``, use ``\\(`` or ``\\)``, or enclose them inside a " 
 "character class: ``[(] [)]``." 
 msgstr "" 
+"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 : ``[(] " 
+"[)]``." 
  
 #: ../Doc/library/re.rst:227 
 msgid "``(?...)``" 
@ -385,6 +563,11 @@ msgid ""
 "do not create a new group; ``(?P<name>...)`` is the only exception to this " 
 "rule. Following are the currently supported extensions." 
 msgstr "" 
+"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." 
  
 #: ../Doc/library/re.rst:240 
 msgid "``(?aiLmsux)``" 
@ -402,6 +585,17 @@ msgid ""
 "regular expression, instead of passing a *flag* argument to the :func:`re." 
 "compile` function. Flags should be used first in the expression string." 
 msgstr "" 
+"(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 : :const:`re.A` (validation *ASCII* " 
+"seulement), :const:`re.I` (ignorer la casse)`, :const:`re.L` (dépendant de " 
+"la locale), :const:`re.M` (multi-ligne), :const:`re.S` (les points " 
+"correspondent à tous les caractères) et :const:`re.X` (verbeux), pour " 
+"l'ensemble de l'expression rationnelle. (Les options dans décrites dans la " 
+"section :ref:`contents-of-module-re`.) C'est utile si vous souhaitez " 
+"préciser l'option dans l'expression rationnelle, plutôt qu'en passant un " 
+"argument *flag* à la fonction :func:`re.compile`. Les options devraient " 
+"être spécifiées en premier dans la chaîne de l'expression." 
  
 #: ../Doc/library/re.rst:246 
 msgid "``(?:...)``" 
@ -414,10 +608,14 @@ msgid ""
 "*cannot* be retrieved after performing a match or referenced later in the " 
 "pattern." 
 msgstr "" 
+"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." 
  
 #: ../Doc/library/re.rst:256 
 msgid "``(?imsx-imsx:...)``" 
-msgstr "" 
+msgstr "``(?imsx-imsx:...)``" 
  
 #: ../Doc/library/re.rst:249 
 msgid "" 
@ -428,6 +626,13 @@ msgid ""
 "and :const:`re.X` (verbose), for the part of the expression. (The flags are " 
 "described in :ref:`contents-of-module-re`.)" 
 msgstr "" 
+"(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 : :const:`re.I` (ignorer la casse), :const:`re.M` (multi-" 
+"ligne), :const:`re.S` (les points correspondent à tous les caractères) et :" 
+"const:`re.X` (verbeux), pour cette partie de l'expression. (Les options " 
+"sont décrites dans la section :ref:`contents-of-module-re`.)" 
  
 #: ../Doc/library/re.rst:281 
 msgid "``(?P<name>...)``" 
@ -441,6 +646,12 @@ msgid ""
 "regular expression. A symbolic group is also a numbered group, just as if " 
 "the group were not named." 
 msgstr "" 
+"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é." 
  
 #: ../Doc/library/re.rst:265 
 msgid "" 
@ -448,22 +659,25 @@ msgid ""
 "P<quote>['\"]).*?(?P=quote)`` (i.e. matching a string quoted with either " 
 "single or double quotes):" 
 msgstr "" 
+"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)." 
  
 #: ../Doc/library/re.rst:270 
 msgid "Context of reference to group \"quote\"" 
-msgstr "" 
+msgstr "Contexte de référence au groupe \"quote\"" 
  
 #: ../Doc/library/re.rst:270 
 msgid "Ways to reference it" 
-msgstr "" 
+msgstr "Manières de le référencer" 
  
 #: ../Doc/library/re.rst:272 
 msgid "in the same pattern itself" 
-msgstr "" 
+msgstr "lui-même dans le même motif" 
  
 #: ../Doc/library/re.rst:272 
 msgid "``(?P=quote)`` (as shown)" 
-msgstr "" 
+msgstr "``(?P=quote)`` (comme vu)" 
  
 #: ../Doc/library/re.rst:273 ../Doc/library/re.rst:280 
 msgid "``\\1``" 
@ -471,7 +685,7 @@ msgstr "``\\1``"
  
 #: ../Doc/library/re.rst:275 
 msgid "when processing match object ``m``" 
-msgstr "" 
+msgstr "en analysant l'objet résultat ``m``" 
  
 #: ../Doc/library/re.rst:275 
 msgid "``m.group('quote')``" 
@ -479,11 +693,11 @@ msgstr "``m.group('quote')``"
  
 #: ../Doc/library/re.rst:276 
 msgid "``m.end('quote')`` (etc.)" 
-msgstr "" 
+msgstr "``m.end('quote')`` (etc.)" 
  
 #: ../Doc/library/re.rst:278 
 msgid "in a string passed to the ``repl`` argument of ``re.sub()``" 
-msgstr "" 
+msgstr "dans une chaîne passée à l'argument ``repl`` de ``re.sub()``" 
  
 #: ../Doc/library/re.rst:278 
 msgid "``\\g<quote>``" 
@ -502,6 +716,8 @@ msgid ""
 "A backreference to a named group; it matches whatever text was matched by " 
 "the earlier group named *name*." 
 msgstr "" 
+"Une référence arrière à un groupe nommé ; elle correspond à n'importe quel " 
+"texte validé plus tôt par le groupe nommé *name*." 
  
 #: ../Doc/library/re.rst:288 
 msgid "``(?#...)``" 
@ -509,7 +725,7 @@ msgstr "``(?#...)``"
  
 #: ../Doc/library/re.rst:288 
 msgid "A comment; the contents of the parentheses are simply ignored." 
-msgstr "" 
+msgstr "Un commentaire ; le contenu des parenthèses est simplement ignoré." 
  
 #: ../Doc/library/re.rst:293 
 msgid "``(?=...)``" 
@ -521,6 +737,10 @@ msgid ""
 "This is called a lookahead assertion. For example, ``Isaac (?=Asimov)`` " 
 "will match ``'Isaac '`` only if it's followed by ``'Asimov'``." 
 msgstr "" 
+"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'``." 
  
 #: ../Doc/library/re.rst:298 
 msgid "``(?!...)``" 
@ -532,6 +752,9 @@ msgid ""
 "assertion. For example, ``Isaac (?!Asimov)`` will match ``'Isaac '`` only if " 
 "it's *not* followed by ``'Asimov'``." 
 msgstr "" 
+"Valide si ``...`` ne valide pas la suite. C'est une assertion *lookahead* " 
+"négative. Par exemple, ``Isaac (?!Asimov)`` correspondra à la chaîne " 
+"``'Isaac'`` seulement si elle *n'est pas* suivie par ``'Asimov'``." 
  
 #: ../Doc/library/re.rst:323 
 msgid "``(?<=...)``" 
@ -550,14 +773,25 @@ msgid ""
 "will most likely want to use the :func:`search` function rather than the :" 
 "func:`match` function:" 
 msgstr "" 
+"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 :dfn:`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 :func:`search` plutôt que la " 
+"fonction :func:`match` :" 
  
 #: ../Doc/library/re.rst:316 
 msgid "This example looks for a word following a hyphen:" 
-msgstr "" 
+msgstr "Cet exemple recherche un mot suivi d'un trait d'union :" 
  
 #: ../Doc/library/re.rst:322 
 msgid "Added support for group references of fixed length." 
-msgstr "" 
+msgstr "Ajout du support des références aux groupes de taille fixe." 
  
 #: ../Doc/library/re.rst:330 
 msgid "``(?<!...)``" 
@ -571,10 +805,16 @@ msgid ""
 "strings of some fixed length. Patterns which start with negative lookbehind " 
 "assertions may match at the beginning of the string being searched." 
 msgstr "" 
+"Valide si la position courante dans la chaîne n'est pas précédée par une " 
+"correspondance sur ``...``. On appelle cela une :dfn:`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." 
  
 #: ../Doc/library/re.rst:339 
 msgid "``(?(id/name)yes-pattern|no-pattern)``" 
-msgstr "" 
+msgstr "``(?(id/name)yes-pattern|no-pattern)``" 
  
 #: ../Doc/library/re.rst:333 
 msgid "" 
@ -585,6 +825,12 @@ msgid ""
 "``'<user@host.com>'`` as well as ``'user@host.com'``, but not with " 
 "``'<user@host.com'`` nor ``'user@host.com>'``." 
 msgstr "" 
+"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>'``." 
  
 #: ../Doc/library/re.rst:341 
 msgid "" 
@ -593,6 +839,11 @@ msgid ""
 "then the resulting RE will match the second character. For example, ``\\$`` " 
 "matches the character ``'$'``." 
 msgstr "" 
+"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 ``'$'``." 
  
 #: ../Doc/library/re.rst:354 
 msgid "``\\number``"