Traduction terminée. Besoin de relecture.

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-26 23:49+0200\n"
+"PO-Revision-Date: 2018-07-27 10:54+0200\n"
 "Last-Translator: Nabil Bendafi <nabil@bendafi.fr>\n"
 "Language-Team: FRENCH <traductions@lists.afpy.org>\n"
 "Language: fr\n"
@@ -81,13 +81,14 @@ msgid ""
 "requires that you have a good understanding of the matching engine's "
 "internals."
 msgstr ""
-"Un motif d'expression régulière est compilé en **bytecode** qui est ensuite "
-"exécuté par un moteur de correspondance écrit en C. Pour une utilisation "
-"plus poussée, il peut s'avérer nécessaire de s'intéresser à la manière dont "
-"le moteur exécute la RE afin d'écrire une expression dont le **bytecode** "
-"est plus rapide. L'optimisation n'est pas traitée dans ce document, parce "
-"qu'elle nécessite d'avoir une bonne compréhension des mécanismes internes du "
-"moteur de correspondance."
+"Un motif d'expression régulière est compilé en code intermédiaire "
+"(*bytecode* en anglais) qui est ensuite exécuté par un moteur de "
+"correspondance écrit en C. Pour une utilisation plus poussée, il peut "
+"s'avérer nécessaire de s'intéresser à la manière dont le moteur exécute la "
+"RE afin d'écrire une expression dont le code intermédiaire est plus rapide. "
+"L'optimisation n'est pas traitée dans ce document, parce qu'elle nécessite "
+"d'avoir une bonne compréhension des mécanismes internes du moteur de "
+"correspondance."
 
 #: ../Doc/howto/regex.rst:42
 msgid ""
@@ -238,8 +239,8 @@ msgstr ""
 "pour signaler différentes séquences spéciales. Elle est aussi utilisée pour "
 "échapper tous les métacaractères afin d'en trouver les correspondances dans "
 "les motifs ; par exemple, si vous devez trouver une correspondance pour "
-"``[`` ou ``\\`, vous pouvez les précéder avec une barre oblique inverse pour "
-"annihiler leur signification spéciale : ``\\[`` ou ``\\\\``."
+"``[`` ou ``\\``, vous pouvez les précéder avec une barre oblique inverse "
+"pour annihiler leur signification spéciale : ``\\[`` ou ``\\\\``."
 
 #: ../Doc/howto/regex.rst:109
 msgid ""
@@ -662,7 +663,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 les substitutions dans les chaînes. ::"
+"correspondances ou les substitutions dans les chaînes. ::"
 
 #: ../Doc/howto/regex.rst:275
 msgid ""
@@ -863,7 +864,7 @@ msgid ""
 "for a complete listing."
 msgstr ""
 "Une fois que nous avons un objet représentant une expression régulière "
-"compilée, qu'en faisons-nous ? Les objets motifs ont plusieurs méthodes et "
+"compilée, qu'en faisons-nous ? Les objets motifs ont plusieurs méthodes et "
 "attributs. Seuls les plus significatifs seront couverts ici ; consultez la "
 "documentation :mod:`re` pour la liste complète."
 
@@ -968,7 +969,7 @@ msgstr ""
 "indique \"une ou plusieurs occurrences\". :meth:`~re.Pattern.match` doit "
 "renvoyer ``None`` dans ce cas, ce qui fait que l'interpréteur n'affiche "
 "rien. Vous pouvez afficher le résultat de :meth:`!match` explicitement pour "
-"que ce soit clair. ::"
+"que ce soit clair. ::"
 
 #: ../Doc/howto/regex.rst:404
 msgid ""
@@ -979,7 +980,7 @@ msgstr ""
 "Maintenant, essayons sur une chaîne qui doit correspondre, par exemple "
 "``tempo``. Dans ce cas, :meth:`~re.Pattern.match` renvoie un :ref:`objet "
 "correspondance <match-objects>`, vous pouvez ainsi stocker le résultat dans "
-"une variable pour une utilisation ultérieure. ::"
+"une variable pour une utilisation ultérieure. ::"
 
 #: ../Doc/howto/regex.rst:412
 msgid ""
@@ -1091,8 +1092,8 @@ msgid ""
 msgstr ""
 ":meth:`~re.Pattern.findall` doit créer la liste entière avant d'être renvoyé "
 "comme résultat. La méthode :meth:`~re.Pattern.finditer` renvoie une séquence "
-"d'instances :ref:`d'objets correspondances <match-objects>` en tant qu'\\ :"
-"term:`itérateur <iterator>` ::"
+"d'instances :ref:`d'objets correspondances <match-objects>` en tant :term:"
+"`qu'itérateur <iterator>` ::"
 
 #: ../Doc/howto/regex.rst:495
 msgid "Module-Level Functions"
@@ -1113,7 +1114,7 @@ msgstr ""
 "suite. Ces fonctions prennent les mêmes arguments que les méthodes "
 "correspondantes des objets motifs, avec la chaîne RE ajoutée en tant que "
 "premier argument. Elles renvoient toujours ``None`` ou une instance  :ref:"
-"`d'objet correspondance <match-objects>`. ::"
+"`d'objet correspondance <match-objects>`. ::"
 
 #: ../Doc/howto/regex.rst:509
 msgid ""
@@ -1301,7 +1302,7 @@ msgstr ""
 "Par exemple, si vous traitez du texte français, vous souhaitez pouvoir "
 "écrire ``\\w+`` pour faire correspondre les mots, mais ``\\w`` ne correspond "
 "qu'à la classe de caractères ``[A-Za-za-z]`` en octets ; cette classe ne "
-"correspond pas avec les octets codant ``é`` ou ``ç```. Si votre système est "
+"correspond pas avec les octets codant ``é`` ou ``ç``. Si votre système est "
 "configuré correctement et que la locale est définie sur 'français', "
 "certaines fonctions C diront à votre programme que l'octet codant ``é`` doit "
 "être considéré comme une lettre. Définir l'option :const:`LOCALE` lors de la "
@@ -1335,7 +1336,7 @@ msgstr ""
 "Normalement, ``^`` correspond uniquement au début de la chaîne, et ``$`` "
 "correspond uniquement à la fin de la chaîne et immédiatement avant la "
 "nouvelle ligne (s'il y en a une) à la fin de la chaîne. Lorsque cette option "
-"est spécifiée, ``^``` correspond au début de la chaîne de caractères et au "
+"est spécifiée, ``^`` correspond au début de la chaîne de caractères et au "
 "début de chaque ligne de la chaîne de caractères, immédiatement après le "
 "début de la nouvelle ligne. De même, le métacaractère ``$`` correspond à la "
 "fin de la chaîne de caractères ou à la fin de chaque ligne (précédant "
@@ -1407,7 +1408,7 @@ msgstr ""
 
 #: ../Doc/howto/regex.rst:671
 msgid "More Pattern Power"
-msgstr ""
+msgstr "Des motifs plus puissants"
 
 #: ../Doc/howto/regex.rst:673
 msgid ""
@@ -1503,7 +1504,7 @@ msgid ""
 "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``. ::"
+"en début de ligne, la RE à utiliser est ``^From``. ::"
 
 #: ../Doc/howto/regex.rst:717
 msgid "To match a literal ``'^'``, use ``\\^``."
@@ -1519,7 +1520,7 @@ msgid ""
 "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. ::"
+"soit tout emplacement qui est suivi du caractère de nouvelle ligne. ::"
 
 #: ../Doc/howto/regex.rst:730
 msgid ""
@@ -1579,7 +1580,7 @@ msgid ""
 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. ::"
+"mot. ::"
 
 #: ../Doc/howto/regex.rst:759
 msgid ""
@@ -1599,7 +1600,7 @@ msgstr ""
 "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. ::"
+"chaîne RE. ::"
 
 #: ../Doc/howto/regex.rst:773
 msgid ""
@@ -1668,7 +1669,7 @@ msgstr ""
 "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``. ::"
+"``(ab)*`` correspond à zéro, une ou plusieurs fois ``ab``. ::"
 
 #: ../Doc/howto/regex.rst:813
 msgid ""
@@ -1689,7 +1690,7 @@ msgstr ""
 "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. ::"
+"avec lequel ils correspondent. ::"
 
 #: ../Doc/howto/regex.rst:829
 msgid ""
@@ -1700,7 +1701,7 @@ 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. ::"
+"droite. ::"
 
 #: ../Doc/howto/regex.rst:842
 msgid ""
@@ -1710,7 +1711,7 @@ msgid ""
 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. ::"
+"correspondantes pour ces groupes. ::"
 
 #: ../Doc/howto/regex.rst:848
 msgid ""
@@ -1719,7 +1720,7 @@ msgid ""
 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. ::"
+"dernier. ::"
 
 #: ../Doc/howto/regex.rst:854
 msgid ""
@@ -1742,7 +1743,7 @@ msgstr ""
 #: ../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. ::"
+"Par exemple, la RE suivante détecte les mots doublés dans une chaîne. ::"
 
 #: ../Doc/howto/regex.rst:868
 msgid ""
@@ -1789,10 +1790,11 @@ 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 ``[&]``."
+"``\\`` sans que les RE Perl ne deviennent trop différentes des RE standards "
+"au point de créer de la confusion. 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 ""
@@ -1804,7 +1806,7 @@ 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 ``( ?...)`` "
+"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 "
@@ -1844,7 +1846,7 @@ msgstr ""
 "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. ::"
+"expression régulière. ::"
 
 #: ../Doc/howto/regex.rst:917
 msgid ""
@@ -2187,7 +2189,7 @@ msgstr ""
 "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 "
+"split` ne gère que les découpages 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."
 
@@ -2215,7 +2217,7 @@ msgstr ""
 "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. ::"
+"séquence de caractères non alphanumériques. ::"
 
 #: ../Doc/howto/regex.rst:1101
 msgid ""
@@ -2235,11 +2237,11 @@ msgid ""
 "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. ::"
+"premier argument, mais est par ailleurs identique. ::"
 
 #: ../Doc/howto/regex.rst:1125
 msgid "Search and Replace"
-msgstr "Recherche et Substitution"
+msgstr "Recherche et substitution"
 
 #: ../Doc/howto/regex.rst:1127
 msgid ""
@@ -2297,7 +2299,7 @@ msgid ""
 "empty match. ::"
 msgstr ""
 "Les correspondances vides ne sont remplacées que lorsqu'elles ne sont pas "
-"adjacentes à une correspondance vide précédente. ::"
+"adjacentes à une correspondance vide précédente. ::"
 
 #: ../Doc/howto/regex.rst:1167
 msgid ""
@@ -2309,12 +2311,21 @@ msgid ""
 "incorporate portions of the original text in the resulting replacement "
 "string."
 msgstr ""
+"Si *replacement* est une chaîne de caractères, toute barre oblique inverse "
+"d'échappement est traitée.  C'est-à-dire que ```\\n`` est converti en "
+"caractère de nouvelle ligne, ``\\r`` est converti en retour chariot, et "
+"ainsi de suite. Les échappements inconnus comme ``\\&`` sont laissés tels "
+"quels. Les renvois, tels que ``\\6``, sont remplacés par la sous-chaîne "
+"correspondante au groupe dans le RE. Ceci vous permet d'incorporer des "
+"parties du texte original dans la chaîne de remplacement résultante."
 
 #: ../Doc/howto/regex.rst:1174
 msgid ""
 "This example matches the word ``section`` followed by a string enclosed in "
 "``{``, ``}``, and changes ``section`` to ``subsection``::"
 msgstr ""
+"Cet exemple fait correspondre le mot ``section`` suivi par une chaîne "
+"encadrée par  ``{`` et ``}``, et modifie ``section`` en ``subsection`` ::"
 
 #: ../Doc/howto/regex.rst:1181
 msgid ""
@@ -2327,6 +2338,15 @@ msgid ""
 "literal character ``'0'``.)  The following substitutions are all equivalent, "
 "but use all three variations of the replacement string. ::"
 msgstr ""
+"Il existe aussi une syntaxe pour faire référence aux groupes nommés définis "
+"par la syntaxe ``(?P<nom>....)``. ``\\g<nom>`` utilise la sous-chaîne "
+"correspondante au groupe nommé ``nom`` et ``\\g<numéro>`` utilise le numéro "
+"de groupe correspondant. ``\\g<2>`` est donc l'équivalent de ``\\2``, mais "
+"n'est pas ambigu dans une chaîne de substitution telle que ``\\g<2>0`` (``"
+"\\20`` serait interprété comme une référence au groupe 20 et non comme une "
+"référence au groupe 2 suivie du caractère littéral ``'0'``). Les "
+"substitutions suivantes sont toutes équivalentes mais utilisent les trois "
+"variantes de la chaîne de remplacement. ::"
 
 #: ../Doc/howto/regex.rst:1198
 msgid ""
@@ -2336,12 +2356,20 @@ msgid ""
 "a :ref:`match object <match-objects>` argument for the match and can use "
 "this information to compute the desired replacement string and return it."
 msgstr ""
+"*replacement* peut aussi être une fonction, ce qui vous donne encore plus de "
+"contrôle. Si *replacement* est une fonction, la fonction est appelée pour "
+"chaque occurrence non chevauchante de *pattern*. À chaque appel, un "
+"argument :ref:`objet correspondance <match-objects>` est passé à la "
+"fonction, qui peut utiliser cette information pour calculer la chaîne de "
+"remplacement désirée et la renvoyer."
 
 #: ../Doc/howto/regex.rst:1204
 msgid ""
 "In the following example, the replacement function translates decimals into "
 "hexadecimal::"
 msgstr ""
+"Dans l'exemple suivant, la fonction de substitution convertit un nombre "
+"décimal en hexadécimal ::"
 
 #: ../Doc/howto/regex.rst:1216
 msgid ""
@@ -2352,6 +2380,13 @@ msgid ""
 "pattern string, e.g. ``sub(\"(?i)b+\", \"x\", \"bbbb BBBB\")`` returns ``'x "
 "x'``."
 msgstr ""
+"Quand vous utilisez la fonction de niveau modulel :func:`re.sub`, le motif "
+"est passé comme premier argument. Vous pouvez fournir le motif sous forme "
+"d'objet ou de chaîne de caractères ; si vous avez besoin de spécifier des "
+"options pour l'expression régulière, vous devez soit utiliser un objet motif "
+"comme premier paramètre, soit utiliser des modificateurs intégrés dans la "
+"chaîne de caractères, par exemple ``sub(\"(?i)b+\", \"x\", \"bbbb BBBBB"
+"\")```retourne ``'x x'``."
 
 #: ../Doc/howto/regex.rst:1224
 msgid "Common Problems"
@@ -2364,6 +2399,10 @@ msgid ""
 "you may expect them to.  This section will point out some of the most common "
 "pitfalls."
 msgstr ""
+"Les expressions régulières constituent un outil puissant pour certaines "
+"applications mais, à certains égards, leur comportement n'est pas intuitif "
+"et, parfois, elles ne se comportent pas comme vous pouvez vous y attendre.  "
+"Cette section met en évidence certains des pièges les plus courants."
 
 #: ../Doc/howto/regex.rst:1232
 msgid "Use String Methods"
@@ -2380,6 +2419,14 @@ msgid ""
 "for the purpose, instead of the large, more generalized regular expression "
 "engine."
 msgstr ""
+"Parfois, il ne faut pas utiliser le module :mod:`re`. Si vous faites "
+"correspondre une chaîne fixe, ou une classe à un seul caractère, et que vous "
+"n'utilisez pas les fonctionnalités de :mod:`re` telles que l'option :const:"
+"`~re.IGNORECASE`, alors la puissance des expressions régulières n'est pas "
+"nécessaire. Les chaînes de caractères ont plusieurs méthodes pour opérer sur "
+"des chaînes fixes et elles sont généralement beaucoup plus rapides, parce "
+"que l'implémentation est une seule petite boucle C qui a été optimisée, au "
+"lieu du gros moteur d'expressions régulières plus généraliste."
 
 #: ../Doc/howto/regex.rst:1242
 msgid ""
@@ -2393,6 +2440,15 @@ msgid ""
 "``word`` have a word boundary on either side.  This takes the job beyond  :"
 "meth:`!replace`'s abilities.)"
 msgstr ""
+"Nous pouvons prendre l'exemple du remplacement d'une seule chaîne fixe par "
+"une autre ; vous souhaitez remplacer ``mot`` par ``acte``. :func:`re.sub` "
+"semble être faite pour cela, mais regardons la méthode :meth:`~str.replace`. "
+"Nous notons que :meth:`!replace` sait remplacer aussi ``mot`` à l'intérieur "
+"des mots, transformant ``moteur`` en ``acteeur``, mais la RE naïve ``mot`` "
+"aurait aussi fait cela (pour éviter d'effectuer la substitution sur des "
+"parties de mots, le motif doit être ``\\bmot\\b``, qui exige que ``mot`` "
+"soit en limite de mot d'un côté et de l'autre ; c'est au-delà des capacités "
+"de la méthode :meth:`!replace`)."
 
 #: ../Doc/howto/regex.rst:1251
 msgid ""
@@ -2402,16 +2458,23 @@ msgid ""
 "capable of doing both tasks and will be faster than any regular expression "
 "operation can be."
 msgstr ""
+"Une autre tâche classique est de supprimer chaque occurrence d'un seul "
+"caractère d'une chaîne de caractères ou de le remplacer par un autre "
+"caractère unique. Vous pouvez le faire avec quelque chose comme ``re."
+"sub('\\n', ' ', S)``, mais :meth:`~str.translate` en est capable et est plus "
+"rapide que n'importe quelle opération d'expression régulière."
 
 #: ../Doc/howto/regex.rst:1257
 msgid ""
 "In short, before turning to the :mod:`re` module, consider whether your "
 "problem can be solved with a faster and simpler string method."
 msgstr ""
+"Bref, avant de passer au module :mod:`re`, évaluez d'abord si votre problème "
+"peut être résolu avec une méthode de chaîne plus rapide et plus simple."
 
 #: ../Doc/howto/regex.rst:1262
 msgid "match() versus search()"
-msgstr ""
+msgstr "match() contre search()"
 
 #: ../Doc/howto/regex.rst:1264
 msgid ""
@@ -2422,12 +2485,20 @@ msgid ""
 "start at 0; if the match wouldn't start at zero,  :func:`!match` will *not* "
 "report it. ::"
 msgstr ""
+"La fonction :func:`~re.match` vérifie seulement si la RE correspond au début "
+"de la chaîne de caractères tandis que :func:`~re.search` parcourt la chaîne "
+"de caractères pour trouver une correspondance. Il est important de garder "
+"cette distinction à l'esprit. Rappelez-vous, :func:`!match` ne trouve qu'une "
+"correspondance qui commence à 0 ; si la correspondance commence plus loin, :"
+"func:`!match` *ne la trouve pas*. ::"
 
 #: ../Doc/howto/regex.rst:1275
 msgid ""
 "On the other hand, :func:`~re.search` will scan forward through the string, "
 "reporting the first match it finds. ::"
 msgstr ""
+"D'un autre côté, :func:`~re.search` balaie la chaîne de caractères, "
+"rapportant la première correspondance qu'elle trouve. ::"
 
 #: ../Doc/howto/regex.rst:1283
 msgid ""
@@ -2440,6 +2511,15 @@ msgid ""
 "analysis lets the engine quickly scan through the string looking for the "
 "starting character, only trying the full match if a ``'C'`` is found."
 msgstr ""
+"Vous pouvez être tenté d'utiliser :func:`re.match` en ajoutant simplement ``."
+"*`` au début de votre RE. Ce n'est pas une bonne idée, utilisez plutôt :func:"
+"`re.search`. Le compilateur d'expressions régulières analyse les REs pour "
+"optimiser le processus de recherche d'une correspondance. Cette analyse "
+"permet de déterminer ce que doit être le premier caractère d'une "
+"correspondance ; par exemple, un motif commençant par ``Corbeau`` doit faire "
+"correspondre un ``'C'`` en tête. L'analyse permet au moteur de parcourir "
+"rapidement la chaîne de caractères à la recherche du caractère de départ, "
+"n'essayant la correspondance complète que si un \"C\" a déjà été trouvé."
 
 #: ../Doc/howto/regex.rst:1292
 msgid ""
@@ -2447,6 +2527,10 @@ msgid ""
 "the string and then backtracking to find a match for the rest of the RE.  "
 "Use :func:`re.search` instead."
 msgstr ""
+"Ajouter ``.*`` annihile cette optimisation, nécessitant un balayage jusqu'à "
+"la fin de la chaîne de caractères, puis un retour en arrière pour trouver "
+"une correspondance pour le reste de la RE. Préférez l'utilisation :func:`re."
+"search`."
 
 #: ../Doc/howto/regex.rst:1298
 msgid "Greedy versus Non-Greedy"
@@ -2460,6 +2544,12 @@ msgid ""
 "brackets surrounding an HTML tag.  The naive pattern for matching a single "
 "HTML tag doesn't work because of the greedy nature of ``.*``. ::"
 msgstr ""
+"Si vous répétez un motif dans une expression régulière, comme ``a*``, "
+"l'action résultante est de consommer autant de motifs que possible. C'est un "
+"problème lorsque vous essayez de faire correspondre une paire de "
+"délimiteurs, comme des chevrons encadrant une balise HTML. Le motif naïf "
+"pour faire correspondre une seule balise HTML ne fonctionne pas en raison de "
+"la nature gloutonne de ``.*``. ::"
 
 #: ../Doc/howto/regex.rst:1314
 msgid ""
@@ -2470,6 +2560,13 @@ msgid ""
 "The final match extends from the ``'<'`` in ``'<html>'`` to the ``'>'`` in "
 "``'</title>'``, which isn't what you want."
 msgstr ""
+"La RE correspond au ``'<'`` de ``'<html>'`` et le ``.*``` consomme le reste "
+"de la chaîne. Mais, comme il reste des éléments du motif dans la RE et que "
+"le ``>`` ne peut pas correspondre à la fin de la chaîne de caractères, le "
+"moteur d'expression régulière doit faire marche arrière caractère par "
+"caractère jusqu'à ce qu'il trouve une correspondance pour le ``>``.  La "
+"correspondance finale s'étend du ``'<'`` de ``'<html>'`` au ``'>'`` de ``'</"
+"title>'``, ce qui n'est pas ce que vous voulez."
 
 #: ../Doc/howto/regex.rst:1321
 msgid ""
@@ -2479,6 +2576,12 @@ msgid ""
 "matches, and when it fails, the engine advances a character at a time, "
 "retrying the ``'>'`` at every step.  This produces just the right result::"
 msgstr ""
+"Dans ce cas, la solution consiste à utiliser des quantificateurs non "
+"gloutons tels que ``*?``, ``+?``, ``??`` ou ``{m,n}?``, qui effectuent une "
+"correspondance aussi *petite* que possible. Dans l'exemple ci-dessus, le "
+"``'>'`` est essayé immédiatement après que le ``'<'`` corresponde et, s'il "
+"échoue, le moteur avance caractère par caractère, ré-essayant ``'>'`` à "
+"chaque pas. Nous obtenons alors le bon résultat ::"
 
 #: ../Doc/howto/regex.rst:1330
 msgid ""
@@ -2489,6 +2592,12 @@ msgid ""
 "patterns will be *very* complicated.  Use an HTML or XML parser module for "
 "such tasks.)"
 msgstr ""
+"Note : l'analyse du HTML ou du XML avec des expressions régulières est tout "
+"sauf une sinécure. Les motifs écrits à la va-vite traiteront les cas "
+"communs, mais HTML et XML ont des cas spéciaux qui font planter l'expression "
+"régulière évidente ; quand vous aurez écrit une expression régulière qui "
+"traite tous les cas possibles, les motifs seront *très* compliqués.  "
+"Utilisez un module d'analyse HTML ou XML pour de telles tâches."
 
 #: ../Doc/howto/regex.rst:1338
 msgid "Using re.VERBOSE"
@@ -2501,6 +2610,11 @@ msgid ""
 "become lengthy collections of backslashes, parentheses, and metacharacters, "
 "making them difficult to read and understand."
 msgstr ""
+"À présent, vous vous êtes rendu compte que les expressions régulières sont "
+"une notation très compacte, mais qu'elles ne sont pas très lisibles. Une RE "
+"modérément complexe  peut rapidement devenir une longue collection de barres "
+"obliques inverses, de parenthèses et de métacaractères, ce qui la rend "
+"difficile à lire et à comprendre."
 
 #: ../Doc/howto/regex.rst:1345
 msgid ""
@@ -2508,6 +2622,9 @@ msgid ""
 "regular expression can be helpful, because it allows you to format the "
 "regular expression more clearly."
 msgstr ""
+"Pour de telles RE, activer l'option :const:`re.VERBOSE` à la compilation de "
+"l'expression régulière peut être utile ; cela vous permet de formater "
+"l'expression régulière de manière plus claire."
 
 #: ../Doc/howto/regex.rst:1349
 msgid ""
@@ -2519,6 +2636,15 @@ msgid ""
 "extend from a ``#`` character to the next newline.  When used with triple-"
 "quoted strings, this enables REs to be formatted more neatly::"
 msgstr ""
+"L'option ``re.VERBOSE`` a plusieurs effets. Les espaces dans l'expression "
+"régulière qui *ne sont pas* à l'intérieur d'une classe de caractères sont "
+"ignorées. Cela signifie qu'une expression comme ``chien | chat`` est "
+"équivalente à ``chien|chat`` qui est moins lisible, mais ``[a b]`` "
+"correspond toujours aux caractères ``'a'``, ``'b'`` ou à une espace. En "
+"outre, vous avez la possibilité de mettre des commentaires à l'intérieur "
+"d'une RE ; les commentaires s'étendent du caractère ``#`` à la nouvelle "
+"ligne suivante. Lorsque vous l'utilisez avec des chaînes à triple "
+"guillemets, cela permet aux RE d'être formatées plus proprement ::"
 
 #: ../Doc/howto/regex.rst:1366
 msgid "This is far more readable than::"
@@ -2536,8 +2662,8 @@ msgid ""
 "improvements to the author."
 msgstr ""
 "Les expressions régulières sont un sujet compliqué. Est-ce que ce document "
-"vous a aidé à les comprendre ? Des parties ne sont pas claires, ou des "
-"problèmes que vous avez rencontrés ne sont pas traités ici ? Si tel est le "
+"vous a aidé à les comprendre ? Des parties ne sont pas claires, ou des "
+"problèmes que vous avez rencontrés ne sont pas traités ici ? Si tel est le "
 "cas, merci d'envoyer vos suggestions d'améliorations à l'auteur."
 
 #: ../Doc/howto/regex.rst:1379