avancement du fichier : 80 %

2018-07-26 23:53:29 +02:00 · 2018-07-26 23:53:29 +02:00 · ef4e8e64e8
commit ef4e8e64e8
parent 520ac8092d
1 changed files with 297 additions and 27 deletions
--- a/howto/regex.po
+++ b/howto/regex.po
@ -6,7 +6,7 @@ msgstr ""
 "Project-Id-Version: Python 3.6\n" 
 "Report-Msgid-Bugs-To: \n" 
 "POT-Creation-Date: 2018-06-28 15:29+0200\n" 
-"PO-Revision-Date: 2018-07-24 23:31+0200\n" 
+"PO-Revision-Date: 2018-07-26 23:49+0200\n" 
 "Last-Translator: Nabil Bendafi <nabil@bendafi.fr>\n" 
 "Language-Team: FRENCH <traductions@lists.afpy.org>\n" 
 "Language: fr\n" 
@ -662,7 +662,7 @@ msgid ""
 msgstr "" 
 "Les expressions régulières sont compilées en objets motifs, qui possèdent " 
 "des méthodes pour diverses opérations telles que la recherche de " 
-"correspondances ou le remplacement dans les chaînes. ::" 
+"correspondances ou les substitutions dans les chaînes. ::" 
  
 #: ../Doc/howto/regex.rst:275 
 msgid "" 
@ -1075,7 +1075,7 @@ msgid ""
 "in a :exc:`DeprecationWarning` and will eventually become a :exc:" 
 "`SyntaxError`. See :ref:`the-backslash-plague`." 
 msgstr "" 
-"Le préfixe ``r`` , qui indique une chaîne brute littérale, est nécessaire " 
+"Le préfixe ``r``, qui indique une chaîne brute littérale, est nécessaire " 
 "dans cet exemple car les séquences d'échappement dans une chaîne littérale " 
 "qui ne sont pas reconnues par Python, alors qu'elles le sont par les " 
 "expressions régulières, induisent maintenant un :exc:`DeprecationWarning` et " 
@ -1417,18 +1417,20 @@ msgid ""
 msgstr "" 
 "Jusqu'à présent nous avons seulement couvert une partie des fonctionnalités " 
 "des expressions régulières. Dans cette section, nous couvrirons quelques " 
-"nouveaux métacaractères et comment utiliser les groupes pour récupérer des " 
-"portions de textes correspondante." 
+"nouveaux métacaractères et l'utilisation des groupes pour récupérer des " 
+"portions de textes correspondantes." 
  
 #: ../Doc/howto/regex.rst:681 
 msgid "More Metacharacters" 
-msgstr "Plus de métacaratères" 
+msgstr "Plus de métacaractères" 
  
 #: ../Doc/howto/regex.rst:683 
 msgid "" 
 "There are some metacharacters that we haven't covered yet. Most of them " 
 "will be covered in this section." 
 msgstr "" 
+"Nous n'avons pas encore couvert tous les métacaractères. Cette section " 
+"traite de la plupart de ceux que nous n'avons pas abordés." 
  
 #: ../Doc/howto/regex.rst:686 
 msgid "" 
@ -1441,6 +1443,15 @@ msgid ""
 "once at a given location, they can obviously be matched an infinite number " 
 "of times." 
 msgstr "" 
+"Certains métacaractères restants sont des :dfn:`assertions de largeur zéro` " 
+"(*zero-width assertions* en anglais). Ils ne font pas avancer le moteur dans " 
+"la chaîne de caractères ; ils ne consomment aucun caractère et ils " 
+"réussissent ou échouent tout simplement. Par exemple, ``\\b`` est une " 
+"assertion selon laquelle la position actuelle est située à la limite d'un " 
+"mot ; la position n'est pas modifiée par le \" \\b \". Cela signifie que les " 
+"assertions de largeur zéro ne doivent pas être répétées car, si elles " 
+"correspondent à un endroit donné, elles correspondent automatiquement un " 
+"nombre infini de fois." 
  
 #: ../Doc/howto/regex.rst:702 
 msgid "``|``" 
@ -1455,12 +1466,20 @@ msgid ""
 "``'Crow'`` or ``'Servo'``, not ``'Cro'``, a ``'w'`` or an ``'S'``, and " 
 "``'ervo'``." 
 msgstr "" 
+"Union ensembliste ou opérateur \"ou\". Si *A* et *B* sont des expressions " 
+"régulières, ``A|B`` correspond à toute chaine qui correspond à A ou à B. La " 
+"priorité de ``|`` est très faible afin de pouvoir effectuer simplement des " 
+"unions de chaînes de plusieurs caractères. ``Crow|Servo`` correspond avec " 
+"``'Crow'`` ou ``'Servo'``, mais pas avec ``'Cro'``, un ``'w'`` ou un " 
+"``'S'``, ou encore ``'ervo'``." 
  
 #: ../Doc/howto/regex.rst:701 
 msgid "" 
 "To match a literal ``'|'``, use ``\\|``, or enclose it inside a character " 
 "class, as in ``[|]``." 
 msgstr "" 
+"Pour correspondre avec un ``'|'`` littéral, utilisez ``\\|`` ou placez-le " 
+"dans une classe de caractères, comme ceci ``[|]``." 
  
 #: ../Doc/howto/regex.rst:717 
 msgid "``^``" 
@ -1473,32 +1492,42 @@ msgid ""
 "`MULTILINE` mode, this also matches immediately after each newline within " 
 "the string." 
 msgstr "" 
+"Correspond à un début de ligne. À moins que l'option :const:`MULTILINE` ne " 
+"soit activée, cela ne fait correspondre que le début de la chaîne. Dans le " 
+"mode :const:`MULTILINE`, cela fait aussi correspondre immédiatement après " 
+"chaque nouvelle ligne à l'intérieur de la chaîne." 
  
 #: ../Doc/howto/regex.rst:709 
 msgid "" 
 "For example, if you wish to match the word ``From`` only at the beginning of " 
 "a line, the RE to use is ``^From``. ::" 
 msgstr "" 
+"Par exemple, si vous voulez trouver le mot ``From`` uniquement quand il est " 
+"en début de ligne, la RE à utiliser est ``^From``. ::" 
  
 #: ../Doc/howto/regex.rst:717 
 msgid "To match a literal ``'^'``, use ``\\^``." 
-msgstr "" 
+msgstr "Pour trouver un ``'^'`` littéral, utilisez ``\\^``." 
  
 #: ../Doc/howto/regex.rst:731 
 msgid "``$``" 
-msgstr "" 
+msgstr "``$``" 
  
 #: ../Doc/howto/regex.rst:720 
 msgid "" 
 "Matches at the end of a line, which is defined as either the end of the " 
 "string, or any location followed by a newline character. ::" 
 msgstr "" 
+"Correspond à une fin de ligne, ce qui veut dire soit la fin de la chaîne, " 
+"soit tout emplacement qui est suivi du caractère de nouvelle ligne. ::" 
  
 #: ../Doc/howto/regex.rst:730 
 msgid "" 
 "To match a literal ``'$'``, use ``\\$`` or enclose it inside a character " 
 "class, as in ``[$]``." 
 msgstr "" 
+"Pour trouver un ``'$'`` littéral, utilisez ``\\$`` ou placez-le à " 
+"l'intérieur d'une classe de caractères, comme ceci ``[$]``." 
  
 #: ../Doc/howto/regex.rst:737 
 msgid "``\\A``" 
@ -1512,6 +1541,12 @@ msgid ""
 "string, but ``^`` may match at any location inside the string that follows a " 
 "newline character." 
 msgstr "" 
+"Correspond au début de la chaîne de caractère, uniquement. Si l'option :" 
+"const:`MULTILINE` n'est pas activée, ``\\A`` et ``^`` sont équivalents. Dans " 
+"le mode :const:`MULTILINE`, ils sont différents : ``\\A`` ne correspond " 
+"toujours qu'au début de la chaîne alors que ``^`` correspond aussi aux " 
+"emplacements situés immédiatement après une nouvelle ligne à l'intérieur de " 
+"la chaîne." 
  
 #: ../Doc/howto/regex.rst:740 
 msgid "``\\Z``" 
@ -1532,12 +1567,19 @@ msgid ""
 "characters, so the end of a word is indicated by whitespace or a non-" 
 "alphanumeric character." 
 msgstr "" 
+"Limite de mot. Cette une assertion de largeur zéro qui correspond uniquement " 
+"aux positions de début et de fin de mots. Un mot est défini comme une " 
+"séquence de caractères alphanumériques ; ainsi, la fin d'un mot est indiquée " 
+"par un \"blanc\" ou un caractère non-alphanumérique." 
  
 #: ../Doc/howto/regex.rst:748 
 msgid "" 
 "The following example matches ``class`` only when it's a complete word; it " 
 "won't match when it's contained inside another word. ::" 
 msgstr "" 
+"L'exemple suivant fait correspondre ``class`` seulement si c'est ce mot " 
+"complet ; il ne fait pas correspondre quand il est à l'intérieur d'un autre " 
+"mot. ::" 
  
 #: ../Doc/howto/regex.rst:759 
 msgid "" 
@ -1549,6 +1591,15 @@ msgid ""
 "won't match as you expect it to. The following example looks the same as our " 
 "previous RE, but omits the ``'r'`` in front of the RE string. ::" 
 msgstr "" 
+"Quand vous utilisez cette séquence spéciale, gardez deux choses à l'esprit. " 
+"Tout d'abord, c'est la pire collision entre les littéraux des chaînes Python " 
+"et les séquences d'expressions régulières. Dans les littéraux de chaîne de " 
+"caractères Python, ``\\b``` est le caractère de retour-arrière (*backspace* " 
+"en anglais), dont la valeur ASCII est 8. Si vous n'utilisez pas les chaînes " 
+"de caractères brutes, alors Python convertit le ``\\b`` en retour-arrière, " 
+"et votre RE ne correspond pas à ce que vous attendez. L'exemple suivant " 
+"ressemble à notre RE précédente, mais nous avons omis le ```'r'`` devant la " 
+"chaîne RE. ::" 
  
 #: ../Doc/howto/regex.rst:773 
 msgid "" 
@ -1556,6 +1607,9 @@ msgid ""
 "\\b`` represents the backspace character, for compatibility with Python's " 
 "string literals." 
 msgstr "" 
+"Ensuite, dans une classe de caractères, où cette assertion n'a pas lieu " 
+"d'être, ``\\b`` représente le caractère retour-arrière, afin d'être " 
+"compatible avec les littéraux de chaînes de caractères." 
  
 #: ../Doc/howto/regex.rst:780 
 msgid "``\\B``" 
@ -1566,6 +1620,9 @@ msgid ""
 "Another zero-width assertion, this is the opposite of ``\\b``, only matching " 
 "when the current position is not at a word boundary." 
 msgstr "" 
+"Encore une assertion de largeur zéro, qui est l'opposée de ``\\b``, c'est-à-" 
+"dire qu'elle fait correspondre uniquement les emplacements qui ne sont pas à " 
+"la limite d'un mot." 
  
 #: ../Doc/howto/regex.rst:783 
 msgid "Grouping" 
@ -1579,6 +1636,13 @@ msgid ""
 "of interest. For example, an RFC-822 header line is divided into a header " 
 "name and a value, separated by a ``':'``, like this:" 
 msgstr "" 
+"Souvent, vous avez besoin d'obtenir plus d'informations que le simple fait " 
+"que la RE corresponde ou non. Ainsi, les expressions régulières sont souvent " 
+"utilisées pour analyser des chaînes de caractères en écrivant une RE qui " 
+"divise une chaîne en plusieurs sous-groupes, correspondant chacun à une " 
+"information particulière. Par exemple, une ligne d'en-tête RFC-822 peut se " 
+"diviser en un nom d'en-tête et une valeur associée, séparés par un ``':'``, " 
+"comme ceci :" 
  
 #: ../Doc/howto/regex.rst:798 
 msgid "" 
@ -1586,6 +1650,9 @@ msgid ""
 "header line, and has one group which matches the header name, and another " 
 "group which matches the header's value." 
 msgstr "" 
+"Vous pouvez alors écrire une expression régulière qui fait correspondre une " 
+"ligne d'en-tête entière et qui comporte un groupe correspondant au nom de " 
+"l'en-tête, et un autre groupe correspondant à la valeur de l'en-tête." 
  
 #: ../Doc/howto/regex.rst:802 
 msgid "" 
@ -1596,6 +1663,12 @@ msgid ""
 "+``, ``?``, or ``{m,n}``. For example, ``(ab)*`` will match zero or more " 
 "repetitions of ``ab``. ::" 
 msgstr "" 
+"Les groupes sont délimités par les métacaractères marqueurs ``'('``et " 
+"``')'``. ``'('`` et ``')'`` ont à peu près le même sens que dans les " 
+"expressions mathématiques ; ils forment un groupe à partir des expressions " 
+"qu'ils encadrent ; vous pouvez le contenu d'un groupe à l'aide d'un " 
+"quantificateur, comme ``*``, ``+``, ``?`` ou ``{m,n}``. Par exemple, " 
+"``(ab)*`` correspond à zéro, une ou plusieurs fois ``ab``. ::" 
  
 #: ../Doc/howto/regex.rst:813 
 msgid "" 
@ -1608,6 +1681,15 @@ msgid ""
 "we'll see how to express groups that don't capture the span of text that " 
 "they match. ::" 
 msgstr "" 
+"Les groupes délimités par ``'('``et ``')'`` capturent également les indices " 
+"de début et de fin du texte avec lequel ils correspondent ; ces indices " 
+"peuvent être récupérés en passant un argument à :meth:`~re.Match.group`, :" 
+"meth:`~re.Match.start`, :meth:`~re.Match.end` ou :meth:`~re.Match.span`. Les " 
+"groupes sont numérotés à partir de 0, le groupe 0 est toujours présent ; " 
+"c'est l'ensemble de la RE, donc les méthodes de :ref:`l'objet correspondance " 
+"<match-objects>` ont le groupe 0 comme argument par défaut. Plus loin, nous " 
+"voyons comment exprimer les groupes qui ne capturent pas l'étendue du texte " 
+"avec lequel ils correspondent. ::" 
  
 #: ../Doc/howto/regex.rst:829 
 msgid "" 
@ -1615,6 +1697,10 @@ msgid ""
 "nested; to determine the number, just count the opening parenthesis " 
 "characters, going from left to right. ::" 
 msgstr "" 
+"Les sous-groupes sont numérotés de la gauche vers la droite, à partir de un. " 
+"Les groupes peuvent être imbriqués ; pour déterminer le numéro, il vous " 
+"suffit de compter le nombre de parenthèses ouvrantes de la gauche vers la " 
+"droite. ::" 
  
 #: ../Doc/howto/regex.rst:842 
 msgid "" 
@ -1622,12 +1708,18 @@ msgid ""
 "which case it will return a tuple containing the corresponding values for " 
 "those groups. ::" 
 msgstr "" 
+"Vous pouvez passer plusieurs numéros de groupes à :meth:`~re.Match.group` en " 
+"même temps, elle vous renvoie alors un *tuple* contenant les valeurs " 
+"correspondantes pour ces groupes. ::" 
  
 #: ../Doc/howto/regex.rst:848 
 msgid "" 
 "The :meth:`~re.Match.groups` method returns a tuple containing the strings " 
 "for all the subgroups, from 1 up to however many there are. ::" 
 msgstr "" 
+"La méthode :meth:`~re.Match.groups` renvoie un *tuple* contenant les " 
+"chaînes pour tous les sous-groupes, en commençant par le numéro 1 jusqu'au " 
+"dernier. ::" 
  
 #: ../Doc/howto/regex.rst:854 
 msgid "" 
@ -1639,10 +1731,18 @@ msgid ""
 "including arbitrary characters in a string, so be sure to use a raw string " 
 "when incorporating backreferences in a RE." 
 msgstr "" 
+"Les renvois dans un motif vous permettent de spécifier que le contenu d'un " 
+"groupe précédent doit aussi être trouvé à l'emplacement actuel dans la " 
+"chaîne. Par exemple, ``\\1`` réussit si le contenu du premier groupe se " 
+"trouve aussi à la position courante, sinon il échoue. Rappelez-vous que les " 
+"littéraux de chaînes Python utilisent aussi la barre oblique inverse suivie " 
+"d'un nombre pour insérer des caractères arbitraires dans une chaîne ; soyez " 
+"sûr d'utiliser une chaîne brute quand vous faites des renvois dans une RE." 
  
 #: ../Doc/howto/regex.rst:862 
 msgid "For example, the following RE detects doubled words in a string. ::" 
 msgstr "" 
+"Par exemple, la RE suivante détecte les mots doublés dans une chaîne. ::" 
  
 #: ../Doc/howto/regex.rst:868 
 msgid "" 
@ -1651,10 +1751,14 @@ msgid ""
 "you'll soon find out that they're *very* useful when performing string " 
 "substitutions." 
 msgstr "" 
+"Les renvois tels que celui-ci ne sont pas très utiles juste pour effectuer " 
+"une recherche dans une chaîne --- il n'y a que peu de formats de textes qui " 
+"répètent des données ainsi --- mais nous allons bientôt vous montrer qu'ils " 
+"sont *très* utiles pour effectuer des substitutions dans les chaînes." 
  
 #: ../Doc/howto/regex.rst:874 
 msgid "Non-capturing and Named Groups" 
-msgstr "" 
+msgstr "Groupes non capturant et groupes nommés" 
  
 #: ../Doc/howto/regex.rst:876 
 msgid "" 
@ -1664,6 +1768,13 @@ msgid ""
 "help with this problem. Both of them use a common syntax for regular " 
 "expression extensions, so we'll look at that first." 
 msgstr "" 
+"Les RE élaborées peuvent utiliser de nombreux groupes, à la fois pour " 
+"capturer des sous-chaînes intéressantes ainsi que pour regrouper et " 
+"structurer la RE elle-même. Dans les RE complexes, il devient difficile de " 
+"garder la trace des numéros de groupe. Deux caractéristiques aident à " 
+"résoudre ce problème, toutes deux utilisant la même syntaxe d'extension des " 
+"expressions régulières. Nous allons donc commencer en examinant cette " 
+"syntaxe." 
  
 #: ../Doc/howto/regex.rst:882 
 msgid "" 
@ -1675,6 +1786,13 @@ msgid ""
 "expressions would be assuming that ``&`` was a regular character and " 
 "wouldn't have escaped it by writing ``\\&`` or ``[&]``." 
 msgstr "" 
+"Perl 5 est bien connu pour ses puissantes extensions des expressions " 
+"régulières. Pour y arriver, les développeurs Perl ne pouvaient pas utiliser " 
+"de nouveaux métacaractères simples ou de nouvelles séquences commençant par " 
+"``\\`` sans que les RE Perl ne deviennent XXX différentes des RE standards. " 
+"S'ils avaient choisi ``&`` comme nouveau métacaractère, par exemple, les " 
+"anciennes expressions auraient considéré que ``&`` était un caractère " 
+"standard et ne l'aurait pas échappé en écrivant ``\\&`` ou ``[&]``." 
  
 #: ../Doc/howto/regex.rst:889 
 msgid "" 
@ -1686,6 +1804,14 @@ msgid ""
 "positive lookahead assertion) and ``(?:foo)`` is something else (a non-" 
 "capturing group containing the subexpression ``foo``)." 
 msgstr "" 
+"La solution adoptée par les développeurs Perl a été d'utiliser ``( ?...)`` " 
+"comme syntaxe d'extension. Placer ``?`` immédiatement après une parenthèse " 
+"était une erreur de syntaxe, parce que le ``?`` n'a alors rien à répéter. " 
+"Ainsi, cela n'a pas introduit de problème de compatibilité. Les caractères " 
+"qui suivent immédiatement le ``?`` indiquent quelle extension est utilisée, " 
+"donc ``(?=truc)`` est une chose (une assertion positive anticipée) et ``(?:" 
+"truc)`` est une autre chose (un groupe non capturant contenant la sous-" 
+"expression ``truc``)." 
  
 #: ../Doc/howto/regex.rst:897 
 msgid "" 
@ -1693,12 +1819,19 @@ msgid ""
 "Perl's extension syntax. If the first character after the question mark is " 
 "a ``P``, you know that it's an extension that's specific to Python." 
 msgstr "" 
+"Python gère plusieurs des extensions Perl et rajoute une extension à la " 
+"syntaxe des extensions Perl. Si le premier caractère après le point " 
+"d'interrogation est ``P``, cela signifie que c'est une extension spécifique " 
+"à Python." 
  
 #: ../Doc/howto/regex.rst:902 
 msgid "" 
 "Now that we've looked at the general extension syntax, we can return to the " 
 "features that simplify working with groups in complex REs." 
 msgstr "" 
+"Après avoir vu la syntaxe générale d'extension des RE, nous pouvons revenir " 
+"aux fonctionnalités qui simplifient le travail avec les groupes dans des RE " 
+"complexes." 
  
 #: ../Doc/howto/regex.rst:905 
 msgid "" 
@ -1707,6 +1840,11 @@ msgid ""
 "can make this fact explicit by using a non-capturing group: ``(?:...)``, " 
 "where you can replace the ``...`` with any other regular expression. ::" 
 msgstr "" 
+"Parfois, vous souhaitez utiliser un groupe pour marquer une partie de " 
+"l'expression régulière mais le contenu de ce groupe ne vous intéresse pas " 
+"vraiment. Vous pouvez l'indiquer explicitement en utilisant un groupe non " 
+"capturant : ``(?:...)``, où vous remplacez les ``...`` par n'importe quelle " 
+"expression régulière. ::" 
  
 #: ../Doc/howto/regex.rst:917 
 msgid "" 
@ -1720,12 +1858,25 @@ msgid ""
 "performance difference in searching between capturing and non-capturing " 
 "groups; neither form is any faster than the other." 
 msgstr "" 
+"À part le fait que vous n'avez pas accès au contenu du groupe, un groupe non " 
+"capturant se comporte exactement de la même manière qu'un groupe capturant ; " 
+"vous pouvez placer n'importe quoi dedans, spécifier une répétition avec un " 
+"métacaractère tel que ``*`` et l'imbriquer dans un autre groupe (capturant " 
+"ou pas). ``(?:...)`` est particulièrement utile quand vous modifiez des " 
+"motifs existants, puisque vous pouvez ajouter de nouveaux groupes sans " 
+"changer la façon dont les autres groupes sont numérotés. Nous devons " 
+"mentionner ici qu'il n'y a aucune différence de performance dans la " 
+"recherche de groupes capturant ou pas ; les deux formes travaillent à la " 
+"même vitesse." 
  
 #: ../Doc/howto/regex.rst:926 
 msgid "" 
 "A more significant feature is named groups: instead of referring to them by " 
 "numbers, groups can be referenced by a name." 
 msgstr "" 
+"Une fonctionnalité plus importante est le nommage des groupes : au lieu d'y " 
+"faire référence par des nombres, vous pouvez référencer des groupes par leur " 
+"nom." 
  
 #: ../Doc/howto/regex.rst:929 
 msgid "" 
@ -1738,6 +1889,15 @@ msgid ""
 "still given numbers, so you can retrieve information about a group in two " 
 "ways::" 
 msgstr "" 
+"La syntaxe pour nommer les groupes est l'une des extensions spécifiques à " 
+"Python : ``(?P<nom>....)```. *nom* est, vous vous en doutez, le nom du " 
+"groupe. Les groupes nommés se comportent exactement comme des groupes " 
+"capturant, sauf qu'ils associent en plus un nom à un groupe. Les méthodes " 
+"des :ref:`objets correspondance <match-objects>` qui gèrent les groupes " 
+"capturant acceptent toutes soit des entiers qui font référence aux numéros " 
+"des groupes, soit des chaînes de caractères qui désignent les noms des " 
+"groupes désirés. Les groupes nommés se voient toujours attribuer un numéro, " 
+"vous pouvez ainsi récupérer les informations d'un groupe de deux façons ::" 
  
 #: ../Doc/howto/regex.rst:944 
 msgid "" 
@ -1745,12 +1905,16 @@ msgid ""
 "instead of having to remember numbers. Here's an example RE from the :mod:" 
 "`imaplib` module::" 
 msgstr "" 
+"Les groupes nommés sont pratiques car il est plus facile de se rappeler un " 
+"nom qu'un numéro. Voici un exemple de RE tirée du module :mod:`imaplib` ::" 
  
 #: ../Doc/howto/regex.rst:955 
 msgid "" 
 "It's obviously much easier to retrieve ``m.group('zonem')``, instead of " 
 "having to remember to retrieve group 9." 
 msgstr "" 
+"Il est évidemment plus facile de récupérer ``m.group('zonem')`` que de se " 
+"rappeler de récupérer le groupe 9." 
  
 #: ../Doc/howto/regex.rst:958 
 msgid "" 
@ -1762,10 +1926,17 @@ msgid ""
 "words, ``\\b(\\w+)\\s+\\1\\b`` can also be written as ``\\b(?P<word>\\w+)\\s" 
 "+(?P=word)\\b``::" 
 msgstr "" 
+"La syntaxe des renvois dans une expression telle que ``(....)\\1`` fait " 
+"référence au numéro du groupe. Il y a naturellement une variante qui utilise " 
+"le nom du groupe au lieu du numéro. C'est une autre extension Python : ``(?" 
+"P=nom)`` indique que le contenu du groupe appelé *nom* doit correspondre à " 
+"nouveau avec l'emplacement courant. L'expression régulière pour trouver des " 
+"mots doublés, ``\\b(\\w+)\\s+\\1\\b`` peut ainsi être ré-écrite en ``\\b(?" 
+"P<mot>\\w+)\\s+(?P=mot)\\b`` ::" 
  
 #: ../Doc/howto/regex.rst:971 
 msgid "Lookahead Assertions" 
-msgstr "" 
+msgstr "Assertions prédictives" 
  
 #: ../Doc/howto/regex.rst:973 
 msgid "" 
@ -1773,6 +1944,9 @@ msgid ""
 "assertions are available in both positive and negative form, and look like " 
 "this:" 
 msgstr "" 
+"Une autre assertion de largeur zéro est l'assertion prédictive. Une " 
+"assertion prédictive peut s'exprimer sous deux formes, la positive et la " 
+"négative, comme ceci :" 
  
 #: ../Doc/howto/regex.rst:981 
 msgid "``(?=...)``" 
@ -1786,6 +1960,12 @@ msgid ""
 "tried, the matching engine doesn't advance at all; the rest of the pattern " 
 "is tried right where the assertion started." 
 msgstr "" 
+"Assertion prédictive positive. Elle réussit si l'expression régulière " 
+"contenue, représentée ici par ``...``, correspond effectivement à " 
+"l'emplacement courant ; dans le cas contraire, elle échoue. Mais, une fois " 
+"que l'expression contenue a été essayée, le moteur de correspondance " 
+"n'avance pas ; le reste du motif est testé à l'endroit même où l'assertion a " 
+"commencé." 
  
 #: ../Doc/howto/regex.rst:986 
 msgid "``(?!...)``" 
@ -1797,6 +1977,9 @@ msgid ""
 "assertion; it succeeds if the contained expression *doesn't* match at the " 
 "current position in the string." 
 msgstr "" 
+"Assertion prédictive négative. C'est l'opposée de l'assertion positive ; " 
+"elle réussit si l'expression régulière contenue *ne* correspond *pas* à " 
+"l'emplacement courant dans la chaine." 
  
 #: ../Doc/howto/regex.rst:988 
 msgid "" 
@ -1805,14 +1988,19 @@ msgid ""
 "name and an extension, separated by a ``.``. For example, in ``news.rc``, " 
 "``news`` is the base name, and ``rc`` is the filename's extension." 
 msgstr "" 
+"Pour rendre ceci plus concret, regardons le cas où une prédiction est utile. " 
+"Considérons un motif simple qui doit faire correspondre un nom de fichier et " 
+"le diviser en un nom de base et une extension, séparés par un ``.``. Par " 
+"exemple, dans ``news.rc``, ``news`` est le nom de base et ``rc`` est " 
+"l'extension du nom de fichier." 
  
 #: ../Doc/howto/regex.rst:993 
 msgid "The pattern to match this is quite simple:" 
-msgstr "Le motif de correspondance est plutôt simple: " 
+msgstr "Le motif de correspondance est plutôt simple :" 
  
 #: ../Doc/howto/regex.rst:995 
 msgid "``.*[.].*$``" 
-msgstr "" 
+msgstr "``.*[.].*$``" 
  
 #: ../Doc/howto/regex.rst:997 
 msgid "" 
@ -1823,12 +2011,21 @@ msgid ""
 "expression matches ``foo.bar`` and ``autoexec.bat`` and ``sendmail.cf`` and " 
 "``printers.conf``." 
 msgstr "" 
+"Notez que le ``.`` doit être traité spécialement car c'est un métacaractère, " 
+"nous le plaçons donc à l'intérieur d'une classe de caractères pour ne faire " 
+"correspondre que ce caractère spécifique. Notez également le ``$`` en fin ; " 
+"nous l'avons ajouté pour nous assurer que tout le reste de la chaîne est " 
+"bien inclus dans l'extension. Cette expression régulière fait correspondre " 
+"``truc.bar``, ``autoexec.bat``, ``sendmail.cf`` et ``printers.conf``." 
  
 #: ../Doc/howto/regex.rst:1004 
 msgid "" 
 "Now, consider complicating the problem a bit; what if you want to match " 
 "filenames where the extension is not ``bat``? Some incorrect attempts:" 
 msgstr "" 
+"Maintenant, compliquons un peu le problème ; si nous voulons faire " 
+"correspondre les noms de fichiers dont l'extension n'est pas ``bat`` ? voici " 
+"quelques tentatives incorrectes :" 
  
 #: ../Doc/howto/regex.rst:1007 
 msgid "" 
@ -1836,10 +2033,13 @@ msgid ""
 "requiring that the first character of the extension is not a ``b``. This is " 
 "wrong, because the pattern also doesn't match ``foo.bar``." 
 msgstr "" 
+"``.*[.][^b].*$`` Le premier essai ci-dessus tente d'exclure ``bat`` en " 
+"spécifiant que le premier caractère de l'extension ne doit pas être ``b``. " 
+"Cela ne fonctionne pas, car le motif n'accepte pas ``truc.bar``." 
  
 #: ../Doc/howto/regex.rst:1011 
 msgid "``.*[.]([^b]..|.[^a].|..[^t])$``" 
-msgstr "" 
+msgstr "``.*[.]([^b]..|.[^a].|..[^t])$``" 
  
 #: ../Doc/howto/regex.rst:1013 
 msgid "" 
@ -1851,10 +2051,18 @@ msgid ""
 "with a two-letter extension such as ``sendmail.cf``. We'll complicate the " 
 "pattern again in an effort to fix it." 
 msgstr "" 
+"L'expression devient plus confuse si nous essayons de réparer la première " 
+"solution en spécifiant l'un des cas suivants : le premier caractère de " 
+"l'extension n'est pas ``b`` ; le deuxième caractère n'est pas ``a`` ; ou le " 
+"troisième caractère n'est pas ``t```. Ce motif accepte ``truc.bar`` et " 
+"rejette ``autoexec.bat``, mais elle nécessite une extension de trois lettres " 
+"et n'accepte pas un nom de fichier avec une extension de deux lettres comme " 
+"``sendmail.cf``. Compliquons encore une fois le motif pour essayer de le " 
+"réparer." 
  
 #: ../Doc/howto/regex.rst:1021 
 msgid "``.*[.]([^b].?.?|.[^a]?.?|..?[^t]?)$``" 
-msgstr "" 
+msgstr "``.*[.]([^b].?.?|.[^a]?.?|..?[^t]?)$``" 
  
 #: ../Doc/howto/regex.rst:1023 
 msgid "" 
@ -1862,6 +2070,9 @@ msgid ""
 "order to allow matching extensions shorter than three characters, such as " 
 "``sendmail.cf``." 
 msgstr "" 
+"Pour cette troisième tentative, les deuxième et troisième lettres sont " 
+"devenues facultatives afin de permettre la correspondance avec des " 
+"extensions plus courtes que trois caractères, comme ``sendmail.cf``." 
  
 #: ../Doc/howto/regex.rst:1027 
 msgid "" 
@ -1870,10 +2081,14 @@ msgid ""
 "``bat`` and ``exe`` as extensions, the pattern would get even more " 
 "complicated and confusing." 
 msgstr "" 
+"Le motif devient vraiment compliqué maintenant, ce qui le rend difficile à " 
+"lire et à comprendre. Pire, si le problème change et que vous voulez exclure " 
+"à la fois ``bat`` et ``exe`` en tant qu'extensions, le modèle deviendra " 
+"encore plus compliqué et confus." 
  
 #: ../Doc/howto/regex.rst:1032 
 msgid "A negative lookahead cuts through all this confusion:" 
-msgstr "" 
+msgstr "Une assertion prédictive négative supprime toute cette confusion :" 
  
 #: ../Doc/howto/regex.rst:1034 
 msgid "" 
@ -1884,6 +2099,13 @@ msgid ""
 "starts with ``bat``, will be allowed. The ``[^.]*`` makes sure that the " 
 "pattern works when there are multiple dots in the filename." 
 msgstr "" 
+"``.*[.](?!bat$)[^.]*$`` Cette assertion prédictive négative signifie : si " 
+"l'expression ``bat`` ne correspond pas à cet emplacement, essaie le reste du " 
+"motif ; si ``bat$`` correspond, tout le motif échoue. Le ``$`` est " 
+"nécessaire pour s'assurer que quelque chose comme ``sample.batch``, où c'est " 
+"seulement le début de l'extension qui vaut ``bat``, est autorisé. Le " 
+"``[^...]*`` s'assure que le motif fonctionne lorsqu'il y a plusieurs points " 
+"dans le nom de fichier." 
  
 #: ../Doc/howto/regex.rst:1041 
 msgid "" 
@ -1891,14 +2113,17 @@ msgid ""
 "alternative inside the assertion. The following pattern excludes filenames " 
 "that end in either ``bat`` or ``exe``:" 
 msgstr "" 
+"Exclure une autre extension de nom de fichier est maintenant facile ; il " 
+"suffit de l'ajouter comme alternative à l'intérieur de l'assertion. Le motif " 
+"suivant exclut les noms de fichiers qui se terminent par ``bat`` ou ``exe`` :" 
  
 #: ../Doc/howto/regex.rst:1045 
 msgid "``.*[.](?!bat$|exe$)[^.]*$``" 
-msgstr "" 
+msgstr "``.*[.](?!bat$|exe$)[^.]*$``" 
  
 #: ../Doc/howto/regex.rst:1049 
 msgid "Modifying Strings" 
-msgstr "" 
+msgstr "Modification de chaînes" 
  
 #: ../Doc/howto/regex.rst:1051 
 msgid "" 
@ -1906,10 +2131,14 @@ msgid ""
 "Regular expressions are also commonly used to modify strings in various " 
 "ways, using the following pattern methods:" 
 msgstr "" 
+"Jusqu'à présent, nous avons simplement effectué des recherches dans une " 
+"chaîne statique. Les expressions régulières sont aussi couramment utilisées " 
+"pour modifier les chaînes de caractères de diverses manières, en utilisant " 
+"les méthodes suivantes des motifs :" 
  
 #: ../Doc/howto/regex.rst:1058 
 msgid "``split()``" 
-msgstr "" 
+msgstr "``split()``" 
  
 #: ../Doc/howto/regex.rst:1058 
 msgid "Split the string into a list, splitting it wherever the RE matches" 
@ -1919,29 +2148,31 @@ msgstr ""
  
 #: ../Doc/howto/regex.rst:1061 
 msgid "``sub()``" 
-msgstr "" 
+msgstr "``sub()``" 
  
 #: ../Doc/howto/regex.rst:1061 
 msgid "" 
 "Find all substrings where the RE matches, and replace them with a different " 
 "string" 
 msgstr "" 
-"Rechercher toutes les sous-chaînes de caractères où correspond la RE et les " 
-"substituer par une chaîne de caractères différente " 
+"Recherche toutes les sous-chaînes de caractères où la RE correspond et les " 
+"substitue par une chaîne de caractères différente" 
  
 #: ../Doc/howto/regex.rst:1064 
 msgid "``subn()``" 
-msgstr "" 
+msgstr "``subn()``" 
  
 #: ../Doc/howto/regex.rst:1064 
 msgid "" 
 "Does the same thing as :meth:`!sub`, but returns the new string and the " 
 "number of replacements" 
 msgstr "" 
+"Fait la même chose que :meth:`!sub`, mais renvoie la nouvelle chaîne et le " 
+"nombre de remplacements effectués" 
  
 #: ../Doc/howto/regex.rst:1071 
 msgid "Splitting Strings" 
-msgstr "" 
+msgstr "Découpage de chaînes" 
  
 #: ../Doc/howto/regex.rst:1073 
 msgid "" 
@ -1952,6 +2183,13 @@ msgid ""
 "splitting by whitespace or by a fixed string. As you'd expect, there's a " 
 "module-level :func:`re.split` function, too." 
 msgstr "" 
+"La méthode :meth:`~re.Pattern.Pattern.split` d'un motif divise une chaîne de " 
+"caractères à chaque fois que la RE correspond, retournant la liste des " 
+"morceaux. C'est similaire à la méthode :meth:`~str.split` mais est beaucoup " 
+"plus générale par les délimiteurs que vous pouvez spécifier ; string :meth:`!" 
+"split` ne gère que les découpage en suivant les \"blancs\" ou suivant une " 
+"chaîne définie. Comme vous pouvez vous y attendre, il y a aussi une " 
+"fonction :func:`re.split` de niveau module." 
  
 #: ../Doc/howto/regex.rst:1084 
 msgid "" 
@ -1960,6 +2198,10 @@ msgid ""
 "part of the resulting list. If *maxsplit* is nonzero, at most *maxsplit* " 
 "splits are performed." 
 msgstr "" 
+"Découpe *string* en suivant les correspondances de l'expression régulière. " 
+"Si des parenthèses de capture sont utilisées dans la RE, leur contenu est " 
+"également renvoyé dans la liste résultante. Si *maxsplit* n'est pas nul, au " 
+"plus *maxsplit* découpages sont effectués." 
  
 #: ../Doc/howto/regex.rst:1089 
 msgid "" 
@ -1969,6 +2211,11 @@ msgid ""
 "the following example, the delimiter is any sequence of non-alphanumeric " 
 "characters. ::" 
 msgstr "" 
+"Vous pouvez limiter le nombre de découpages effectués en passant une valeur " 
+"pour *maxsplit*. Quand *maxsplit* n'est pas nul, au plus *maxsplit* " 
+"découpages sont effectués et le reste de la chaîne est renvoyé comme dernier " 
+"élément de la liste. Dans l'exemple suivant, le délimiteur est toute " 
+"séquence de caractères non alphanumériques. ::" 
  
 #: ../Doc/howto/regex.rst:1101 
 msgid "" 
@ -1977,12 +2224,18 @@ msgid ""
 "used in the RE, then their values are also returned as part of the list. " 
 "Compare the following calls::" 
 msgstr "" 
+"Parfois, vous voulez récupérer le texte entre les délimiteurs mais aussi " 
+"quel était le délimiteur. Si des parenthèses de capture sont utilisées dans " 
+"la RE, leurs valeurs sont également renvoyées dans la liste. Comparons les " 
+"appels suivants ::" 
  
 #: ../Doc/howto/regex.rst:1113 
 msgid "" 
 "The module-level function :func:`re.split` adds the RE to be used as the " 
 "first argument, but is otherwise the same. ::" 
 msgstr "" 
+"La fonction de niveau module :func:`re.split` ajoute la RE à utiliser comme " 
+"premier argument, mais est par ailleurs identique. ::" 
  
 #: ../Doc/howto/regex.rst:1125 
 msgid "Search and Replace" 
@ -1995,6 +2248,10 @@ msgid ""
 "replacement value, which can be either a string or a function, and the " 
 "string to be processed." 
 msgstr "" 
+"Une autre tâche classique est de trouver toutes les correspondances d'un " 
+"motif et de les remplacer par une autre chaîne. La méthode :meth:`~re." 
+"Pattern.sub` prend une valeur de substitution, qui peut être une chaîne de " 
+"caractères ou une fonction, et la chaîne à traiter." 
  
 #: ../Doc/howto/regex.rst:1134 
 msgid "" 
@ -2002,6 +2259,9 @@ msgid ""
 "occurrences of the RE in *string* by the replacement *replacement*. If the " 
 "pattern isn't found, *string* is returned unchanged." 
 msgstr "" 
+"Renvoie la chaîne obtenue en remplaçant les occurrences sans chevauchement " 
+"les plus à gauche de la RE dans *string* par la substitution *replacement*. " 
+"Si le motif n'est pas trouvé, *string* est renvoyée inchangée." 
  
 #: ../Doc/howto/regex.rst:1138 
 msgid "" 
@ -2009,12 +2269,17 @@ msgid ""
 "to be replaced; *count* must be a non-negative integer. The default value " 
 "of 0 means to replace all occurrences." 
 msgstr "" 
+"L'argument optionnel *count* est le nombre maximum d'occurrences du motif à " 
+"remplacer ; *count* doit être un entier positif ou nul. La valeur par défaut " 
+"de 0 signifie qu'il faut remplacer toutes les occurrences." 
  
 #: ../Doc/howto/regex.rst:1142 
 msgid "" 
 "Here's a simple example of using the :meth:`~re.Pattern.sub` method. It " 
 "replaces colour names with the word ``colour``::" 
 msgstr "" 
+"Voici un exemple simple utilisant la méthode :meth:`~re.Pattern.sub`. Nous " 
+"remplaçons les noms des couleurs par le mot ``colour`` ::" 
  
 #: ../Doc/howto/regex.rst:1151 
 msgid "" 
@ -2022,12 +2287,17 @@ msgid ""
 "tuple containing the new string value and the number of replacements that " 
 "were performed::" 
 msgstr "" 
+"La méthode :meth:`~re.Pattern.subn.subn` fait la même chose mais retourne un " 
+"couple contenant la nouvelle valeur de la chaîne de caractères et le nombre " 
+"de remplacements effectués ::" 
  
 #: ../Doc/howto/regex.rst:1160 
 msgid "" 
 "Empty matches are replaced only when they're not adjacent to a previous " 
 "empty match. ::" 
 msgstr "" 
+"Les correspondances vides ne sont remplacées que lorsqu'elles ne sont pas " 
+"adjacentes à une correspondance vide précédente. ::" 
  
 #: ../Doc/howto/regex.rst:1167 
 msgid "" 
@ -2085,7 +2355,7 @@ msgstr ""
  
 #: ../Doc/howto/regex.rst:1224 
 msgid "Common Problems" 
-msgstr "Problèmes courants" 
+msgstr "Problèmes classiques" 
  
 #: ../Doc/howto/regex.rst:1226 
 msgid "" 
@ -2097,7 +2367,7 @@ msgstr ""
  
 #: ../Doc/howto/regex.rst:1232 
 msgid "Use String Methods" 
-msgstr "" 
+msgstr "Utilisez les méthodes des *string*" 
  
 #: ../Doc/howto/regex.rst:1234 
 msgid "" 
@ -2180,7 +2450,7 @@ msgstr ""
  
 #: ../Doc/howto/regex.rst:1298 
 msgid "Greedy versus Non-Greedy" 
-msgstr "" 
+msgstr "Glouton contre non-glouton" 
  
 #: ../Doc/howto/regex.rst:1300 
 msgid "" 
@ -2256,7 +2526,7 @@ msgstr "Ceci est beaucoup plus lisible que::"
  
 #: ../Doc/howto/regex.rst:1372 
 msgid "Feedback" 
-msgstr "Retour" 
+msgstr "Vos commentaires" 
  
 #: ../Doc/howto/regex.rst:1374 
 msgid ""