diff --git a/dict b/dict index 6375f5d1..4ef7ff7a 100644 --- a/dict +++ b/dict @@ -1,4 +1,6 @@ +017F 12h +212A allocateur allocateurs batch @@ -68,3 +70,5 @@ tokenisé tokenisés tty Zope +ı +ſ diff --git a/howto/regex.po b/howto/regex.po index 6fc32dc6..dec31e96 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-08-01 00:29+0200\n" +"PO-Revision-Date: 2018-09-27 23:16+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 "" @@ -161,18 +162,18 @@ msgid "" "do." msgstr "" "Il existe des exceptions à cette règle ; certains caractères sont des :dfn:" -"`métacaractères ` spéciaux et ne correspondent pas à eux-" -"mêmes. Au lieu de cela, ils signalent que certaines choses non ordinaires " -"doivent correspondre, ou ils affectent d'autre portions de la RE en les " -"répétant ou en changeant leur sens. Une grande partie de ce document est " -"consacrée au fonctionnement de ces métacaractères." +"`métacaractères` spéciaux et ne correspondent pas à eux-mêmes. Au lieu de " +"cela, ils signalent que certaines choses non ordinaires doivent " +"correspondre, ou ils affectent d'autre portions de la RE en les répétant ou " +"en changeant leur sens. Une grande partie de ce document est consacrée au " +"fonctionnement de ces métacaractères." #: ../Doc/howto/regex.rst:76 msgid "" "Here's a complete list of the metacharacters; their meanings will be " "discussed in the rest of this HOWTO." msgstr "" -"Voici une liste complète des métacaractères ; leurs sens est décrit dans la " +"Voici une liste complète des métacaractères ; leur sens est décrit dans la " "suite de ce guide." #: ../Doc/howto/regex.rst:83 @@ -216,12 +217,12 @@ msgid "" "match the ``'^'`` character. For example, ``[^5]`` will match any character " "except ``'5'``." msgstr "" -"Vous pouvez trouvez une correspondance avec les caractères non listés dans " -"une classe en spécifiant le :dfn:`complément ` de l'ensemble. " -"Ceci est indiqué en plaçant un ``'^'`` en tant que premier caractère de la " -"classe ; ``'^'`` en dehors d'une classe de caractères correspond au " -"caractère ``'^'``. Par exemple, ``[^5]`` correspond à tous les caractères, " -"sauf ``'5'``." +"Vous pouvez trouver une correspondance avec les caractères non listés dans " +"une classe en spécifiant le :dfn:`complément` de l'ensemble. Ceci est " +"indiqué en plaçant un ``'^'`` en tant que premier caractère de la classe ; " +"``'^'`` en dehors d'une classe de caractères correspond au caractère " +"``'^'``. Par exemple, ``[^5]`` correspond à tous les caractères, sauf " +"``'5'``." #: ../Doc/howto/regex.rst:102 msgid "" @@ -232,14 +233,14 @@ msgid "" "need to match a ``[`` or ``\\``, you can precede them with a backslash to " "remove their special meaning: ``\\[`` or ``\\\\``." msgstr "" -"Le métacaractère probablement le plus important est la barre oblique inverse " +"Le métacaractère le plus important est probablement la barre oblique inverse " "( *backslash* en anglais), ``\\``. Comme dans les chaînes de caractères en " -"Python, le **backslash** peut être suivi par différents caractères pour " -"signaler différentes séquences spéciales. Il est aussi utilisé 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 ``\\\\``." +"Python, la barre oblique inverse peut être suivie par différents caractères " +"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 annuler leur signification spéciale : ``\\[`` ou ``\\\\``." #: ../Doc/howto/regex.rst:109 msgid "" @@ -262,7 +263,7 @@ msgid "" "in a string pattern by supplying the :const:`re.ASCII` flag when compiling " "the regular expression." msgstr "" -"Prenons un exemple: ``\\w`` correspond à n'importe quel caractère " +"Prenons un exemple : ``\\w`` correspond à n'importe quel caractère " "alphanumérique. Si l'expression régulière est exprimée en *bytes*, c'est " "équivalent à la classe ``[a-zA-Z0-9_]``. Si l'expression régulière est une " "chaîne de caractères, ``\\w`` correspond à tous les caractères identifiés " @@ -426,7 +427,7 @@ msgid "" "portions of the pattern don't match, the matching engine will then back up " "and try again with fewer repetitions." msgstr "" -"Les répétitions telles que ``*`` sont :dfn:`` ; quand vous répétez " +"Les répétitions telles que ``*`` sont :dfn:`gloutonnes` ; quand vous répétez " "une RE, le moteur de correspondance essaie de trouver la correspondance la " "plus longue en répétant le motif tant qu'il le peut. Si la suite du motif ne " "correspond pas, le moteur de correspondance revient en arrière et essaie " @@ -558,7 +559,7 @@ msgid "" "``[bcd]*``, and if that subsequently fails, the engine will conclude that " "the string doesn't match the RE at all." msgstr "" -"La fin de la RE est maintenant atteint et la correspondance trouvée est " +"La fin de la RE est maintenant atteinte et la correspondance trouvée est " "``'abcb'``. Ceci démontre comment le moteur de correspondance essaie d'aller " "le plus loin possible en premier et, si la correspondance échoue, il revient " "progressivement en arrière et ré-essaie avec le reste de la RE encore et " @@ -577,7 +578,7 @@ msgid "" msgstr "" "Un autre métacaractère de répétition est ``+``, qui fait correspondre une ou " "plusieurs fois. Faites bien attention à la différence entre ``*`` et ``+`` ; " -"``*`` fait correspondre *zero* fois ou plus, ainsi ce qui doit être répété " +"``*`` fait correspondre *zéro* fois ou plus, ainsi ce qui doit être répété " "peut ne pas être présent du tout, alors que ``+`` requiert au moins *une* " "occurrence. Pour continuer avec le même exemple, ``cha+t`` correspond avec " "``'chat'`` (1 ``'a'``), ``'chaaat'`` (3 ``'a'``) mais ne correspond pas avec " @@ -646,7 +647,7 @@ msgid "" "perform matches with them." msgstr "" "Maintenant que nous avons vu quelques expressions régulières simples, " -"utilisons les concrètement. Le module :mod:`re` fournit une interface pour " +"utilisons-les concrètement. Le module :mod:`re` fournit une interface pour " "le moteur de correspondance, ce qui permet de compiler les RE en objets et " "d'effectuer des correspondances avec." @@ -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 le remplacement dans les chaînes. ::" +"correspondances ou les substitutions dans les chaînes. ::" #: ../Doc/howto/regex.rst:275 msgid "" @@ -863,8 +864,8 @@ 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 " -"attributs. Seuls les plus significatifs seront couverts ici; consultez la " +"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." #: ../Doc/howto/regex.rst:359 ../Doc/howto/regex.rst:417 @@ -924,7 +925,7 @@ msgid "" msgstr "" ":meth:`~re.Pattern.match` et :meth:`~re.Pattern.search` renvoient ``None`` " "si aucune correspondance ne peut être trouvée. Si elles trouvent une " -"correspondance, une instance d' objet :ref:`correspondance ` " +"correspondance, une instance d'objet :ref:`correspondance ` " "est renvoyée, contenant les informations relatives à la correspondance : " "position de départ et de fin, la sous-chaîne qui correspond et d'autres " "informations." @@ -938,12 +939,22 @@ msgid "" "whether the RE matches or fails. :file:`redemo.py` can be quite useful when " "trying to debug a complicated RE." msgstr "" +"Vous pouvez apprendre leur fonctionnement en expérimentant de manière " +"interactive avec le module :mod:`re`. Si vous disposez de :mod:`tkinter`, " +"vous pouvez aussi regarder les sources de :source:`Tools/demo/redemo.py`, un " +"programme de démonstration inclus dans la distribution Python. Ce programme " +"vous permet de rentrer des RE et des chaînes, affichant si la RE correspond " +"ou pas. :file:`redemo.py` peut s'avérer particulièrement utile quand vous " +"devez déboguer une RE compliquée." #: ../Doc/howto/regex.rst:386 msgid "" "This HOWTO uses the standard Python interpreter for its examples. First, run " "the Python interpreter, import the :mod:`re` module, and compile a RE::" msgstr "" +"Ce guide utilise l'interpréteur standard de Python pour ses exemples. " +"Commencez par lancer l'interpréteur Python, importez le module :mod:`re` et " +"compilez une RE ::" #: ../Doc/howto/regex.rst:394 msgid "" @@ -953,6 +964,12 @@ msgid "" "which will cause the interpreter to print no output. You can explicitly " "print the result of :meth:`!match` to make this clear. ::" msgstr "" +"Maintenant, vous pouvez tester des correspondances de la RE ``[a-z]+`` avec " +"différentes chaînes. Une chaîne vide ne doit pas correspondre, puisque ``+`` " +"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. ::" #: ../Doc/howto/regex.rst:404 msgid "" @@ -960,6 +977,10 @@ msgid "" "this case, :meth:`~re.Pattern.match` will return a :ref:`match object `, so you should store the result in a variable for later use. ::" 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. ::" #: ../Doc/howto/regex.rst:412 msgid "" @@ -967,6 +988,10 @@ msgid "" "about the matching string. Match object instances also have several methods " "and attributes; the most important ones are:" msgstr "" +"Maintenant, vous pouvez interroger :ref:`l'objet correspondance ` pour obtenir des informations sur la chaîne qui correspond. Les " +"instances d'objets correspondances possèdent plusieurs méthodes et " +"attributs ; les plus importants sont :" #: ../Doc/howto/regex.rst:419 msgid "``group()``" @@ -974,7 +999,7 @@ msgstr "``group()``" #: ../Doc/howto/regex.rst:419 msgid "Return the string matched by the RE" -msgstr "Retourne la chaîne de caractères correspondant à la RE" +msgstr "Renvoie la chaîne de caractères correspondant à la RE" #: ../Doc/howto/regex.rst:421 msgid "``start()``" @@ -982,7 +1007,7 @@ msgstr "``start()``" #: ../Doc/howto/regex.rst:421 msgid "Return the starting position of the match" -msgstr "Retourne la position de début de correspondance" +msgstr "Renvoie la position de début de la correspondance" #: ../Doc/howto/regex.rst:423 msgid "``end()``" @@ -990,7 +1015,7 @@ msgstr "``end()``" #: ../Doc/howto/regex.rst:423 msgid "Return the ending position of the match" -msgstr "Retourne la position de fin de correspondance" +msgstr "Renvoie la position de fin de la correspondance" #: ../Doc/howto/regex.rst:425 msgid "``span()``" @@ -999,10 +1024,11 @@ msgstr "``span()``" #: ../Doc/howto/regex.rst:425 msgid "Return a tuple containing the (start, end) positions of the match" msgstr "" +"Renvoie un *tuple* contenant les positions (début, fin) de la correspondance" #: ../Doc/howto/regex.rst:429 msgid "Trying these methods will soon clarify their meaning::" -msgstr "" +msgstr "Essayons ces méthodes pour clarifier leur signification ::" #: ../Doc/howto/regex.rst:438 msgid "" @@ -1015,6 +1041,14 @@ msgid "" "scans through the string, so the match may not start at zero in that " "case. ::" msgstr "" +":meth:`~re.Match.group` renvoie la sous-chaîne qui correspond à la RE. :meth:" +"`~re.Match.start` et :meth:`~re.Match.end` renvoient les indices de début et " +"de fin de la correspondance. :meth:`~re.Match.span` renvoie les indices de " +"début et de fin dans un seul *tuple*. Comme la méthode :meth:`~re.Pattern." +"match` ne fait que vérifier si la RE correspond au début de la chaîne, :meth:" +"`!start` vaut toujours zéro. Cependant, la méthode :meth:`~re.Pattern." +"search` d'un motif analyse toute la chaîne, afin de trouver une " +"correspondance potentielle qui ne commence pas à zéro. ::" #: ../Doc/howto/regex.rst:455 msgid "" @@ -1022,12 +1056,17 @@ msgid "" "` in a variable, and then check if it was ``None``. This " "usually looks like::" msgstr "" +"Dans les programmes réels, la façon de faire la plus courante consiste à " +"stocker :ref:`l'objet correspondance ` dans une variable, " +"puis à vérifier s'il vaut ``None``. Généralement, cela ressemble à ceci ::" #: ../Doc/howto/regex.rst:466 msgid "" "Two pattern methods return all of the matches for a pattern. :meth:`~re." "Pattern.findall` returns a list of matching strings::" msgstr "" +"Deux méthodes de motifs renvoient toutes les correspondances pour un motif. :" +"meth:`~re.Pattern.findall` renvoie une liste des chaînes qui correspondent ::" #: ../Doc/howto/regex.rst:473 msgid "" @@ -1037,6 +1076,12 @@ msgid "" "in a :exc:`DeprecationWarning` and will eventually become a :exc:" "`SyntaxError`. See :ref:`the-backslash-plague`." msgstr "" +"Le préfixe ``r``, qui indique une chaîne brute littérale, est nécessaire " +"dans cet exemple car les séquences d'échappement dans une chaîne littérale " +"qui ne sont pas reconnues par Python, alors qu'elles le sont par les " +"expressions régulières, induisent maintenant un :exc:`DeprecationWarning` et " +"deviendront possiblement des :exc:`SyntaxError`. Reportez-vous à :ref:`the-" +"backslash-plague`." #: ../Doc/howto/regex.rst:479 msgid "" @@ -1045,10 +1090,14 @@ msgid "" "sequence of :ref:`match object ` instances as an :term:" "`iterator`::" 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 :term:" +"`qu'itérateur ` ::" #: ../Doc/howto/regex.rst:495 msgid "Module-Level Functions" -msgstr "" +msgstr "Fonctions de niveau module" #: ../Doc/howto/regex.rst:497 msgid "" @@ -1059,6 +1108,13 @@ msgid "" "with the RE string added as the first argument, and still return either " "``None`` or a :ref:`match object ` instance. ::" msgstr "" +"Vous n'avez pas besoin de créer un objet motif et d'appeler ses méthodes ; " +"le module :mod:`re` fournit des fonctions à son niveau, ce sont :func:`~re." +"match`, :func:`~re.search`, :func:`~re.findall`, :func:`~re.sub` et ainsi de " +"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 `. ::" #: ../Doc/howto/regex.rst:509 msgid "" @@ -1067,6 +1123,10 @@ msgid "" "cache, so future calls using the same RE won't need to parse the pattern " "again and again." msgstr "" +"En interne, ces fonctions créent simplement un objet motif pour vous et " +"appellent la méthode appropriée de cet objet. Elles stockent également " +"l'objet compilé dans un cache afin que les appels suivants qui utilisent la " +"même RE n'aient pas besoin d'analyser le motif une nouvelle fois." #: ../Doc/howto/regex.rst:514 msgid "" @@ -1075,10 +1135,15 @@ msgid "" "pre-compiling it will save a few function calls. Outside of loops, there's " "not much difference thanks to the internal cache." msgstr "" +"Devez-vous utiliser ces fonctions au niveau des modules ou devez-vous " +"calculer le motif et appeler vous-même ses méthodes ? Si vous utilisez " +"l'expression régulière à l'intérieur d'une boucle, la pré-compilation permet " +"d'économiser quelques appels de fonctions. En dehors des boucles, il n'y a " +"pas beaucoup de différence grâce au cache interne." #: ../Doc/howto/regex.rst:522 msgid "Compilation Flags" -msgstr "Fanion de Compilation" +msgstr "Options de compilation" #: ../Doc/howto/regex.rst:524 msgid "" @@ -1091,12 +1156,23 @@ msgid "" "them; ``re.I | re.M`` sets both the :const:`I` and :const:`M` flags, for " "example." msgstr "" +"Les options de compilation vous permettent de modifier le comportement des " +"expressions régulières. Ces options sont accessibles dans le module :mod:" +"`re` par deux noms, un long du type :const:`IGNORECASE` et un court (une " +"seule lettre) tel que :const:`I` (si vous êtes habitués aux modificateurs de " +"motifs Perl, la version courte utilise les mêmes lettres que Perl, par " +"exemple la version courte de :const:`re.VERBOSE` est :const:`re.X`). " +"Plusieurs options peuvent être spécifiées en appliquant l'opérateur bit-à-" +"bit *OR* ; par exemple, ``re.I | re.M`` active à la fois les options :const:" +"`I` et :const:`M`." #: ../Doc/howto/regex.rst:532 msgid "" "Here's a table of the available flags, followed by a more detailed " "explanation of each one." msgstr "" +"Vous trouvez ci-dessous le tableau des options disponibles, suivies " +"d'explications détaillées." #: ../Doc/howto/regex.rst:536 msgid "Flag" @@ -1108,17 +1184,20 @@ msgstr "Signification" #: ../Doc/howto/regex.rst:538 msgid ":const:`ASCII`, :const:`A`" -msgstr "" +msgstr ":const:`ASCII`, :const:`A`" #: ../Doc/howto/regex.rst:538 msgid "" "Makes several escapes like ``\\w``, ``\\b``, ``\\s`` and ``\\d`` match only " "on ASCII characters with the respective property." msgstr "" +"Transforme plusieurs échappements tels que ``\\w``, ``\\b``, ``\\s`` et ``" +"\\d`` de manière à ce qu'ils ne correspondent qu'à des caractères ASCII " +"ayant la propriété demandée." #: ../Doc/howto/regex.rst:542 msgid ":const:`DOTALL`, :const:`S`" -msgstr "" +msgstr ":const:`DOTALL`, :const:`S`" #: ../Doc/howto/regex.rst:542 msgid "Make ``.`` match any character, including newlines." @@ -1128,38 +1207,41 @@ msgstr "" #: ../Doc/howto/regex.rst:545 msgid ":const:`IGNORECASE`, :const:`I`" -msgstr "" +msgstr ":const:`IGNORECASE`, :const:`I`" #: ../Doc/howto/regex.rst:545 msgid "Do case-insensitive matches." -msgstr "Rechercher une correspondance non-sensible à la casse." +msgstr "Recherche une correspondance sans tenir compte de la casse." #: ../Doc/howto/regex.rst:547 msgid ":const:`LOCALE`, :const:`L`" -msgstr "" +msgstr ":const:`LOCALE`, :const:`L`" #: ../Doc/howto/regex.rst:547 msgid "Do a locale-aware match." -msgstr "Rechercher une correspondance sensible à la langue locale." +msgstr "" +"Recherche une correspondance en tenant compte de la configuration de la " +"région." #: ../Doc/howto/regex.rst:549 msgid ":const:`MULTILINE`, :const:`M`" -msgstr "" +msgstr ":const:`MULTILINE`, :const:`M`" #: ../Doc/howto/regex.rst:549 msgid "Multi-line matching, affecting ``^`` and ``$``." -msgstr "Correspondance multi-ligne, affectant ``^`` et ``$``." +msgstr "Correspondance multi-lignes, affecte ``^`` et ``$``." #: ../Doc/howto/regex.rst:552 msgid ":const:`VERBOSE`, :const:`X` (for 'extended')" msgstr "" +":const:`VERBOSE`, :const:`X` (pour *extended*, c-à-d étendu en anglais)" #: ../Doc/howto/regex.rst:552 msgid "" "Enable verbose REs, which can be organized more cleanly and understandably." msgstr "" -"Activer les RE verbeuses, qui peuvent être organisées de manière plus " -"propres et compréhensibles." +"Active les RE verbeuses, qui peuvent être organisées de manière plus propre " +"et compréhensible." #: ../Doc/howto/regex.rst:561 msgid "" @@ -1176,12 +1258,30 @@ msgid "" "lowercasing doesn't take the current locale into account; it will if you " "also set the :const:`LOCALE` flag." msgstr "" +"Effectue une correspondance insensible à la casse ; les classes de " +"caractères et les littéraux de chaînes de caractères ignorent la casse pour " +"la correspondance. Par exemple, ``[A-Z]`` correspond aussi aux lettres " +"minuscules. La correspondance Unicode complète fonctionne également, sauf si " +"l'option :const:`ASCII` est utilisée pour désactiver les correspondances non " +"ASCII. Lorsque les motifs Unicode ``[a-z]`` ou ``[A-Z]`` sont utilisés en " +"combinaison avec l'option :const:`IGNORECASE`, ils correspondent avec les 52 " +"lettres ASCII et 4 lettres non ASCII supplémentaires : 'İ' (U+0130, lettre I " +"en majuscule latine avec un point au-dessus), 'ı' (U+0131, lettre minuscule " +"latine i sans point au-dessus), 'ſ' (U+017F, lettre minuscule latine longue " +"s) et 'K' (U+212A, signe du Kelvin). ``Spam`` correspond ainsi à ``'Spam'``, " +"``'spam'``, ``'spAM'`` ou ``'ſpam'`` (ce dernier ne correspond qu'en mode " +"Unicode). Le passage en minuscules ne prend pas en compte la configuration " +"de région courante ; elle le fait si vous mettez aussi l'option :const:" +"`LOCALE`." #: ../Doc/howto/regex.rst:579 msgid "" "Make ``\\w``, ``\\W``, ``\\b``, ``\\B`` and case-insensitive matching " "dependent on the current locale instead of the Unicode database." msgstr "" +"Rend ``\\w``, ``\\W``, ``\\b``, ``\\B`` et les correspondances non sensibles " +"à la casse dépendants de la configuration de la région courante au lieu de " +"la base de données Unicode." #: ../Doc/howto/regex.rst:582 msgid "" @@ -1201,14 +1301,33 @@ msgid "" "matching is already enabled by default in Python 3 for Unicode (str) " "patterns, and it is able to handle different locales/languages." msgstr "" +"Les *locales* sont une caractéristique de la bibliothèque C destinées à " +"favoriser une programmation qui tient compte des différences linguistiques " +"(NdT : nous utilisons *configuration de région* dans cette page pour " +"désigner ce concept de la bibliothèque C). 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 configuré " +"correctement et que la configuration de région 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 " +"compilation d'une expression régulière fait que l'objet compilé résultant " +"utilise ces fonctions C pour ``\\w`` ; c'est plus lent mais cela permet à ``" +"\\w+`` de correspondre avec les mots français tel qu'attendu. L'utilisation " +"de cette option est déconseillée en Python 3 car le mécanisme de locale est " +"très peu fiable, il ne gère qu'une seule \"culture\" à la fois et il ne " +"fonctionne qu'avec des locales 8 bits. La correspondance Unicode est déjà " +"activée par défaut dans Python 3 pour les motifs Unicode (type *str*) et " +"elle est capable de gérer différentes configurations de régions." #: ../Doc/howto/regex.rst:604 msgid "" "(``^`` and ``$`` haven't been explained yet; they'll be introduced in " "section :ref:`more-metacharacters`.)" msgstr "" -"(``^`` et ``$`` n'ont pas encore été expliqués; ils seront introduit dans le " -"section :ref:`more-metacharacters`.)" +"Nota : ``^`` et ``$`` n'ont pas encore été expliqués ; ils sont introduits " +"dans la section :ref:`more-metacharacters`." #: ../Doc/howto/regex.rst:607 msgid "" @@ -1220,12 +1339,23 @@ msgid "" "matches either at the end of the string and at the end of each line " "(immediately preceding each newline)." 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 " +"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 " +"immédiatement chaque nouvelle ligne)." #: ../Doc/howto/regex.rst:620 msgid "" "Makes the ``'.'`` special character match any character at all, including a " "newline; without this flag, ``'.'`` will match anything *except* a newline." msgstr "" +"Fait que le caractère spécial ``'.'`` corresponde avec n'importe quel " +"caractère, y compris le retour à la ligne ; sans cette option, ``'.'`` " +"correspond avec tout, *sauf* le retour à la ligne." #: ../Doc/howto/regex.rst:628 msgid "" @@ -1233,6 +1363,10 @@ msgid "" "only matching instead of full Unicode matching. This is only meaningful for " "Unicode patterns, and is ignored for byte patterns." msgstr "" +"Fait que ``\\w``, ``\\W``, ``\\b``, ``\\B``, ``\\s`` et ``\\S`` ne " +"correspondent qu'avec des caractères ASCII au lieu de l'ensemble des " +"caractères Unicode. Cette option n'a de sens que pour des motifs Unicode, " +"elle est ignorée pour les motifs *bytes*." #: ../Doc/howto/regex.rst:637 msgid "" @@ -1245,16 +1379,27 @@ msgid "" "comments are marked by a ``'#'`` that's neither in a character class or " "preceded by an unescaped backslash." msgstr "" +"Cette option vous permet d'écrire des expressions régulières plus lisibles " +"en vous permettant plus de flexibilité pour le formatage. Lorsque cette " +"option est activée, les \"blancs\" dans la chaîne RE sont ignorés, sauf " +"lorsque le \"blanc\" se trouve dans une classe de caractères ou est précédé " +"d'une barre oblique inverse ; ceci vous permet d'organiser et d'indenter vos " +"RE plus clairement. Cette option vous permet également de placer des " +"commentaires dans une RE, ils seront ignorés par le moteur ; les " +"commentaires commencent par un ``'#'`` qui n'est ni dans une classe de " +"caractères, ni précédé d'une barre oblique inverse." #: ../Doc/howto/regex.rst:646 msgid "" "For example, here's a RE that uses :const:`re.VERBOSE`; see how much easier " "it is to read? ::" msgstr "" +"Par exemple, voici une RE qui utilise :const:`re.VERBOSE` ; vous pouvez " +"constater qu'elle est beaucoup plus facile à lire ::" #: ../Doc/howto/regex.rst:659 msgid "Without the verbose setting, the RE would look like this::" -msgstr "" +msgstr "Sans l'option verbeuse, cette RE ressemble à ceci ::" #: ../Doc/howto/regex.rst:665 msgid "" @@ -1262,10 +1407,14 @@ msgid "" "has been used to break up the RE into smaller pieces, but it's still more " "difficult to understand than the version using :const:`re.VERBOSE`." msgstr "" +"Dans l'exemple ci-dessus, Python concatène automatiquement les littéraux " +"chaînes de caractères qui ont été utilisés pour séparer la RE en petits " +"morceaux, mais la RE reste plus difficile à comprendre que sa version " +"utilisant :const:`re.VERBOSE`." #: ../Doc/howto/regex.rst:671 msgid "More Pattern Power" -msgstr "" +msgstr "Des motifs plus puissants" #: ../Doc/howto/regex.rst:673 msgid "" @@ -1275,8 +1424,8 @@ msgid "" msgstr "" "Jusqu'à présent nous avons seulement couvert une partie des fonctionnalités " "des expressions régulières. Dans cette section, nous couvrirons quelques " -"nouveaux métacaractères et comment utiliser les groupes pour récupérer des " -"portions de textes correspondante." +"nouveaux métacaractères et l'utilisation des groupes pour récupérer des " +"portions de textes correspondantes." #: ../Doc/howto/regex.rst:681 msgid "More Metacharacters" @@ -1287,6 +1436,8 @@ msgid "" "There are some metacharacters that we haven't covered yet. Most of them " "will be covered in this section." msgstr "" +"Nous n'avons pas encore couvert tous les métacaractères. Cette section " +"traite de la plupart de ceux que nous n'avons pas abordés." #: ../Doc/howto/regex.rst:686 msgid "" @@ -1299,6 +1450,15 @@ msgid "" "once at a given location, they can obviously be matched an infinite number " "of times." msgstr "" +"Certains métacaractères restants sont des :dfn:`assertions de largeur zéro` " +"(*zero-width assertions* en anglais). Ils ne font pas avancer le moteur dans " +"la chaîne de caractères ; ils ne consomment aucun caractère et ils " +"réussissent ou échouent tout simplement. Par exemple, ``\\b`` est une " +"assertion selon laquelle la position actuelle est située à la limite d'un " +"mot ; la position n'est pas modifiée par le \" \\b \". Cela signifie que les " +"assertions de largeur zéro ne doivent pas être répétées car, si elles " +"correspondent à un endroit donné, elles correspondent automatiquement un " +"nombre infini de fois." #: ../Doc/howto/regex.rst:702 msgid "``|``" @@ -1313,12 +1473,20 @@ msgid "" "``'Crow'`` or ``'Servo'``, not ``'Cro'``, a ``'w'`` or an ``'S'``, and " "``'ervo'``." msgstr "" +"Union ensembliste ou opérateur \"ou\". Si *A* et *B* sont des expressions " +"régulières, ``A|B`` correspond à toute chaine qui correspond à A ou à B. La " +"priorité de ``|`` est très faible afin de pouvoir effectuer simplement des " +"unions de chaînes de plusieurs caractères. ``Crow|Servo`` correspond avec " +"``'Crow'`` ou ``'Servo'``, mais pas avec ``'Cro'``, un ``'w'`` ou un " +"``'S'``, ou encore ``'ervo'``." #: ../Doc/howto/regex.rst:701 msgid "" "To match a literal ``'|'``, use ``\\|``, or enclose it inside a character " "class, as in ``[|]``." msgstr "" +"Pour correspondre avec un ``'|'`` littéral, utilisez ``\\|`` ou placez-le " +"dans une classe de caractères, comme ceci ``[|]``." #: ../Doc/howto/regex.rst:717 msgid "``^``" @@ -1331,32 +1499,42 @@ msgid "" "`MULTILINE` mode, this also matches immediately after each newline within " "the string." msgstr "" +"Correspond à un début de ligne. À moins que l'option :const:`MULTILINE` ne " +"soit activée, cela ne fait correspondre que le début de la chaîne. Dans le " +"mode :const:`MULTILINE`, cela fait aussi correspondre immédiatement après " +"chaque nouvelle ligne à l'intérieur de la chaîne." #: ../Doc/howto/regex.rst:709 msgid "" "For example, if you wish to match the word ``From`` only at the beginning of " "a line, the RE to use is ``^From``. ::" msgstr "" +"Par exemple, si vous voulez trouver le mot ``From`` uniquement quand il est " +"en début de ligne, la RE à utiliser est ``^From``. ::" #: ../Doc/howto/regex.rst:717 msgid "To match a literal ``'^'``, use ``\\^``." -msgstr "" +msgstr "Pour trouver un ``'^'`` littéral, utilisez ``\\^``." #: ../Doc/howto/regex.rst:731 msgid "``$``" -msgstr "" +msgstr "``$``" #: ../Doc/howto/regex.rst:720 msgid "" "Matches at the end of a line, which is defined as either the end of the " "string, or any location followed by a newline character. ::" msgstr "" +"Correspond à une fin de ligne, ce qui veut dire soit la fin de la chaîne, " +"soit tout emplacement qui est suivi du caractère de nouvelle ligne. ::" #: ../Doc/howto/regex.rst:730 msgid "" "To match a literal ``'$'``, use ``\\$`` or enclose it inside a character " "class, as in ``[$]``." msgstr "" +"Pour trouver un ``'$'`` littéral, utilisez ``\\$`` ou placez-le à " +"l'intérieur d'une classe de caractères, comme ceci ``[$]``." #: ../Doc/howto/regex.rst:737 msgid "``\\A``" @@ -1370,6 +1548,12 @@ msgid "" "string, but ``^`` may match at any location inside the string that follows a " "newline character." msgstr "" +"Correspond au début de la chaîne de caractère, uniquement. Si l'option :" +"const:`MULTILINE` n'est pas activée, ``\\A`` et ``^`` sont équivalents. Dans " +"le mode :const:`MULTILINE`, ils sont différents : ``\\A`` ne correspond " +"toujours qu'au début de la chaîne alors que ``^`` correspond aussi aux " +"emplacements situés immédiatement après une nouvelle ligne à l'intérieur de " +"la chaîne." #: ../Doc/howto/regex.rst:740 msgid "``\\Z``" @@ -1390,12 +1574,19 @@ msgid "" "characters, so the end of a word is indicated by whitespace or a non-" "alphanumeric character." msgstr "" +"Limite de mot. C'est une assertion de largeur zéro qui correspond uniquement " +"aux positions de début et de fin de mot. Un mot est défini comme une " +"séquence de caractères alphanumériques ; ainsi, la fin d'un mot est indiquée " +"par un \"blanc\" ou un caractère non-alphanumérique." #: ../Doc/howto/regex.rst:748 msgid "" "The following example matches ``class`` only when it's a complete word; it " "won't match when it's contained inside another word. ::" msgstr "" +"L'exemple suivant fait correspondre ``class`` seulement si c'est un mot " +"complet ; il n'y a pas de correspondance quand il est à l'intérieur d'un " +"autre mot. ::" #: ../Doc/howto/regex.rst:759 msgid "" @@ -1407,6 +1598,15 @@ msgid "" "won't match as you expect it to. The following example looks the same as our " "previous RE, but omits the ``'r'`` in front of the RE string. ::" msgstr "" +"Quand vous utilisez cette séquence spéciale, gardez deux choses à l'esprit. " +"Tout d'abord, c'est la pire collision entre les littéraux des chaînes Python " +"et les séquences d'expressions régulières. Dans les littéraux de chaîne de " +"caractères Python, ``\\b``` est le caractère de retour-arrière (*backspace* " +"en anglais), dont la valeur ASCII est 8. Si vous n'utilisez pas les chaînes " +"de caractères brutes, alors Python convertit le ``\\b`` en retour-arrière, " +"et votre RE ne correspond pas à ce que vous attendez. L'exemple suivant " +"ressemble à notre RE précédente, mais nous avons omis le ```'r'`` devant la " +"chaîne RE. ::" #: ../Doc/howto/regex.rst:773 msgid "" @@ -1414,6 +1614,9 @@ msgid "" "\\b`` represents the backspace character, for compatibility with Python's " "string literals." msgstr "" +"Ensuite, dans une classe de caractères, où cette assertion n'a pas lieu " +"d'être, ``\\b`` représente le caractère retour-arrière, afin d'être " +"compatible avec les littéraux de chaînes de caractères." #: ../Doc/howto/regex.rst:780 msgid "``\\B``" @@ -1424,6 +1627,9 @@ msgid "" "Another zero-width assertion, this is the opposite of ``\\b``, only matching " "when the current position is not at a word boundary." msgstr "" +"Encore une assertion de largeur zéro, qui est l'opposée de ``\\b``, c'est-à-" +"dire qu'elle fait correspondre uniquement les emplacements qui ne sont pas à " +"la limite d'un mot." #: ../Doc/howto/regex.rst:783 msgid "Grouping" @@ -1437,6 +1643,13 @@ msgid "" "of interest. For example, an RFC-822 header line is divided into a header " "name and a value, separated by a ``':'``, like this:" msgstr "" +"Souvent, vous avez besoin d'obtenir plus d'informations que le simple fait " +"que la RE corresponde ou non. Ainsi, les expressions régulières sont souvent " +"utilisées pour analyser des chaînes de caractères en écrivant une RE qui " +"divise une chaîne en plusieurs sous-groupes, correspondant chacun à une " +"information particulière. Par exemple, une ligne d'en-tête RFC-822 peut se " +"diviser en un nom d'en-tête et une valeur associée, séparés par un ``':'``, " +"comme ceci :" #: ../Doc/howto/regex.rst:798 msgid "" @@ -1444,6 +1657,9 @@ msgid "" "header line, and has one group which matches the header name, and another " "group which matches the header's value." msgstr "" +"Vous pouvez alors écrire une expression régulière qui fait correspondre une " +"ligne d'en-tête entière et qui comporte un groupe correspondant au nom de " +"l'en-tête, et un autre groupe correspondant à la valeur de l'en-tête." #: ../Doc/howto/regex.rst:802 msgid "" @@ -1454,6 +1670,12 @@ msgid "" "+``, ``?``, or ``{m,n}``. For example, ``(ab)*`` will match zero or more " "repetitions of ``ab``. ::" msgstr "" +"Les groupes sont délimités par les métacaractères marqueurs ``'('``et " +"``')'``. ``'('`` et ``')'`` ont à peu près le même sens que dans les " +"expressions mathématiques ; ils forment un groupe à partir des expressions " +"qu'ils encadrent ; vous pouvez répéter le contenu d'un groupe à l'aide d'un " +"quantificateur, comme ``*``, ``+``, ``?`` ou ``{m,n}``. Par exemple, " +"``(ab)*`` correspond à zéro, une ou plusieurs fois ``ab``. ::" #: ../Doc/howto/regex.rst:813 msgid "" @@ -1466,6 +1688,15 @@ msgid "" "we'll see how to express groups that don't capture the span of text that " "they match. ::" msgstr "" +"Les groupes délimités par ``'('``et ``')'`` capturent également les indices " +"de début et de fin du texte avec lequel ils correspondent ; ces indices " +"peuvent être récupérés en passant un argument à :meth:`~re.Match.group`, :" +"meth:`~re.Match.start`, :meth:`~re.Match.end` ou :meth:`~re.Match.span`. Les " +"groupes sont numérotés à partir de 0, le groupe 0 est toujours présent ; " +"c'est l'ensemble de la RE, donc les méthodes de :ref:`l'objet correspondance " +"` ont le groupe 0 comme argument par défaut. Plus loin, nous " +"voyons comment exprimer les groupes qui ne capturent pas l'étendue du texte " +"avec lequel ils correspondent. ::" #: ../Doc/howto/regex.rst:829 msgid "" @@ -1473,6 +1704,10 @@ msgid "" "nested; to determine the number, just count the opening parenthesis " "characters, going from left to right. ::" msgstr "" +"Les sous-groupes sont numérotés de la gauche vers la droite, à partir de 1. " +"Les groupes peuvent être imbriqués ; pour déterminer le numéro, il vous " +"suffit de compter le nombre de parenthèses ouvrantes de la gauche vers la " +"droite. ::" #: ../Doc/howto/regex.rst:842 msgid "" @@ -1480,12 +1715,18 @@ msgid "" "which case it will return a tuple containing the corresponding values for " "those groups. ::" msgstr "" +"Vous pouvez passer plusieurs numéros de groupes à :meth:`~re.Match.group` en " +"même temps, elle vous renvoie alors un *tuple* contenant les valeurs " +"correspondantes pour ces groupes. ::" #: ../Doc/howto/regex.rst:848 msgid "" "The :meth:`~re.Match.groups` method returns a tuple containing the strings " "for all the subgroups, from 1 up to however many there are. ::" msgstr "" +"La méthode :meth:`~re.Match.groups` renvoie un *tuple* contenant les " +"chaînes pour tous les sous-groupes, en commençant par le numéro 1 jusqu'au " +"dernier. ::" #: ../Doc/howto/regex.rst:854 msgid "" @@ -1497,10 +1738,18 @@ msgid "" "including arbitrary characters in a string, so be sure to use a raw string " "when incorporating backreferences in a RE." msgstr "" +"Les renvois dans un motif vous permettent de spécifier que le contenu d'un " +"groupe précédent doit aussi être trouvé à l'emplacement actuel dans la " +"chaîne. Par exemple, ``\\1`` réussit si le contenu du premier groupe se " +"trouve aussi à la position courante, sinon il échoue. Rappelez-vous que les " +"littéraux de chaînes Python utilisent aussi la barre oblique inverse suivie " +"d'un nombre pour insérer des caractères arbitraires dans une chaîne ; soyez " +"sûr d'utiliser une chaîne brute quand vous faites des renvois dans une RE." #: ../Doc/howto/regex.rst:862 msgid "For example, the following RE detects doubled words in a string. ::" msgstr "" +"Par exemple, la RE suivante détecte les mots doublés dans une chaîne. ::" #: ../Doc/howto/regex.rst:868 msgid "" @@ -1509,10 +1758,14 @@ msgid "" "you'll soon find out that they're *very* useful when performing string " "substitutions." msgstr "" +"Les renvois tels que celui-ci ne sont pas très utiles pour effectuer une " +"simple recherche dans une chaîne --- il n'y a que peu de formats de textes " +"qui répètent des données ainsi --- mais vous verrez bientôt qu'ils sont " +"*très* utiles pour effectuer des substitutions dans les chaînes." #: ../Doc/howto/regex.rst:874 msgid "Non-capturing and Named Groups" -msgstr "" +msgstr "Groupes non de capture et groupes nommés" #: ../Doc/howto/regex.rst:876 msgid "" @@ -1522,6 +1775,13 @@ msgid "" "help with this problem. Both of them use a common syntax for regular " "expression extensions, so we'll look at that first." msgstr "" +"Les RE élaborées peuvent utiliser de nombreux groupes, à la fois pour " +"capturer des sous-chaînes intéressantes ainsi que pour regrouper et " +"structurer la RE elle-même. Dans les RE complexes, il devient difficile de " +"garder la trace des numéros de groupes. Deux caractéristiques aident à " +"résoudre ce problème, toutes deux utilisant la même syntaxe d'extension des " +"expressions régulières. Nous allons donc commencer en examinant cette " +"syntaxe." #: ../Doc/howto/regex.rst:882 msgid "" @@ -1533,6 +1793,14 @@ msgid "" "expressions would be assuming that ``&`` was a regular character and " "wouldn't have escaped it by writing ``\\&`` or ``[&]``." msgstr "" +"Les puissantes extensions des expressions régulières de Perl 5 sont " +"réputées. Pour les mettre en œuvre, 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 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 expressions déjà écrites " +"auraient considéré que ``&`` était un caractère standard et ne l'aurait pas " +"échappé en écrivant ``\\&`` ou ``[&]``." #: ../Doc/howto/regex.rst:889 msgid "" @@ -1544,6 +1812,13 @@ msgid "" "positive lookahead assertion) and ``(?:foo)`` is something else (a non-" "capturing group containing the subexpression ``foo``)." msgstr "" +"La solution adoptée par les développeurs Perl a été d'utiliser ``(?...)`` " +"comme syntaxe d'extension. Placer ``?`` immédiatement après une parenthèse " +"était une erreur de syntaxe, parce que le ``?`` n'a alors rien à répéter. " +"Ainsi, cela n'a pas introduit de problème de compatibilité. Les caractères " +"qui suivent immédiatement le ``?`` indiquent quelle extension est utilisée, " +"donc ``(?=truc)`` est une chose (une assertion positive anticipée) et ``(?:" +"truc)`` est une autre chose (la sous-expression ``truc`` que l'on groupe)." #: ../Doc/howto/regex.rst:897 msgid "" @@ -1551,12 +1826,19 @@ msgid "" "Perl's extension syntax. If the first character after the question mark is " "a ``P``, you know that it's an extension that's specific to Python." msgstr "" +"Python gère plusieurs des extensions Perl et rajoute une extension à la " +"syntaxe des extensions Perl. Si le premier caractère après le point " +"d'interrogation est ``P``, cela signifie que c'est une extension spécifique " +"à Python." #: ../Doc/howto/regex.rst:902 msgid "" "Now that we've looked at the general extension syntax, we can return to the " "features that simplify working with groups in complex REs." msgstr "" +"Après avoir vu la syntaxe générale d'extension des RE, nous pouvons revenir " +"aux fonctionnalités qui simplifient le travail avec les groupes dans des RE " +"complexes." #: ../Doc/howto/regex.rst:905 msgid "" @@ -1565,6 +1847,12 @@ msgid "" "can make this fact explicit by using a non-capturing group: ``(?:...)``, " "where you can replace the ``...`` with any other regular expression. ::" msgstr "" +"Parfois, vous souhaitez utiliser un groupe pour marquer une partie de " +"l'expression régulière mais le contenu de ce groupe ne vous intéresse pas " +"vraiment. Vous pouvez l'indiquer explicitement en utilisant la syntaxe de " +"groupe, mais sans indiquer que vous voulez en capturer le contenu : " +"``(?:...)``, où vous remplacez les ``...`` par n'importe quelle expression " +"régulière. ::" #: ../Doc/howto/regex.rst:917 msgid "" @@ -1578,12 +1866,24 @@ msgid "" "performance difference in searching between capturing and non-capturing " "groups; neither form is any faster than the other." msgstr "" +"À part le fait que vous n'avez pas accès au contenu du groupe, un groupe se " +"comporte exactement de la même manière qu'un groupe de capture ; vous pouvez " +"placer n'importe quoi dedans, spécifier une répétition avec un métacaractère " +"tel que ``*`` et l'imbriquer dans un autre groupe (de capture ou pas). " +"``(?:...)`` est particulièrement utile quand vous modifiez des motifs " +"existants, puisque vous pouvez ajouter de nouveaux groupes sans changer la " +"façon dont les autres groupes sont numérotés. Nous devons mentionner ici " +"qu'il n'y a aucune différence de performance dans la recherche de groupes, " +"de capture ou non ; les deux formes travaillent à la même vitesse." #: ../Doc/howto/regex.rst:926 msgid "" "A more significant feature is named groups: instead of referring to them by " "numbers, groups can be referenced by a name." msgstr "" +"Une fonctionnalité plus importante est le nommage des groupes : au lieu d'y " +"faire référence par des nombres, vous pouvez référencer des groupes par leur " +"nom." #: ../Doc/howto/regex.rst:929 msgid "" @@ -1596,6 +1896,15 @@ msgid "" "still given numbers, so you can retrieve information about a group in two " "ways::" msgstr "" +"La syntaxe pour nommer les groupes est l'une des extensions spécifiques à " +"Python : ``(?P....)```. *nom* est, vous vous en doutez, le nom du " +"groupe. Les groupes nommés se comportent exactement comme des groupes de " +"capture, sauf qu'ils associent en plus un nom à un groupe. Les méthodes des :" +"ref:`objets correspondances ` qui gèrent les groupes de " +"capture acceptent soit des entiers qui font référence aux numéros des " +"groupes, soit des chaînes de caractères qui désignent les noms des groupes " +"désirés. Les groupes nommés se voient toujours attribuer un numéro, vous " +"pouvez ainsi récupérer les informations d'un groupe de deux façons ::" #: ../Doc/howto/regex.rst:944 msgid "" @@ -1603,12 +1912,16 @@ msgid "" "instead of having to remember numbers. Here's an example RE from the :mod:" "`imaplib` module::" msgstr "" +"Les groupes nommés sont pratiques car il est plus facile de se rappeler un " +"nom qu'un numéro. Voici un exemple de RE tirée du module :mod:`imaplib` ::" #: ../Doc/howto/regex.rst:955 msgid "" "It's obviously much easier to retrieve ``m.group('zonem')``, instead of " "having to remember to retrieve group 9." msgstr "" +"Il est évidemment plus facile de récupérer ``m.group('zonem')`` que de se " +"rappeler de récupérer le groupe 9." #: ../Doc/howto/regex.rst:958 msgid "" @@ -1620,10 +1933,17 @@ msgid "" "words, ``\\b(\\w+)\\s+\\1\\b`` can also be written as ``\\b(?P\\w+)\\s" "+(?P=word)\\b``::" msgstr "" +"La syntaxe des renvois dans une expression telle que ``(....)\\1`` fait " +"référence au numéro du groupe. Il y a naturellement une variante qui utilise " +"le nom du groupe au lieu du numéro. C'est une autre extension Python : ``(?" +"P=nom)`` indique que le contenu du groupe appelé *nom* doit correspondre à " +"nouveau avec l'emplacement courant. L'expression régulière pour trouver des " +"mots doublés, ``\\b(\\w+)\\s+\\1\\b`` peut ainsi être ré-écrite en ``\\b(?" +"P\\w+)\\s+(?P=mot)\\b`` ::" #: ../Doc/howto/regex.rst:971 msgid "Lookahead Assertions" -msgstr "" +msgstr "Assertions prédictives" #: ../Doc/howto/regex.rst:973 msgid "" @@ -1631,6 +1951,9 @@ msgid "" "assertions are available in both positive and negative form, and look like " "this:" msgstr "" +"Une autre assertion de largeur zéro est l'assertion prédictive. Une " +"assertion prédictive peut s'exprimer sous deux formes, la positive et la " +"négative, comme ceci :" #: ../Doc/howto/regex.rst:981 msgid "``(?=...)``" @@ -1644,6 +1967,12 @@ msgid "" "tried, the matching engine doesn't advance at all; the rest of the pattern " "is tried right where the assertion started." msgstr "" +"Assertion prédictive positive. Elle réussit si l'expression régulière " +"contenue, représentée ici par ``...``, correspond effectivement à " +"l'emplacement courant ; dans le cas contraire, elle échoue. Mais, une fois " +"que l'expression contenue a été essayée, le moteur de correspondance " +"n'avance pas ; le reste du motif est testé à l'endroit même où l'assertion a " +"commencé." #: ../Doc/howto/regex.rst:986 msgid "``(?!...)``" @@ -1655,6 +1984,9 @@ msgid "" "assertion; it succeeds if the contained expression *doesn't* match at the " "current position in the string." msgstr "" +"Assertion prédictive négative. C'est l'opposée de l'assertion positive ; " +"elle réussit si l'expression régulière contenue *ne* correspond *pas* à " +"l'emplacement courant dans la chaine." #: ../Doc/howto/regex.rst:988 msgid "" @@ -1663,14 +1995,19 @@ msgid "" "name and an extension, separated by a ``.``. For example, in ``news.rc``, " "``news`` is the base name, and ``rc`` is the filename's extension." msgstr "" +"Pour rendre ceci plus concret, regardons le cas où une prédiction est utile. " +"Considérons un motif simple qui doit faire correspondre un nom de fichier et " +"le diviser en un nom de base et une extension, séparés par un ``.``. Par " +"exemple, dans ``news.rc``, ``news`` est le nom de base et ``rc`` est " +"l'extension du nom de fichier." #: ../Doc/howto/regex.rst:993 msgid "The pattern to match this is quite simple:" -msgstr "Le motif de correspondance est plutôt simple: " +msgstr "Le motif de correspondance est plutôt simple :" #: ../Doc/howto/regex.rst:995 msgid "``.*[.].*$``" -msgstr "" +msgstr "``.*[.].*$``" #: ../Doc/howto/regex.rst:997 msgid "" @@ -1681,12 +2018,21 @@ msgid "" "expression matches ``foo.bar`` and ``autoexec.bat`` and ``sendmail.cf`` and " "``printers.conf``." msgstr "" +"Notez que le ``.`` doit être traité spécialement car c'est un métacaractère, " +"nous le plaçons donc à l'intérieur d'une classe de caractères pour ne faire " +"correspondre que ce caractère spécifique. Notez également le ``$`` en fin ; " +"nous l'avons ajouté pour nous assurer que tout le reste de la chaîne est " +"bien inclus dans l'extension. Cette expression régulière fait correspondre " +"``truc.bar``, ``autoexec.bat``, ``sendmail.cf`` et ``printers.conf``." #: ../Doc/howto/regex.rst:1004 msgid "" "Now, consider complicating the problem a bit; what if you want to match " "filenames where the extension is not ``bat``? Some incorrect attempts:" msgstr "" +"Maintenant, compliquons un peu le problème ; si nous voulons faire " +"correspondre les noms de fichiers dont l'extension n'est pas ``bat`` ? voici " +"quelques tentatives incorrectes :" #: ../Doc/howto/regex.rst:1007 msgid "" @@ -1694,10 +2040,13 @@ msgid "" "requiring that the first character of the extension is not a ``b``. This is " "wrong, because the pattern also doesn't match ``foo.bar``." msgstr "" +"``.*[.][^b].*$`` Le premier essai ci-dessus tente d'exclure ``bat`` en " +"spécifiant que le premier caractère de l'extension ne doit pas être ``b``. " +"Cela ne fonctionne pas, car le motif n'accepte pas ``truc.bar``." #: ../Doc/howto/regex.rst:1011 msgid "``.*[.]([^b]..|.[^a].|..[^t])$``" -msgstr "" +msgstr "``.*[.]([^b]..|.[^a].|..[^t])$``" #: ../Doc/howto/regex.rst:1013 msgid "" @@ -1709,10 +2058,18 @@ msgid "" "with a two-letter extension such as ``sendmail.cf``. We'll complicate the " "pattern again in an effort to fix it." msgstr "" +"L'expression devient plus confuse si nous essayons de réparer la première " +"solution en spécifiant l'un des cas suivants : le premier caractère de " +"l'extension n'est pas ``b`` ; le deuxième caractère n'est pas ``a`` ; ou le " +"troisième caractère n'est pas ``t```. Ce motif accepte ``truc.bar`` et " +"rejette ``autoexec.bat``, mais elle nécessite une extension de trois lettres " +"et n'accepte pas un nom de fichier avec une extension de deux lettres comme " +"``sendmail.cf``. Compliquons encore une fois le motif pour essayer de le " +"réparer." #: ../Doc/howto/regex.rst:1021 msgid "``.*[.]([^b].?.?|.[^a]?.?|..?[^t]?)$``" -msgstr "" +msgstr "``.*[.]([^b].?.?|.[^a]?.?|..?[^t]?)$``" #: ../Doc/howto/regex.rst:1023 msgid "" @@ -1720,6 +2077,9 @@ msgid "" "order to allow matching extensions shorter than three characters, such as " "``sendmail.cf``." msgstr "" +"Pour cette troisième tentative, les deuxième et troisième lettres sont " +"devenues facultatives afin de permettre la correspondance avec des " +"extensions plus courtes que trois caractères, comme ``sendmail.cf``." #: ../Doc/howto/regex.rst:1027 msgid "" @@ -1728,10 +2088,14 @@ msgid "" "``bat`` and ``exe`` as extensions, the pattern would get even more " "complicated and confusing." msgstr "" +"Le motif devient vraiment compliqué maintenant, ce qui le rend difficile à " +"lire et à comprendre. Pire, si le problème change et que vous voulez exclure " +"à la fois ``bat`` et ``exe`` en tant qu'extensions, le modèle deviendra " +"encore plus compliqué et confus." #: ../Doc/howto/regex.rst:1032 msgid "A negative lookahead cuts through all this confusion:" -msgstr "" +msgstr "Une assertion prédictive négative supprime toute cette confusion :" #: ../Doc/howto/regex.rst:1034 msgid "" @@ -1742,6 +2106,13 @@ msgid "" "starts with ``bat``, will be allowed. The ``[^.]*`` makes sure that the " "pattern works when there are multiple dots in the filename." msgstr "" +"``.*[.](?!bat$)[^.]*$`` Cette assertion prédictive négative signifie : si " +"l'expression ``bat`` ne correspond pas à cet emplacement, essaie le reste du " +"motif ; si ``bat$`` correspond, tout le motif échoue. Le ``$`` est " +"nécessaire pour s'assurer que quelque chose comme ``sample.batch``, où c'est " +"seulement le début de l'extension qui vaut ``bat``, est autorisé. Le " +"``[^...]*`` s'assure que le motif fonctionne lorsqu'il y a plusieurs points " +"dans le nom de fichier." #: ../Doc/howto/regex.rst:1041 msgid "" @@ -1749,14 +2120,17 @@ msgid "" "alternative inside the assertion. The following pattern excludes filenames " "that end in either ``bat`` or ``exe``:" msgstr "" +"Exclure une autre extension de nom de fichier est maintenant facile ; il " +"suffit de l'ajouter comme alternative à l'intérieur de l'assertion. Le motif " +"suivant exclut les noms de fichiers qui se terminent par ``bat`` ou ``exe`` :" #: ../Doc/howto/regex.rst:1045 msgid "``.*[.](?!bat$|exe$)[^.]*$``" -msgstr "" +msgstr "``.*[.](?!bat$|exe$)[^.]*$``" #: ../Doc/howto/regex.rst:1049 msgid "Modifying Strings" -msgstr "" +msgstr "Modification de chaînes" #: ../Doc/howto/regex.rst:1051 msgid "" @@ -1764,10 +2138,14 @@ msgid "" "Regular expressions are also commonly used to modify strings in various " "ways, using the following pattern methods:" msgstr "" +"Jusqu'à présent, nous avons simplement effectué des recherches dans une " +"chaîne statique. Les expressions régulières sont aussi couramment utilisées " +"pour modifier les chaînes de caractères de diverses manières, en utilisant " +"les méthodes suivantes des motifs :" #: ../Doc/howto/regex.rst:1058 msgid "``split()``" -msgstr "" +msgstr "``split()``" #: ../Doc/howto/regex.rst:1058 msgid "Split the string into a list, splitting it wherever the RE matches" @@ -1777,29 +2155,31 @@ msgstr "" #: ../Doc/howto/regex.rst:1061 msgid "``sub()``" -msgstr "" +msgstr "``sub()``" #: ../Doc/howto/regex.rst:1061 msgid "" "Find all substrings where the RE matches, and replace them with a different " "string" msgstr "" -"Rechercher toutes les sous-chaînes de caractères où correspond la RE et les " -"substituer par une chaîne de caractères différente " +"Recherche toutes les sous-chaînes de caractères où la RE correspond et les " +"substitue par une chaîne de caractères différente" #: ../Doc/howto/regex.rst:1064 msgid "``subn()``" -msgstr "" +msgstr "``subn()``" #: ../Doc/howto/regex.rst:1064 msgid "" "Does the same thing as :meth:`!sub`, but returns the new string and the " "number of replacements" msgstr "" +"Fait la même chose que :meth:`!sub`, mais renvoie la nouvelle chaîne et le " +"nombre de remplacements effectués" #: ../Doc/howto/regex.rst:1071 msgid "Splitting Strings" -msgstr "" +msgstr "Découpage de chaînes" #: ../Doc/howto/regex.rst:1073 msgid "" @@ -1810,6 +2190,13 @@ msgid "" "splitting by whitespace or by a fixed string. As you'd expect, there's a " "module-level :func:`re.split` function, too." msgstr "" +"La méthode :meth:`~re.Pattern.Pattern.split` d'un motif divise une chaîne de " +"caractères à chaque fois que la RE correspond, retournant la liste des " +"morceaux. C'est similaire à la méthode :meth:`~str.split` mais est beaucoup " +"plus générale par les délimiteurs que vous pouvez spécifier ; la méthode :" +"meth:`!split` du type *string* 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." #: ../Doc/howto/regex.rst:1084 msgid "" @@ -1818,6 +2205,10 @@ msgid "" "part of the resulting list. If *maxsplit* is nonzero, at most *maxsplit* " "splits are performed." msgstr "" +"Découpe *string* en suivant les correspondances de l'expression régulière. " +"Si des parenthèses de capture sont utilisées dans la RE, leur contenu est " +"également renvoyé dans la liste résultante. Si *maxsplit* n'est pas nul, au " +"plus *maxsplit* découpages sont effectués." #: ../Doc/howto/regex.rst:1089 msgid "" @@ -1827,6 +2218,11 @@ msgid "" "the following example, the delimiter is any sequence of non-alphanumeric " "characters. ::" msgstr "" +"Vous pouvez limiter le nombre de découpages effectués en passant une valeur " +"pour *maxsplit*. Quand *maxsplit* n'est pas nul, au plus *maxsplit* " +"découpages sont effectués et le reste de la chaîne est renvoyé comme dernier " +"élément de la liste. Dans l'exemple suivant, le délimiteur est toute " +"séquence de caractères non alphanumériques. ::" #: ../Doc/howto/regex.rst:1101 msgid "" @@ -1835,16 +2231,22 @@ msgid "" "used in the RE, then their values are also returned as part of the list. " "Compare the following calls::" msgstr "" +"Parfois, vous voulez récupérer le texte entre les délimiteurs mais aussi " +"quel était le délimiteur. Si des parenthèses de capture sont utilisées dans " +"la RE, leurs valeurs sont également renvoyées dans la liste. Comparons les " +"appels suivants ::" #: ../Doc/howto/regex.rst:1113 msgid "" "The module-level function :func:`re.split` adds the RE to be used as the " "first argument, but is otherwise the same. ::" msgstr "" +"La fonction de niveau module :func:`re.split` ajoute la RE à utiliser comme " +"premier argument, mais est par ailleurs identique. ::" #: ../Doc/howto/regex.rst:1125 msgid "Search and Replace" -msgstr "Recherche et Substitution" +msgstr "Recherche et substitution" #: ../Doc/howto/regex.rst:1127 msgid "" @@ -1853,6 +2255,10 @@ msgid "" "replacement value, which can be either a string or a function, and the " "string to be processed." msgstr "" +"Une autre tâche classique est de trouver toutes les correspondances d'un " +"motif et de les remplacer par une autre chaîne. La méthode :meth:`~re." +"Pattern.sub` prend une valeur de substitution, qui peut être une chaîne de " +"caractères ou une fonction, et la chaîne à traiter." #: ../Doc/howto/regex.rst:1134 msgid "" @@ -1860,6 +2266,9 @@ msgid "" "occurrences of the RE in *string* by the replacement *replacement*. If the " "pattern isn't found, *string* is returned unchanged." msgstr "" +"Renvoie la chaîne obtenue en remplaçant les occurrences sans chevauchement " +"les plus à gauche de la RE dans *string* par la substitution *replacement*. " +"Si le motif n'est pas trouvé, *string* est renvoyée inchangée." #: ../Doc/howto/regex.rst:1138 msgid "" @@ -1867,12 +2276,17 @@ msgid "" "to be replaced; *count* must be a non-negative integer. The default value " "of 0 means to replace all occurrences." msgstr "" +"L'argument optionnel *count* est le nombre maximum d'occurrences du motif à " +"remplacer ; *count* doit être un entier positif ou nul. La valeur par défaut " +"de 0 signifie qu'il faut remplacer toutes les occurrences." #: ../Doc/howto/regex.rst:1142 msgid "" "Here's a simple example of using the :meth:`~re.Pattern.sub` method. It " "replaces colour names with the word ``colour``::" msgstr "" +"Voici un exemple simple utilisant la méthode :meth:`~re.Pattern.sub`. Nous " +"remplaçons les noms des couleurs par le mot ``colour`` ::" #: ../Doc/howto/regex.rst:1151 msgid "" @@ -1880,12 +2294,17 @@ msgid "" "tuple containing the new string value and the number of replacements that " "were performed::" msgstr "" +"La méthode :meth:`~re.Pattern.subn.subn` fait la même chose mais renvoie un " +"couple contenant la nouvelle valeur de la chaîne de caractères et le nombre " +"de remplacements effectués ::" #: ../Doc/howto/regex.rst:1160 msgid "" "Empty matches are replaced only when they're not adjacent to a previous " "empty match. ::" msgstr "" +"Les correspondances vides ne sont remplacées que lorsqu'elles ne sont pas " +"adjacentes à une correspondance vide précédente. ::" #: ../Doc/howto/regex.rst:1167 msgid "" @@ -1897,12 +2316,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 "" @@ -1915,6 +2343,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 "" @@ -1924,12 +2361,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 "" @@ -1940,10 +2385,17 @@ msgid "" "pattern string, e.g. ``sub(\"(?i)b+\", \"x\", \"bbbb BBBB\")`` returns ``'x " "x'``." msgstr "" +"Quand vous utilisez la fonction de niveau module :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" +"\")```renvoie ``'x x'``." #: ../Doc/howto/regex.rst:1224 msgid "Common Problems" -msgstr "Problèmes courants" +msgstr "Problèmes classiques" #: ../Doc/howto/regex.rst:1226 msgid "" @@ -1952,10 +2404,14 @@ 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" -msgstr "" +msgstr "Utilisez les méthodes du type *string*" #: ../Doc/howto/regex.rst:1234 msgid "" @@ -1968,6 +2424,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 "" @@ -1981,6 +2445,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`. " +"Notons que :meth:`!replace` remplace 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 "" @@ -1990,16 +2463,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 "" @@ -2010,12 +2490,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 "" @@ -2028,6 +2516,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 "" @@ -2035,10 +2532,14 @@ 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" -msgstr "" +msgstr "Glouton contre non-glouton" #: ../Doc/howto/regex.rst:1300 msgid "" @@ -2048,6 +2549,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 "" @@ -2058,6 +2565,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 "" @@ -2067,6 +2581,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 "" @@ -2077,10 +2597,16 @@ 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" -msgstr "Utilisez `re.VERBOSE`" +msgstr "Utilisez *re.VERBOSE*" #: ../Doc/howto/regex.rst:1340 msgid "" @@ -2089,6 +2615,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 "" @@ -2096,6 +2627,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 "" @@ -2107,6 +2641,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::" @@ -2114,7 +2657,7 @@ msgstr "Ceci est beaucoup plus lisible que::" #: ../Doc/howto/regex.rst:1372 msgid "Feedback" -msgstr "Retour" +msgstr "Vos commentaires" #: ../Doc/howto/regex.rst:1374 msgid "" @@ -2124,8 +2667,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 @@ -2141,8 +2684,8 @@ msgstr "" "Le livre le plus complet sur les expressions régulières est certainement " "Mastering Regular Expressions de Jeffrey Friedl, publié par O'Reilly. " "Malheureusement, il se concentre sur les déclinaisons Perl et Java des " -"expressions régulières et ne contient aucun contenu pour Python; il n'est " +"expressions régulières et ne contient aucun contenu pour Python ; il n'est " "donc pas utile d'en faire référence pour la programmation Python. (La " -"première édition traitée du module Python :mod:`!regex`, maintenant " +"première édition traitait du module Python :mod:`!regex`, maintenant " "supprimé, ce qui ne vous aidera pas beaucoup.) Pensez à le retirer de votre " "bibliothèque."