Review re.po

2017-09-22 17:50:23 +02:00 · 2017-09-22 17:50:23 +02:00 · a0487b756c
commit a0487b756c
parent 79858c16bb
1 changed files with 81 additions and 84 deletions
--- a/library/re.po
+++ b/library/re.po
@ -1,21 +1,19 @@
-# SOME DESCRIPTIVE TITLE. 
 # Copyright (C) 2001-2016, Python Software Foundation 
 # This file is distributed under the same license as the Python package. 
 # FIRST AUTHOR <EMAIL@ADDRESS>, YEAR. 
-# 
 msgid "" 
 msgstr "" 
 "Project-Id-Version: Python 3.6\n" 
 "Report-Msgid-Bugs-To: \n" 
 "POT-Creation-Date: 2018-01-04 15:51+0100\n" 
-"PO-Revision-Date: 2017-12-03 13:59+0100\n" 
+"PO-Revision-Date: 2018-01-29 00:08+0100\n" 
 "Last-Translator: Julien Palard <julien@palard.fr>\n" 
 "Language-Team: \n" 
 "Language: fr\n" 
 "MIME-Version: 1.0\n" 
 "Content-Type: text/plain; charset=UTF-8\n" 
 "Content-Transfer-Encoding: 8bit\n" 
-"X-Generator: Poedit 2.0.2\n" 
+"X-Generator: Poedit 2.0.4\n" 
  
 #: ../Doc/library/re.rst:2 
 msgid ":mod:`re` --- Regular expression operations" 
@ -30,8 +28,8 @@ 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." 
+"Ce module fournit des opérations sur les expressions rationnelles similaires " 
+"à celles que l'on trouve dans Perl." 
  
 #: ../Doc/library/re.rst:17 
 msgid "" 
@ -42,12 +40,12 @@ msgid ""
 "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 " 
-"(:class:`str`) que des chaînes d'octets (:class:`bytes`). 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." 
+"Les motifs, comme les chaînes, à analyser peuvent aussi bien être des " 
+"chaînes Unicode que des chaînes 8-bits. 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." 
  
 #: ../Doc/library/re.rst:24 
 msgid "" 
@ -61,12 +59,12 @@ msgid ""
 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 " 
+"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." 
+"rationnelle devrait être ``\\\\`` et chaque *backslash* doit être représenté " 
+"par ``\\\\`` au sein des chaînes littérales Python." 
  
 #: ../Doc/library/re.rst:33 
 msgid "" 
@ -78,12 +76,12 @@ msgid ""
 "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." 
+"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." 
  
 #: ../Doc/library/re.rst:40 
 msgid "" 
@ -94,7 +92,7 @@ msgid ""
 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 " 
+"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." 
@ -145,12 +143,12 @@ msgstr ""
 "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 " 
+"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 " 
-"Frield référencé plus tôt, ou à peu près n'importe quel livre dédié à la " 
+"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 " 
+"référencé plus tôt, ou à peu près n'importe quel livre dédié à la " 
 "construction de compilateurs." 
  
 #: ../Doc/library/re.rst:73 
@ -159,9 +157,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`." 
+"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 :ref:`regex-howto`." 
  
 #: ../Doc/library/re.rst:76 
 msgid "" 
@ -175,8 +173,8 @@ 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'``.  " 
+"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'``.)" 
@ -202,7 +200,7 @@ msgid ""
 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 " 
+"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 " 
@ -222,8 +220,8 @@ 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 " 
+"(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:103 
@ -235,7 +233,7 @@ 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 " 
+"(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:112 
@ -255,8 +253,8 @@ msgid ""
 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 " 
+"`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 " 
@ -272,9 +270,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'." 
+"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'." 
  
 #: ../Doc/library/re.rst:122 
 msgid "``+``" 
@ -286,9 +284,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'." 
+"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'." 
  
 #: ../Doc/library/re.rst:126 
 msgid "``?``" 
@ -299,8 +297,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'." 
+"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'." 
  
 #: ../Doc/library/re.rst:135 
 msgid "``*?``, ``+?``, ``??``" 
@ -337,7 +335,7 @@ msgid ""
 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 " 
+"l'expression entière de correspondre. Par exemple, ``a{6}`` correspondra " 
 "exactement à six caractères ``'a'``, mais pas à cinq." 
  
 #: ../Doc/library/re.rst:149 
@ -355,7 +353,7 @@ msgid ""
 "not 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* " 
+"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 " 
@ -376,12 +374,11 @@ 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* " 
+"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." 
+"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:169 
 msgid "``\\``" 
@ -393,9 +390,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." 
+"É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." 
  
 #: ../Doc/library/re.rst:163 
 msgid "" 
@ -411,11 +408,11 @@ msgstr ""
 "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 " 
-"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." 
+"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." 
  
 #: ../Doc/library/re.rst:201 
 msgid "``[]``" 
@ -423,7 +420,7 @@ msgstr "``[]``"
  
 #: ../Doc/library/re.rst:172 
 msgid "Used to indicate a set of characters. In a set:" 
-msgstr "Utilisé pour indiquer un ensemble de caractères.  Dans un ensemble :" 
+msgstr "Utilisé pour indiquer un ensemble de caractères. Dans un ensemble :" 
  
 #: ../Doc/library/re.rst:174 
 msgid "" 
@ -456,7 +453,7 @@ msgid ""
 "``[(+*)]`` will match any of the literal characters ``'('``, ``'+'``, " 
 "``'*'``, or ``')'``." 
 msgstr "" 
-"Les caractères spéciaux perdent leur sens à l'intérieur des ensembles.  Par " 
+"Les caractères spéciaux perdent leur sens à l'intérieur des ensembles. Par " 
 "exemple, ``[(+*)]`` validera chacun des caractères littéraux ``'('``, " 
 "``'+'``, ``'*'`` ou ``')'``." 
  
@ -481,12 +478,12 @@ msgid ""
 "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." 
+"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:199 
 msgid "" 
@ -495,9 +492,9 @@ msgid ""
 "``[]()[{}]`` 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." 
+"*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:212 
 msgid "``|``" 
@ -516,7 +513,7 @@ msgid ""
 "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 " 
+"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 " 
@ -543,7 +540,7 @@ msgid ""
 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 " 
+"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 : " 
@ -562,7 +559,7 @@ msgid ""
 "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 " 
+"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." 
@ -585,8 +582,8 @@ msgid ""
 "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* " 
+"``'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), :const:`re.U` (support d'Unicode) et :" 
@ -608,7 +605,7 @@ 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 " 
+"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." 
@ -659,9 +656,9 @@ 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)." 
+"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\"" 
@ -1506,7 +1503,7 @@ msgstr ""
 #: ../Doc/library/re.rst:715 ../Doc/library/re.rst:793 
 #: ../Doc/library/re.rst:813 
 msgid "Added the optional flags argument." 
-msgstr "Ajout de l'argument optionnel *flags*" 
+msgstr "Ajout de l'argument optionnel *flags*." 
  
 #: ../Doc/library/re.rst:718 
 msgid "" 
@ -2378,8 +2375,8 @@ msgid ""
 "separate the house number from the street name:" 
 msgstr "" 
 "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." 
+"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 :" 
  
 #: ../Doc/library/re.rst:1415 
 msgid "Text Munging"