From 6d507fb4733fa4d5a425629b377461de93c7a844 Mon Sep 17 00:00:00 2001 From: Christophe Nanteuil Date: Fri, 27 Jul 2018 10:35:49 +0200 Subject: [PATCH] =?UTF-8?q?Traduction=20termin=C3=A9e.=20Besoin=20de=20rel?= =?UTF-8?q?ecture.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- howto/regex.po | 214 +++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 170 insertions(+), 44 deletions(-) diff --git a/howto/regex.po b/howto/regex.po index df9ee513..c97f328e 100644 --- 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-26 23:49+0200\n" +"PO-Revision-Date: 2018-07-27 10:54+0200\n" "Last-Translator: Nabil Bendafi \n" "Language-Team: FRENCH \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 `, 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 ` en tant qu'\\ :" -"term:`itérateur ` ::" +"d'instances :ref:`d'objets correspondances ` en tant :term:" +"`qu'itérateur ` ::" #: ../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 `. ::" +"`d'objet correspondance `. ::" #: ../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 " "` 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....)``. ``\\g`` utilise la sous-chaîne " +"correspondante au groupe nommé ``nom`` et ``\\g`` 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 ` 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 ` 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 ``''`` to the ``'>'`` in " "``''``, which isn't what you want." msgstr "" +"La RE correspond au ``'<'`` de ``''`` 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 ``''`` au ``'>'`` de ``''``, 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