ArmandS/python-docs-fr
Fork 0
forked from AFPy/python-docs-fr
Code Pull requests Activity

Traduction terminée. Besoin de relecture.

Browse source
This commit is contained in:
Christophe Nanteuil 2018-07-27 10:35:49 +02:00
commit 6d507fb473
1 changed files with 170 additions and 44 deletions
Download patch file Download diff file Expand all files Collapse all files

214
howto/regex.po
View file

@ -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