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

Merge pull request #275 from christopheNan/issue271

Browse source 
Relecture de Howto / Regex.po - début
This commit is contained in:
Julien Palard 2018-07-23 15:04:43 +02:00 • committed by GitHub
commit b2e692a468
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
1 changed files with 272 additions and 144 deletions
Download patch file Download diff file Expand all files Collapse all files

416
howto/regex.po
View file

@ -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 <nabil@bendafi.fr>\n"
"Language-Team: FRENCH <traductions@lists.afpy.org>\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 <amk@amk.ca>"
msgstr ""
msgstr "A.M. Kuchling <amk@amk.ca>"
#: ../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 <metacharacters>` 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 <complementing>` 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 <re-syntax>` 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 <re-syntax>` 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:`<greedy>` ; 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 <iterator>`."
#: ../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 <match-objects>` "
"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 ""