Relecture de Howto / Regex.po - début

Principalement pour corriger #271

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 <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 "
+"Ce document constitue un guide d'introduction à l'utilisation des "
-"régulières en Python avec le module :mod:`re`. Il fournit une introduction "
+"expressions régulières en Python avec le module :mod:`re`. Il fournit une "
-"plus abordable que la section correspondante dans le guide de référence des "
+"introduction plus abordable que la section correspondante dans le guide de "
-"bibliothèques."
+"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 "
+"définissez des règles pour spécifier une correspondance avec un ensemble "
-"pour lesquelles vous voulez une correspondance; cet ensemble contient des "
+"souhaité de chaînes de caractères ; ces chaînes peuvent être des phrases, "
-"phrases en Anglais, ou des adresses de courriel, ou des commandes TeX, ou "
+"des adresses de courriel, des commandes TeX ou tout ce que vous voulez. Vous "
-"tout ce que vous voulez. Vous pouvez ensuite poser des questions tel que "
+"pouvez ensuite poser des questions telles que \"Est-ce que cette chaîne de "
-"\"Est-ce que cette chaîne de caractères correspond au motif ?\", ou \"Y-a-"
+"caractères correspond au motif ?\" ou \"Y-a-t'il une correspondance pour ce "
-"t'il une correspondance pour un motif dans le chaîne de caractères ?\". Vous "
+"motif à l'intérieur de la chaîne de caractères ?\". Vous pouvez aussi "
-"pouvez aussi utiliser les RE pour modifier une chaîne de caractères ou la "
+"utiliser les RE pour modifier une chaîne de caractères ou la découper de "
-"découper de différentes façons."
+"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 "
+"Un motif d'expression régulière est compilé en **bytecode** qui est ensuite "
-"ensuite exécutés par un moteur de correspondance écrit en C. Pour une "
+"exécuté par un moteur de correspondance écrit en C. Pour une utilisation "
-"utilisation plus poussée, il peut s'avérer nécessaire de s'intéresser à la "
+"plus poussée, il peut s'avérer nécessaire de s'intéresser à la manière dont "
-"manière dont le moteur exécute la RE afin d'écrire une expression dont le "
+"le moteur exécute la RE afin d'écrire une expression dont le **bytecode** "
-"**bytecode** est plus rapide. L'optimisation n'est pas traitée dans ce "
+"est plus rapide. L'optimisation n'est pas traitée dans ce document, parce "
-"document, parce qu'elle nécessite d'avoir une bonne compréhension des "
+"qu'elle nécessite d'avoir une bonne compréhension des mécanismes internes du "
-"mécanismes internes du moteur de correspondance."
+"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 "
+"Le langage des expressions régulières est relativement petit et restreint, "
-"toutes les tâches de manipulation de chaînes de caractères ne peuvent pas "
+"donc toutes les tâches de manipulation de chaînes de caractères ne peuvent "
-"être réalisées à l'aide d'expressions régulières. Il y a aussi des tâches "
+"pas être réalisées à l'aide d'expressions régulières. Il existe aussi des "
-"qui *peuvent* être réalisées à l'aide d'expressions régulières mais qui ont "
+"tâches qui *peuvent* être réalisées à l'aide d'expressions régulières mais "
-"tendance à produire des expressions régulières très compliquées. Dans ces "
+"qui ont tendance à produire des expressions régulières très compliquées. "
-"cas, il vous sera plus utile d'écrire du code Python pour réaliser le "
+"Dans ces cas, il est plus utile d'écrire du code Python pour réaliser le "
-"traitement; même si le code Python sera plus lent qu'une expression "
+"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 "
+"des chaînes de caractères, nous commençons par l'action la plus courante : "
-"communes: la correspondance de caractères ."
+"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 "
+"Pour une explication détaillée sur le concept informatique sous-jacent aux "
-"expressions régulières (automate d'état déterministe et non-déterministe), "
+"expressions régulières (automate à états déterministe ou non-déterministe), "
-"référez-vous à n'importe quel manuel sur l'écriture de compilateurs."
+"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 "
+"La plupart des lettres ou caractères correspondent simplement à eux-mêmes. "
-"exemple, l'expression régulière ``test`` correspond à la chaîne de caractère "
+"Par exemple, l'expression régulière ``test`` correspond à la chaîne de "
-"``test`` précisément. (Vous pouvez activer le mode non-sensible à la casse "
+"caractères ``test``, précisément. Vous pouvez activer le mode non-sensible à "
-"qui permet à cette RE de correspondre à ``Test`` ou ``TEST`` également; plus "
+"la casse qui permet à cette RE de correspondre également à ``Test`` ou "
-"à ce sujet dans la suite.) "
+"``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:"
+"Il existe des exceptions à cette règle ; certains caractères sont des :dfn:"
-"`metacharacters` spéciaux et ne correspondent pas à eux-mêmes. Au lieu de "
+"`métacaractères <metacharacters>` spéciaux et ne correspondent pas à eux-"
-"cela, ils signalent que certaines choses non ordinaires doivent "
+"mêmes. Au lieu de cela, ils signalent que certaines choses non ordinaires "
-"correspondre, ou affectent d'autre portions de la RE en les répétant ou en "
+"doivent correspondre, ou ils affectent d'autre portions de la RE en les "
-"changeant leur sens. Une grande partie de ce document est consacrée au "
+"répétant ou en changeant leur sens. Une grande partie de ce document est "
-"fonctionnement de ces métacaractères."
+"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 "
+"``[abc]`` correspond à n'importe quel caractère parmi ``a``, ``b``, ou "
-"``c``; ce qui est équivalent à ``[a-c]``, qui utilise une plage pour "
+"``c`` ; c'est équivalent à ``[a-c]``, qui utilise une plage pour exprimer le "
-"exprimer le même ensemble de caractères. Si vous voulez trouver une "
+"même ensemble de caractères. Si vous voulez trouver une chaîne qui ne "
-"correspondance avec uniquement les lettres en minuscule, votre RE sera ``[a-"
+"contient que des lettres en minuscules, la RE est ``[a-z]``."
-"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"
+"Les métacaractères ne sont pas actifs dans les classes. Par exemple, ``[akm"
-"$]`` correspondra à n'importe quel caractère parmi ``'a'``, ``'k'``, "
+"$]`` correspond à n'importe quel caractère parmi ``'a'``, ``'k'``, ``'m'`` "
-"``'m'``, ou ``'$'``; ``'$'`` est habituellement un méta-caractère mais dans "
+"ou ``'$'`` ; ``'$'`` est habituellement un métacaractère mais dans une "
-"une classe de caractères, il est dépourvu de son caractère spécial."
+"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 "
+"une classe en spécifiant le :dfn:`complément <complementing>` de l'ensemble. "
-"indiqué en incluant un ``'^'`` en tant que premier caractère de la classe; "
+"Ceci est indiqué en plaçant un ``'^'`` en tant que premier caractère de la "
-"``'^'`` en dehors d'une classe de caractères correspondra au caractère "
+"classe ; ``'^'`` en dehors d'une classe de caractères correspond au "
-"``'^'``. Par exemple, ``[^5]`` correspondra à tout les caractères, sauf "
+"caractère ``'^'``. Par exemple, ``[^5]`` correspond à tous les caractères, "
-"``[^5]``."
+"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 "
+"Le métacaractère probablement le plus important est la barre oblique inverse "
-"**backslash**, ``\\``. Comme dans les chaînes de caractères en Python, le "
+"( *backslash* en anglais), ``\\``. Comme dans les chaînes de caractères en "
-"**backslash** peut être suivi par différents caractères pour signaler "
+"Python, le **backslash** peut être suivi par différents caractères pour "
-"différentes séquences spéciales. Il est aussi utilisé pour échapper tout les "
+"signaler différentes séquences spéciales. Il est aussi utilisé pour échapper "
-"méta-caractères afin d'en trouver les correspondances dans les motifs; par "
+"tous les métacaractères afin d'en trouver les correspondances dans les "
-"exemple, si vous devait trouver une correspondance pour ``[`` ou  ``\\`, "
+"motifs ; par exemple, si vous devez trouver une correspondance pour ``[`` ou "
-"vous pouvais les précéder avec un **backslash** pour supprimer leur "
+"``\\`, vous pouvez les précéder avec une barre oblique inverse pour "
-"caractères spécial : ``\\[`` ou ``\\\\``."
+"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 "
+"l'ensemble des chiffres, l'ensemble des lettres ou l'ensemble des caractères "
-"caractères qui ne sont pas des séparateurs."
+"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 "
+"Prenons un exemple: ``\\w`` correspond à n'importe quel caractère "
-"alphanumérique. Si le motif **regex** est exprimé en octets, il est "
+"alphanumérique. Si l'expression régulière est exprimée en *bytes*, c'est "
-"équivalent à la classe ``[a-zA-Z0-9_]``. Si le motif **regex** est une "
+"équivalent à la classe ``[a-zA-Z0-9_]``. Si l'expression régulière est une "
-"chaîne de caractères, ``\\w`` correspondra à tout les caractères identifiés "
+"chaîne de caractères, ``\\w`` correspond à tous les caractères identifiés "
-"comme lettre dans le base de données Unicode fourni par le module :mod:"
+"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:"
+"\\w`` dans un motif exprimé en chaîne de caractères en spécifiant l'option :"
-"`re.ASCII` lors de la compilation de l'expression régulière."
+"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 "
+"complète des séquences et définitions de classes étendues relatives aux "
-"chaînes de caractère s Unicode, reportez-vous à la dernière partie de la "
+"motifs de chaînes de caractères Unicode, reportez-vous à la dernière partie "
-"référence :ref:`Syntaxe d'Expressions Régulières <re-syntax>` de la "
+"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 "
+"bibliothèque standard. En général, les versions Unicode trouvent une "
-"correspondance avec n'importe quel caractère présent dans le catégorie "
+"correspondance avec n'importe quel caractère présent dans la catégorie "
-"appropriée de la base de données Unicode. "
+"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 "
+"Correspond à n'importe quel caractère numérique ; équivalent à la classe "
-"classe ``[0-9]``."
+"``[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 "
+"Correspond à n'importe caractère non numérique ; équivalent à la classe "
-"classe ``[^0-9]``."
+"``[^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 "
+"Correspond à n'importe quel caractère \"blanc\" ; équivalent à la classe "
-"classe ``[ \\t\\n\\r\\f\\v]``."
+"``[ \\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 "
+"Correspond à n'importe caractère autre que \"blanc\" ; équivalent à la "
-"à la classe ``[^ \\t\\n\\r\\f\\v]``."
+"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 "
+"Correspond à n'importe caractère alphanumérique ; équivalent à la classe "
-"classe ``[a-zA-Z0-9_]``."
+"``[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 à "
+"Correspond à n'importe caractère non-alphanumérique ; équivalent à la classe "
-"la classe ``[^a-zA-Z0-9_]``."
+"``[^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 "
+"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 "
+"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 "
+"d'aucune ou plusieurs lettres de la classe `[bcd]`` et finit par un ``'b'``. "
-"``'b'``. Maintenant supposé que cette RE correspondra à la chaîne de "
+"Maintenant, supposons que nous cherchons une correspondance de cette RE avec "
-"caractères ``'abcbd'``."
+"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 "
+"Le moteur essaie de trouver une correspondance avec ``b`` mais la position "
-"courante est à la fin de la chaîne de caractères et échoue donc."
+"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 ""