avancement du fichier : 80 %

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 "
+"nouveaux métacaractères et l'utilisation des groupes pour récupérer des "
-"portions de textes correspondante."
+"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 "
+"Recherche toutes les sous-chaînes de caractères où la RE correspond et les "
-"substituer par une chaîne de caractères différente "
+"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 ""