diff --git a/howto/regex.po b/howto/regex.po index f5ff5de9..6abeaf80 100644 --- a/howto/regex.po +++ b/howto/regex.po @@ -6,18 +6,18 @@ 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-06-17 11:06+0200\n" +"PO-Revision-Date: 2018-07-22 16:05+0200\n" "Last-Translator: Nabil Bendafi \n" "Language-Team: FRENCH \n" "Language: fr\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" -"X-Generator: Poedit 1.8.11\n" +"X-Generator: Poedit 2.0.2\n" #: ../Doc/howto/regex.rst:5 msgid "Regular Expression HOWTO" -msgstr "Guide des Expressions régulières" +msgstr "Guide des expressions régulières" #: ../Doc/howto/regex.rst:0 msgid "Author" @@ -25,7 +25,7 @@ msgstr "Auteur" #: ../Doc/howto/regex.rst:7 msgid "A.M. Kuchling " -msgstr "" +msgstr "A.M. Kuchling " #: ../Doc/howto/regex.rst:None msgid "Abstract" @@ -37,10 +37,10 @@ msgid "" "Python with the :mod:`re` module. It provides a gentler introduction than " "the corresponding section in the Library Reference." msgstr "" -"Ce document est un guide d'introduction à l'utilisation des expressions " -"régulières en Python avec le module :mod:`re`. Il fournit une introduction " -"plus abordable que la section correspondante dans le guide de référence des " -"bibliothèques." +"Ce document constitue un guide d'introduction à l'utilisation des " +"expressions régulières en Python avec le module :mod:`re`. Il fournit une " +"introduction plus abordable que la section correspondante dans le guide de " +"référence de la bibliothèque." #: ../Doc/howto/regex.rst:24 msgid "Introduction" @@ -58,18 +58,18 @@ msgid "" "match for the pattern anywhere in this string?\". You can also use REs to " "modify a string or to split it apart in various ways." msgstr "" -"Les expressions régulières (appelées RE, ou regexes, ou motifs regex) sont " +"Les expressions régulières (notées RE ou motifs regex dans ce document) sont " "essentiellement un petit langage de programmation hautement spécialisé " "embarqué dans Python et dont la manipulation est rendue possible par " "l'utilisation du module :mod:`re`. En utilisant ce petit langage, vous " -"spécifiez les règles pour l'ensemble des chaînes des caractères possibles " -"pour lesquelles vous voulez une correspondance; cet ensemble contient des " -"phrases en Anglais, ou des adresses de courriel, ou des commandes TeX, ou " -"tout ce que vous voulez. Vous pouvez ensuite poser des questions tel que " -"\"Est-ce que cette chaîne de caractères correspond au motif ?\", ou \"Y-a-" -"t'il une correspondance pour un motif dans le chaîne de caractères ?\". Vous " -"pouvez aussi utiliser les RE pour modifier une chaîne de caractères ou la " -"découper de différentes façons." +"définissez des règles pour spécifier une correspondance avec un ensemble " +"souhaité de chaînes de caractères ; ces chaînes peuvent être des phrases, " +"des adresses de courriel, des commandes TeX ou tout ce que vous voulez. Vous " +"pouvez ensuite poser des questions telles que \"Est-ce que cette chaîne de " +"caractères correspond au motif ?\" ou \"Y-a-t'il une correspondance pour ce " +"motif à l'intérieur de la chaîne de caractères ?\". Vous pouvez aussi " +"utiliser les RE pour modifier une chaîne de caractères ou la découper de " +"différentes façons." #: ../Doc/howto/regex.rst:35 msgid "" @@ -81,13 +81,13 @@ msgid "" "requires that you have a good understanding of the matching engine's " "internals." msgstr "" -"Les motifs d'expressions régulières sont compilés en **bytecodes** qui sont " -"ensuite exécutés 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 **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." #: ../Doc/howto/regex.rst:42 msgid "" @@ -99,13 +99,13 @@ msgid "" "be slower than an elaborate regular expression, it will also probably be " "more understandable." msgstr "" -"Le langage d'expressions régulières est relativement petit et restreint donc " -"toutes les tâches de manipulation de chaînes de caractères ne peuvent pas " -"être réalisées à l'aide d'expressions régulières. Il y a aussi des tâches " -"qui *peuvent* être réalisées à l'aide d'expressions régulières mais qui ont " -"tendance à produire des expressions régulières très compliquées. Dans ces " -"cas, il vous sera plus utile d'écrire du code Python pour réaliser le " -"traitement; même si le code Python sera plus lent qu'une expression " +"Le langage des expressions régulières est relativement petit et restreint, " +"donc toutes les tâches de manipulation de chaînes de caractères ne peuvent " +"pas être réalisées à l'aide d'expressions régulières. Il existe aussi des " +"tâches qui *peuvent* être réalisées à l'aide d'expressions régulières mais " +"qui ont tendance à produire des expressions régulières très compliquées. " +"Dans ces cas, il est plus utile d'écrire du code Python pour réaliser le " +"traitement ; même si le code Python est plus lent qu'une expression " "régulière élaborée, il sera probablement plus compréhensible." #: ../Doc/howto/regex.rst:51 @@ -118,10 +118,10 @@ msgid "" "Since regular expressions are used to operate on strings, we'll begin with " "the most common task: matching characters." msgstr "" -"Nous commencerons par étudier les expressions régulières les plus simples. " +"Nous commençons par étudier les expressions régulières les plus simples. " "Dans la mesure où les expressions régulières sont utilisées pour manipuler " -"des chaînes de caractères, nous commencerons par les tâches les plus " -"communes: la correspondance de caractères ." +"des chaînes de caractères, nous commençons par l'action la plus courante : " +"la correspondance de caractères." #: ../Doc/howto/regex.rst:57 msgid "" @@ -129,13 +129,14 @@ msgid "" "expressions (deterministic and non-deterministic finite automata), you can " "refer to almost any textbook on writing compilers." msgstr "" -"Pour une explication détaillée sur la technologie sous-jacente des " -"expressions régulières (automate d'état déterministe et non-déterministe), " -"référez-vous à n'importe quel manuel sur l'écriture de compilateurs." +"Pour une explication détaillée sur le concept informatique sous-jacent aux " +"expressions régulières (automate à états déterministe ou non-déterministe), " +"vous pouvez vous référer à n'importe quel manuel sur l'écriture de " +"compilateurs." #: ../Doc/howto/regex.rst:63 msgid "Matching Characters" -msgstr "Caractères correspondants" +msgstr "Correspondance de caractères" #: ../Doc/howto/regex.rst:65 msgid "" @@ -144,11 +145,11 @@ msgid "" "can enable a case-insensitive mode that would let this RE match ``Test`` or " "``TEST`` as well; more about this later.)" msgstr "" -"La plupart des lettres ou caractères vont correspondre à eux-mêmes. Par " -"exemple, l'expression régulière ``test`` correspond à la chaîne de caractère " -"``test`` précisément. (Vous pouvez activer le mode non-sensible à la casse " -"qui permet à cette RE de correspondre à ``Test`` ou ``TEST`` également; plus " -"à ce sujet dans la suite.) " +"La plupart des lettres ou caractères correspondent simplement à eux-mêmes. " +"Par exemple, l'expression régulière ``test`` correspond à la chaîne de " +"caractères ``test``, précisément. Vous pouvez activer le mode non-sensible à " +"la casse qui permet à cette RE de correspondre également à ``Test`` ou " +"``TEST`` (ce sujet est traité par la suite)." #: ../Doc/howto/regex.rst:70 msgid "" @@ -159,19 +160,19 @@ msgid "" "this document is devoted to discussing various metacharacters and what they " "do." msgstr "" -"Il y a des exceptions à cette règle; certains caractères sont des :dfn:" -"`metacharacters` spéciaux et ne correspondent pas à eux-mêmes. Au lieu de " -"cela, ils signalent que certaines choses non ordinaires doivent " -"correspondre, ou 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." +"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." #: ../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éta-caractères; leurs sens sera décrit dans la " +"Voici une liste complète des métacaractères ; leurs sens est décrit dans la " "suite de ce guide." #: ../Doc/howto/regex.rst:83 @@ -185,16 +186,15 @@ msgid "" "characters. If you wanted to match only lowercase letters, your RE would be " "``[a-z]``." msgstr "" -"Les premiers méta-caractères que nous étudions sont ``[`` et ``]``. Ils sont " +"Les premiers métacaractères que nous étudions sont ``[`` et ``]``. Ils sont " "utilisés pour spécifier une classe de caractères, qui forme un ensemble de " "caractères dont vous souhaitez trouver la correspondance. Les caractères " "peuvent être listés individuellement, ou une plage de caractères peut être " "indiquée en fournissant deux caractères séparés par un `'-'``. Par exemple, " -"``[abc]`` correspondra à n'importe quel caractère parmi ``a``, ``b``, ou " -"``c``; ce qui est équivalent à ``[a-c]``, qui utilise une plage pour " -"exprimer le même ensemble de caractères. Si vous voulez trouver une " -"correspondance avec uniquement les lettres en minuscule, votre RE sera ``[a-" -"z]``." +"``[abc]`` correspond à n'importe quel caractère parmi ``a``, ``b``, ou " +"``c`` ; c'est équivalent à ``[a-c]``, qui utilise une plage pour exprimer le " +"même ensemble de caractères. Si vous voulez trouver une chaîne qui ne " +"contient que des lettres en minuscules, la RE est ``[a-z]``." #: ../Doc/howto/regex.rst:92 msgid "" @@ -203,10 +203,10 @@ msgid "" "is usually a metacharacter, but inside a character class it's stripped of " "its special nature." msgstr "" -"Les méta-caractères ne sont pas actifs dans les classes. Par exemple, ``[akm" -"$]`` correspondra à n'importe quel caractère parmi ``'a'``, ``'k'``, " -"``'m'``, ou ``'$'``; ``'$'`` est habituellement un méta-caractère mais dans " -"une classe de caractères, il est dépourvu de son caractère spécial." +"Les métacaractères ne sont pas actifs dans les classes. Par exemple, ``[akm" +"$]`` correspond à n'importe quel caractère parmi ``'a'``, ``'k'``, ``'m'`` " +"ou ``'$'`` ; ``'$'`` est habituellement un métacaractère mais dans une " +"classe de caractères, il est dépourvu de sa signification spéciale." #: ../Doc/howto/regex.rst:97 msgid "" @@ -217,11 +217,11 @@ msgid "" "except ``'5'``." msgstr "" "Vous pouvez trouvez une correspondance avec les caractères non listés dans " -"une classe en complimentant (:dfn:`complementing`) l'ensemble. Ceci est " -"indiqué en incluant un ``'^'`` en tant que premier caractère de la classe; " -"``'^'`` en dehors d'une classe de caractères correspondra au caractère " -"``'^'``. Par exemple, ``[^5]`` correspondra à tout les caractères, sauf " -"``[^5]``." +"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 +232,14 @@ msgid "" "need to match a ``[`` or ``\\``, you can precede them with a backslash to " "remove their special meaning: ``\\[`` or ``\\\\``." msgstr "" -"Le méta-caractère qui est probablement le plus important est le " -"**backslash**, ``\\``. 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 tout les " -"méta-caractères afin d'en trouver les correspondances dans les motifs; par " -"exemple, si vous devait trouver une correspondance pour ``[`` ou ``\\`, " -"vous pouvais les précéder avec un **backslash** pour supprimer leur " -"caractères spécial : ``\\[`` ou ``\\\\``." +"Le métacaractère probablement le plus important est 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 ``\\\\``." #: ../Doc/howto/regex.rst:109 msgid "" @@ -249,8 +249,8 @@ msgid "" msgstr "" "Certaines séquences spéciales commençant par ``'\\'`` représentent des " "ensembles de caractères prédéfinis qui sont souvent utiles, tels que " -"l'ensemble des chiffres, l'ensemble des lettres, ou l'ensemble des " -"caractères qui ne sont pas des séparateurs." +"l'ensemble des chiffres, l'ensemble des lettres ou l'ensemble des caractères " +"qui ne sont pas des \"blancs\"." #: ../Doc/howto/regex.rst:114 msgid "" @@ -262,14 +262,14 @@ 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ères " -"alphanumérique. Si le motif **regex** est exprimé en octets, il est " -"équivalent à la classe ``[a-zA-Z0-9_]``. Si le motif **regex** est une " -"chaîne de caractères, ``\\w`` correspondra à tout les caractères identifiés " -"comme lettre dans le base de données Unicode fourni par le module :mod:" +"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 " +"comme lettre dans la base de données Unicode fournie par le module :mod:" "`unicodedata`. Vous pouvez utiliser la définition plus restrictive de ``" -"\\w`` dans un motif de chaîne de caractères en spécifiant le fanion :const:" -"`re.ASCII` lors de la compilation de l'expression régulière." +"\\w`` dans un motif exprimé en chaîne de caractères en spécifiant l'option :" +"const:`re.ASCII` lors de la compilation de l'expression régulière." #: ../Doc/howto/regex.rst:122 msgid "" @@ -280,12 +280,12 @@ msgid "" "character that's in the appropriate category in the Unicode database." msgstr "" "La liste de séquences spéciales suivante est incomplète. Pour une liste " -"complète de séquences et définitions de classe étendue pour des motifs de " -"chaînes de caractère s Unicode, reportez-vous à la dernière partie de la " -"référence :ref:`Syntaxe d'Expressions Régulières ` de la " -"librairie standard. En général, les versions d'Unicode trouve une " -"correspondance avec n'importe quel caractère présent dans le catégorie " -"appropriée de la base de données Unicode. " +"complète des séquences et définitions de classes étendues relatives aux " +"motifs de chaînes de caractères Unicode, reportez-vous à la dernière partie " +"de la référence :ref:`Syntaxe d'Expressions Régulières ` de la " +"bibliothèque standard. En général, les versions Unicode trouvent une " +"correspondance avec n'importe quel caractère présent dans la catégorie " +"appropriée de la base de données Unicode." #: ../Doc/howto/regex.rst:130 msgid "``\\d``" @@ -294,8 +294,8 @@ msgstr "``\\d``" #: ../Doc/howto/regex.rst:130 msgid "Matches any decimal digit; this is equivalent to the class ``[0-9]``." msgstr "" -"Correspond à n'importe quel caractère numérique ; ceci est équivalent à la " -"classe ``[0-9]``." +"Correspond à n'importe quel caractère numérique ; équivalent à la classe " +"``[0-9]``." #: ../Doc/howto/regex.rst:133 msgid "``\\D``" @@ -305,8 +305,8 @@ msgstr "``\\D``" msgid "" "Matches any non-digit character; this is equivalent to the class ``[^0-9]``." msgstr "" -"Correspond à n'importe caractère non numérique; ceci est équivalent à la " -"classe ``[^0-9]``." +"Correspond à n'importe caractère non numérique ; équivalent à la classe " +"``[^0-9]``." #: ../Doc/howto/regex.rst:137 msgid "``\\s``" @@ -317,8 +317,8 @@ msgid "" "Matches any whitespace character; this is equivalent to the class ``[ \\t\\n" "\\r\\f\\v]``." msgstr "" -"Correspond à n'importe caractères d'espacement; ceci est équivalent à la " -"classe ``[ \\t\\n\\r\\f\\v]``." +"Correspond à n'importe quel caractère \"blanc\" ; équivalent à la classe " +"``[ \\t\\n\\r\\f\\v]``." #: ../Doc/howto/regex.rst:141 msgid "``\\S``" @@ -329,8 +329,8 @@ msgid "" "Matches any non-whitespace character; this is equivalent to the class ``[^ " "\\t\\n\\r\\f\\v]``." msgstr "" -"Correspond à n'importe caractère autre que d'espacement; ceci est équivalent " -"à la classe ``[^ \\t\\n\\r\\f\\v]``." +"Correspond à n'importe caractère autre que \"blanc\" ; équivalent à la " +"classe ``[^ \\t\\n\\r\\f\\v]``." #: ../Doc/howto/regex.rst:145 msgid "``\\w``" @@ -341,8 +341,8 @@ msgid "" "Matches any alphanumeric character; this is equivalent to the class ``[a-zA-" "Z0-9_]``." msgstr "" -"Correspond à n'importe caractère alphanumérique; ceci est équivalent à la " -"classe ``[a-zA-Z0-9_]``." +"Correspond à n'importe caractère alphanumérique ; équivalent à la classe " +"``[a-zA-Z0-9_]``." #: ../Doc/howto/regex.rst:149 msgid "``\\W``" @@ -353,8 +353,8 @@ msgid "" "Matches any non-alphanumeric character; this is equivalent to the class " "``[^a-zA-Z0-9_]``." msgstr "" -"Correspond à n'importe caractère non-alphanumérique; ceci est équivalent à " -"la classe ``[^a-zA-Z0-9_]``." +"Correspond à n'importe caractère non-alphanumérique ; équivalent à la classe " +"``[^a-zA-Z0-9_]``." #: ../Doc/howto/regex.rst:151 msgid "" @@ -364,7 +364,7 @@ msgid "" msgstr "" "Ces séquences peuvent être incluses dans une classe de caractères. Par " "exemple, ``[\\s,.]`` est une classe de caractères qui correspond à tous les " -"caractères d'espace, ou ``','`` ou ``'.'``. " +"caractères \"blancs\" ou ``','`` ou ``'.'``." #: ../Doc/howto/regex.rst:155 msgid "" @@ -373,15 +373,15 @@ msgid "" "DOTALL`) where it will match even a newline. ``.`` is often used where you " "want to match \"any character\"." msgstr "" -"Le dernier méta-caractère dans cette section est ``.``. Il correspond à tout " -"les caractères, à l'exception du caractère de retour à la ligne; il existe " +"Le dernier métacaractère de cette section est ``.``. Il correspond à tous " +"les caractères, à l'exception du caractère de retour à la ligne ; il existe " "un mode alternatif (:const:`re.DOTALL`) dans lequel il correspond également " "eu caractère de retour à la ligne. ``.`` est souvent utilisé lorsque l'on " "veut trouver une correspondance avec \"n'importe quel caractère\"." #: ../Doc/howto/regex.rst:162 msgid "Repeating Things" -msgstr "Répetitions" +msgstr "Répétitions" #: ../Doc/howto/regex.rst:164 msgid "" @@ -391,6 +391,12 @@ msgid "" "they wouldn't be much of an advance. Another capability is that you can " "specify that portions of the RE must be repeated a certain number of times." msgstr "" +"Trouver des correspondances de divers ensembles de caractères est la " +"première utilisation des expressions régulières, ce que l'on ne peut pas " +"faire avec les méthodes des chaînes. Cependant, si c'était la seule " +"possibilité des expressions régulières, le gain ne serait pas significatif. " +"Une autre utilisation consiste à spécifier des portions d'une RE qui peuvent " +"être répétées un certain nombre de fois." #: ../Doc/howto/regex.rst:170 msgid "" @@ -399,12 +405,19 @@ msgid "" "that the previous character can be matched zero or more times, instead of " "exactly once." msgstr "" +"Le premier métacaractère pour la répétition que nous abordons est ``*``. " +"``*`` ne correspond pas au caractère litéral ``'*'`` ; à la place, il " +"spécifie que le caractère précédent peut correspondre zéro, une ou plusieurs " +"fois (au lieu d'une seule fois)." #: ../Doc/howto/regex.rst:174 msgid "" "For example, ``ca*t`` will match ``'ct'`` (0 ``'a'`` characters), ``'cat'`` " "(1 ``'a'``), ``'caaat'`` (3 ``'a'`` characters), and so forth." msgstr "" +"Par exemple, ``cha*t`` correspond à ``'cht'`` (0 caractère ``'a'``), " +"``'chat'`` (1 ``'a'``), ``'chaaat'`` (3 caractères ``'a'``) et ainsi de " +"suite." #: ../Doc/howto/regex.rst:177 msgid "" @@ -413,6 +426,11 @@ 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 " +"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 " +"avec moins de répétitions." #: ../Doc/howto/regex.rst:182 msgid "" @@ -423,13 +441,13 @@ msgid "" msgstr "" "Un exemple étape par étape mettra les choses au clair. Considérons " "l'expression ``a[bcd]*b``. Elle correspond à la lettre ``'a'``, suivi " -"d'aucune ou plusieurs lettres de la classe `[bcd]`` et finira par un " -"``'b'``. Maintenant supposé que cette RE correspondra à la chaîne de " -"caractères ``'abcbd'``." +"d'aucune ou plusieurs lettres de la classe `[bcd]`` et finit par un ``'b'``. " +"Maintenant, supposons que nous cherchons une correspondance de cette RE avec " +"la chaîne de caractères ``'abcbd'``." #: ../Doc/howto/regex.rst:188 msgid "Step" -msgstr "Etape" +msgstr "Étape" #: ../Doc/howto/regex.rst:188 msgid "Matched" @@ -445,11 +463,11 @@ msgstr "1" #: ../Doc/howto/regex.rst:190 msgid "``a``" -msgstr "" +msgstr "``a``" #: ../Doc/howto/regex.rst:190 msgid "The ``a`` in the RE matches." -msgstr "Le ``a`` dans la RE correspondante." +msgstr "Le ``a`` correspond dans la RE." #: ../Doc/howto/regex.rst:192 msgid "2" @@ -457,13 +475,15 @@ msgstr "2" #: ../Doc/howto/regex.rst:192 msgid "``abcbd``" -msgstr "" +msgstr "``abcbd``" #: ../Doc/howto/regex.rst:192 msgid "" "The engine matches ``[bcd]*``, going as far as it can, which is to the end " "of the string." msgstr "" +"Le moteur de correspondance trouve ``[bcd]*``, va aussi loin qu'il le peut, " +"ce qui n'est pas la fin de la chaîne." #: ../Doc/howto/regex.rst:196 msgid "3" @@ -471,15 +491,15 @@ msgstr "3" #: ../Doc/howto/regex.rst:196 ../Doc/howto/regex.rst:204 msgid "*Failure*" -msgstr "" +msgstr "*échec*" #: ../Doc/howto/regex.rst:196 msgid "" "The engine tries to match ``b``, but the current position is at the end of " "the string, so it fails." msgstr "" -"Le moteur essaye de trouver une correspondance avec ``b`` mais la position " -"courante est à la fin de la chaîne de caractères et échoue donc." +"Le moteur essaie de trouver une correspondance avec ``b`` mais la position " +"courante est à la fin de la chaîne de caractères, donc il échoue." #: ../Doc/howto/regex.rst:201 msgid "4" @@ -487,11 +507,13 @@ msgstr "4" #: ../Doc/howto/regex.rst:201 ../Doc/howto/regex.rst:212 msgid "``abcb``" -msgstr "" +msgstr "``abcb``" #: ../Doc/howto/regex.rst:201 msgid "Back up, so that ``[bcd]*`` matches one less character." msgstr "" +"Retour en arrière, de manière à ce que ``[bcd]*`` corresponde avec un " +"caractère de moins." #: ../Doc/howto/regex.rst:204 msgid "5" @@ -502,6 +524,8 @@ msgid "" "Try ``b`` again, but the current position is at the last character, which is " "a ``'d'``." msgstr "" +"Essaie encore ``b``, mais la position courante est le dernier caractère, qui " +"est ``'d'``." #: ../Doc/howto/regex.rst:208 ../Doc/howto/regex.rst:212 msgid "6" @@ -509,17 +533,21 @@ msgstr "6" #: ../Doc/howto/regex.rst:208 msgid "``abc``" -msgstr "" +msgstr "``abc``" #: ../Doc/howto/regex.rst:208 msgid "Back up again, so that ``[bcd]*`` is only matching ``bc``." msgstr "" +"Encore un retour en arrière, de manière à ce que ``[bcd]*`` ne corresponde " +"qu'à ``bc``." #: ../Doc/howto/regex.rst:212 msgid "" "Try ``b`` again. This time the character at the current position is " "``'b'``, so it succeeds." msgstr "" +"Essaie ``b`` encore une fois. Cette fois, le caractère à la position " +"courante est ``'b'``, donc cela fonctionne." #: ../Doc/howto/regex.rst:218 msgid "" @@ -530,6 +558,13 @@ 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 " +"``'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 " +"encore. Il revient en arrière jusqu'à qu'il n'y ait aucune correspondance " +"pour ``[bcd]*`` et, si cela échoue toujours, le moteur conclut que la chaîne " +"de caractères et la RE ne correspondent pas du tout." #: ../Doc/howto/regex.rst:225 msgid "" @@ -540,6 +575,13 @@ msgid "" "similar example, ``ca+t`` will match ``'cat'`` (1 ``'a'``), ``'caaat'`` (3 " "``'a'``\\ s), but won't match ``'ct'``." 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é " +"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 " +"``'ct'``." #: ../Doc/howto/regex.rst:232 msgid "" @@ -548,6 +590,11 @@ msgid "" "something as being optional. For example, ``home-?brew`` matches either " "``'homebrew'`` or ``'home-brew'``." msgstr "" +"Il existe deux autres quantificateurs pour les répétitions. Le point " +"d'interrogation, ``?``, fait correspondre zéro ou une fois ; vous pouvez " +"vous le représenter comme indiquant une option. Par exemple, ``méta-?" +"caractère`` fait correspondre soit ``métacaractère``, soit ``méta-" +"caractère``." #: ../Doc/howto/regex.rst:237 msgid "" @@ -557,6 +604,11 @@ msgid "" "b'``, ``'a//b'``, and ``'a///b'``. It won't match ``'ab'``, which has no " "slashes, or ``'a////b'``, which has four." msgstr "" +"Le plus compliqué des quantificateurs est ``{m,n}`` où *m* et *n* sont des " +"entiers décimaux. Ce quantificateur indique qu'il faut au moins *m* " +"répétitions et au plus *n*. Par exemple, ``a/{1,3}b`` fait correspondre ``'a/" +"b'``, ``'a//b'`` et ``'a///b'``. Elle ne fait pas correspondre ``'ab'`` (pas " +"de barre oblique) ni ``'a////b'`` (quatre barres obliques)." #: ../Doc/howto/regex.rst:243 msgid "" @@ -564,6 +616,9 @@ msgid "" "for the missing value. Omitting *m* is interpreted as a lower limit of 0, " "while omitting *n* results in an upper bound of infinity." msgstr "" +"Vous pouvez omettre soit *m*, soit *n* ; dans ce cas, une valeur raisonnable " +"est prise pour la valeur manquante. Omettre *m* considère que la borne basse " +"est 0 alors qu'omettre *n* signifie qu'il n'y a pas de borne supérieure." #: ../Doc/howto/regex.rst:247 msgid "" @@ -573,10 +628,15 @@ msgid "" "better to use ``*``, ``+``, or ``?`` when you can, simply because they're " "shorter and easier to read." msgstr "" +"Le lecteur attentif aura noté que les trois premiers quantificateurs peuvent " +"être exprimés en utilisant cette notation. ``{0,}`` est la même chose que " +"``*``, ``{1,}`` est équivalent à ``+`` et ``{0,1}`` se comporte comme ``?``. " +"Il est préférable d'utiliser ``*``, ``+`` ou ``?`` quand vous le pouvez, " +"simplement parce qu'ils sont plus courts et plus faciles à lire." #: ../Doc/howto/regex.rst:255 msgid "Using Regular Expressions" -msgstr "Utilisation des Expressions Régulières" +msgstr "Utilisation des expressions régulières" #: ../Doc/howto/regex.rst:257 msgid "" @@ -585,10 +645,14 @@ msgid "" "regular expression engine, allowing you to compile REs into objects and then " "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 " +"le moteur de correspondance, ce qui permet de compiler les RE en objets et " +"d'effectuer des correspondances avec." #: ../Doc/howto/regex.rst:264 msgid "Compiling Regular Expressions" -msgstr "Compilations des Expressions Régulières" +msgstr "Compilation des expressions régulières" #: ../Doc/howto/regex.rst:266 msgid "" @@ -596,6 +660,9 @@ msgid "" "for various operations such as searching for pattern matches or performing " "string substitutions. ::" 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. ::" #: ../Doc/howto/regex.rst:275 msgid "" @@ -603,6 +670,10 @@ msgid "" "various special features and syntax variations. We'll go over the available " "settings later, but for now a single example will do::" msgstr "" +":func:`re.compile` accepte aussi une option *flags*, utilisée pour activer " +"des fonctionnalités particulières et des variations de syntaxe. Nous " +"étudierons la définition des variables plus tard et, pour l'instant, un seul " +"exemple suffit ::" #: ../Doc/howto/regex.rst:281 msgid "" @@ -614,16 +685,26 @@ msgid "" "simply a C extension module included with Python, just like the :mod:" "`socket` or :mod:`zlib` modules." msgstr "" +"La RE passée à :func:`re.compile` est une chaîne. Les RE sont des chaînes " +"car les expressions régulières ne font pas partie intrinsèque du langage " +"Python et aucune syntaxe particulière n'a été créée pour les exprimer (il " +"existe des applications qui ne nécessitent aucune RE et il n'a donc aucune " +"raison de grossir les spécifications du langage en incluant les RE). Ainsi, " +"le module :mod:`re` est simplement un module d'extension en C inclus dans " +"Python, tout comme les modules :mod:`socket` ou :mod:`zlib`." #: ../Doc/howto/regex.rst:288 msgid "" "Putting REs in strings keeps the Python language simpler, but has one " "disadvantage which is the topic of the next section." msgstr "" +"Exprimer les RE comme des chaînes de caractères garde le langage Python plus " +"simple mais introduit un inconvénient qui fait l'objet de la section " +"suivante." #: ../Doc/howto/regex.rst:295 msgid "The Backslash Plague" -msgstr "Le Maudit Backslash" +msgstr "La maudite barre oblique inverse" #: ../Doc/howto/regex.rst:297 msgid "" @@ -632,6 +713,12 @@ msgid "" "used without invoking their special meaning. This conflicts with Python's " "usage of the same character for the same purpose in string literals." msgstr "" +"Comme indiqué précédemment, les expressions régulières utilisent la barre " +"oblique inverse (*backslash* en anglais) pour indiquer des constructions " +"particulières ou pour autoriser des caractères spéciaux sans que leur " +"signification spéciale ne soit invoquée. C'est en contradiction avec l'usage " +"de Python qui est qu'un caractère doit avoir la même signification dans les " +"littéraux de chaînes de caractères." #: ../Doc/howto/regex.rst:302 msgid "" @@ -644,6 +731,16 @@ msgid "" "to express this as a Python string literal, both backslashes must be escaped " "*again*." msgstr "" +"Considérons que vous voulez écrire une RE qui fait correspondre la chaîne de " +"caractères ``\\section`` (on en trouve dans un fichier LaTeX). Pour savoir " +"ce qu'il faut coder dans votre programme, commençons par la chaîne de " +"caractères cherchée. Ensuite, nous devons échapper chaque barre oblique " +"inverse et tout autre métacaractère en les précédant d'une barre oblique " +"inverse, ce qui donne la chaîne de caractères ``\\\\section``. La chaîne " +"résultante qui doit être passée à :func:`re.compile` est donc ``\\" +"\\section``. Comme nous devons l'exprimer sous la forme d'une chaîne " +"littérale Python, nous devons échapper les deux barres obliques inverses " +"*encore une fois*." #: ../Doc/howto/regex.rst:311 msgid "Characters" @@ -651,31 +748,32 @@ msgstr "Caractères" #: ../Doc/howto/regex.rst:311 msgid "Stage" -msgstr "" +msgstr "Niveau" #: ../Doc/howto/regex.rst:313 msgid "``\\section``" -msgstr "" +msgstr "``\\section``" #: ../Doc/howto/regex.rst:313 msgid "Text string to be matched" -msgstr "" +msgstr "Chaîne de caractère à chercher" #: ../Doc/howto/regex.rst:315 msgid "``\\\\section``" -msgstr "" +msgstr "``\\\\section``" #: ../Doc/howto/regex.rst:315 msgid "Escaped backslash for :func:`re.compile`" -msgstr "**backslash** échappé pour :func:`re.compile`" +msgstr "Barre oblique inverse échappée pour :func:`re.compile`" #: ../Doc/howto/regex.rst:317 ../Doc/howto/regex.rst:344 msgid "``\"\\\\\\\\section\"``" -msgstr "" +msgstr "``\"\\\\\\\\section\"``" #: ../Doc/howto/regex.rst:317 msgid "Escaped backslashes for a string literal" msgstr "" +"Barres obliques inverses échappées pour un littéral de chaîne de caractères" #: ../Doc/howto/regex.rst:320 msgid "" @@ -685,6 +783,13 @@ msgid "" "literal. In REs that feature backslashes repeatedly, this leads to lots of " "repeated backslashes and makes the resulting strings difficult to understand." msgstr "" +"Pour faire court, si vous cherchez une correspondance pour une barre oblique " +"inverse littérale, écrivez ``'\\\\\\\\'`` dans votre chaîne RE, car " +"l'expression régulière doit être ``\\\\`` et que chaque barre oblique " +"inverse doit être exprimée comme ``\\\\`` dans un littéral chaîne de " +"caractères Python. Dans les RE qui comportent plusieurs barres obliques " +"inverses, cela conduit à beaucoup de barres obliques inverses et rend la " +"chaîne résultante difficile à comprendre." #: ../Doc/howto/regex.rst:326 msgid "" @@ -695,6 +800,13 @@ msgid "" "newline. Regular expressions will often be written in Python code using this " "raw string notation." msgstr "" +"La solution consiste à utiliser les chaînes brutes Python pour les " +"expressions régulières ; les barres obliques inverses ne sont pas gérées " +"d'une manière particulière dans les chaînes littérales préfixées avec " +"``'r'``. Ainsi, ``r\"\\n\"`` est la chaîne de deux caractères contenant " +"``'\\'`` et ``'n'`` alors que ``\"\\n\"`` est la chaîne contenant uniquement " +"le caractère retour à la ligne. Les expressions régulières sont souvent " +"écrites dans le code Python en utilisant la notation \"chaînes brutes\"." #: ../Doc/howto/regex.rst:332 msgid "" @@ -704,10 +816,16 @@ msgid "" "means the sequences will be invalid if raw string notation or escaping the " "backslashes isn't used." msgstr "" +"En complément, les séquences d'échappement valides dans les expressions " +"régulières, mais non valides dans les littéraux chaînes classiques, " +"produisent dorénavant un :exc:`DeprecationWarning` et, possiblement, " +"deviendront une :exc:`SyntaxError`, ce qui signifie que les séquences seront " +"invalides si la notation \"chaîne brute\" ou l'échappement des barres " +"obliques inverses ne sont pas utilisés." #: ../Doc/howto/regex.rst:340 msgid "Regular String" -msgstr "" +msgstr "Chaîne normale" #: ../Doc/howto/regex.rst:340 msgid "Raw string" @@ -715,27 +833,27 @@ msgstr "Chaîne de caractères brute" #: ../Doc/howto/regex.rst:342 msgid "``\"ab*\"``" -msgstr "" +msgstr "``\"ab*\"``" #: ../Doc/howto/regex.rst:342 msgid "``r\"ab*\"``" -msgstr "" +msgstr "``r\"ab*\"``" #: ../Doc/howto/regex.rst:344 msgid "``r\"\\\\section\"``" -msgstr "" +msgstr "``r\"\\\\section\"``" #: ../Doc/howto/regex.rst:346 msgid "``\"\\\\w+\\\\s+\\\\1\"``" -msgstr "" +msgstr "``\"\\\\w+\\\\s+\\\\1\"``" #: ../Doc/howto/regex.rst:346 msgid "``r\"\\w+\\s+\\1\"``" -msgstr "" +msgstr "``r\"\\w+\\s+\\1\"``" #: ../Doc/howto/regex.rst:351 msgid "Performing Matches" -msgstr "" +msgstr "Recherche de correspondances" #: ../Doc/howto/regex.rst:353 msgid "" @@ -761,37 +879,41 @@ msgstr "Objectif" #: ../Doc/howto/regex.rst:361 msgid "``match()``" -msgstr "" +msgstr "``match()``" #: ../Doc/howto/regex.rst:361 msgid "Determine if the RE matches at the beginning of the string." -msgstr "" +msgstr "Détermine si la RE fait correspond dès le début de la chaîne." #: ../Doc/howto/regex.rst:364 msgid "``search()``" -msgstr "" +msgstr "``search()``" #: ../Doc/howto/regex.rst:364 msgid "Scan through a string, looking for any location where this RE matches." -msgstr "" +msgstr "Analyse la chaîne à la recherche d'une position où la RE correspond." #: ../Doc/howto/regex.rst:367 msgid "``findall()``" -msgstr "" +msgstr "``findall()``" #: ../Doc/howto/regex.rst:367 msgid "Find all substrings where the RE matches, and returns them as a list." msgstr "" +"Trouve toutes les sous-chaînes qui correspondent à la RE et les renvoie sous " +"la forme d'une liste." #: ../Doc/howto/regex.rst:370 msgid "``finditer()``" -msgstr "" +msgstr "``finditer()``" #: ../Doc/howto/regex.rst:370 msgid "" "Find all substrings where the RE matches, and returns them as an :term:" "`iterator`." msgstr "" +"Trouve toutes les sous-chaînes qui correspondent à la RE et les renvoie sous " +"la forme d'un :term:`itérateur `." #: ../Doc/howto/regex.rst:374 msgid "" @@ -800,6 +922,12 @@ msgid "" "objects>` instance is returned, containing information about the match: " "where it starts and ends, the substring it matched, and more." 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 ` " +"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." #: ../Doc/howto/regex.rst:379 msgid "" @@ -842,7 +970,7 @@ msgstr "" #: ../Doc/howto/regex.rst:419 msgid "``group()``" -msgstr "" +msgstr "``group()``" #: ../Doc/howto/regex.rst:419 msgid "Return the string matched by the RE" @@ -850,7 +978,7 @@ msgstr "Retourne la chaîne de caractères correspondant à la RE" #: ../Doc/howto/regex.rst:421 msgid "``start()``" -msgstr "" +msgstr "``start()``" #: ../Doc/howto/regex.rst:421 msgid "Return the starting position of the match" @@ -858,7 +986,7 @@ msgstr "Retourne la position de début de correspondance" #: ../Doc/howto/regex.rst:423 msgid "``end()``" -msgstr "" +msgstr "``end()``" #: ../Doc/howto/regex.rst:423 msgid "Return the ending position of the match" @@ -866,7 +994,7 @@ msgstr "Retourne la position de fin de correspondance" #: ../Doc/howto/regex.rst:425 msgid "``span()``" -msgstr "" +msgstr "``span()``" #: ../Doc/howto/regex.rst:425 msgid "Return a tuple containing the (start, end) positions of the match" @@ -1147,12 +1275,12 @@ 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éta-caractères et comment utiliser les groupes pour récupérer des " +"nouveaux métacaractères et comment utiliser les groupes pour récupérer des " "portions de textes correspondante." #: ../Doc/howto/regex.rst:681 msgid "More Metacharacters" -msgstr "Plus de Méta-caratères" +msgstr "Plus de métacaratères" #: ../Doc/howto/regex.rst:683 msgid ""