forked from AFPy/python-docs-fr
Traduction terminée. Besoin de relecture.
This commit is contained in:
parent
ef4e8e64e8
commit
6d507fb473
214
howto/regex.po
214
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
|
||||
|
|
Loading…
Reference in New Issue
Block a user