Relecture du guide des expressions régulières (#1467)

howto/regex.po

@@ -6,7 +6,7 @@ msgstr ""
 "Project-Id-Version: Python 3\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2020-10-01 16:00+0200\n"
-"PO-Revision-Date: 2020-04-27 22:24+0200\n"
+"PO-Revision-Date: 2020-11-10 10:27+0100\n"
 "Last-Translator: Nabil Bendafi <nabil@bendafi.fr>\n"
 "Language-Team: FRENCH <traductions@lists.afpy.org>\n"
 "Language: fr\n"
@@ -64,10 +64,10 @@ msgstr ""
 "l'utilisation du module :mod:`re`. En utilisant ce petit langage, vous "
 "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 "
+"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."
 
@@ -192,7 +192,7 @@ msgstr ""
 "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]`` correspond à n'importe quel caractère parmi ``a``, ``b``, ou "
+"``[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]``."
@@ -236,7 +236,7 @@ msgid ""
 "remove their special meaning: ``\\[`` or ``\\\\``."
 msgstr ""
 "Le métacaractère le plus important est probablement la barre oblique inverse "
-"( *backslash* en anglais), ``\\``. Comme dans les chaînes de caractères en "
+"(*backslash* en anglais), ``\\``. Comme dans les chaînes de caractères en "
 "Python, la barre oblique inverse peut être suivie par différents caractères "
 "pour signaler différentes séquences spéciales. Elle est aussi utilisée pour "
 "échapper tous les métacaractères afin d'en trouver les correspondances dans "
@@ -253,7 +253,7 @@ 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 \"blancs\"."
+"qui ne sont pas des « blancs »."
 
 #: howto/regex.rst:115
 msgid ""
@@ -308,7 +308,7 @@ 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 ; équivalent à la classe "
+"Correspond à n'importe quel caractère non numérique ; équivalent à la classe "
 "``[^0-9]``."
 
 #: howto/regex.rst:138
@@ -320,7 +320,7 @@ msgid ""
 "Matches any whitespace character; this is equivalent to the class ``[ \\t\\n"
 "\\r\\f\\v]``."
 msgstr ""
-"Correspond à n'importe quel caractère \"blanc\" ; équivalent à la classe "
+"Correspond à n'importe quel caractère « blanc » ; équivalent à la classe "
 "``[ \\t\\n\\r\\f\\v]``."
 
 #: howto/regex.rst:142
@@ -332,7 +332,7 @@ 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 \"blanc\" ; équivalent à la "
+"Correspond à n'importe quel caractère autre que « blanc » ; équivalent à la "
 "classe ``[^ \\t\\n\\r\\f\\v]``."
 
 #: howto/regex.rst:146
@@ -344,8 +344,8 @@ msgid ""
 "Matches any alphanumeric character; this is equivalent to the class ``[a-zA-"
 "Z0-9_]``."
 msgstr ""
-"Correspond à n'importe caractère alphanumérique ; équivalent à la classe "
-"``[a-zA-Z0-9_]``."
+"Correspond à n'importe quel caractère alphanumérique ; équivalent à la "
+"classe ``[a-zA-Z0-9_]``."
 
 #: howto/regex.rst:150
 msgid "``\\W``"
@@ -356,8 +356,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 ; équivalent à la classe "
-"``[^a-zA-Z0-9_]``."
+"Correspond à n'importe quel caractère non-alphanumérique ; équivalent à la "
+"classe ``[^a-zA-Z0-9_]``."
 
 #: howto/regex.rst:152
 msgid ""
@@ -367,7 +367,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 \"blancs\" ou ``','`` ou ``'.'``."
+"caractères « blanc » ou ``','`` ou ``'.'``."
 
 #: howto/regex.rst:156
 msgid ""
@@ -379,8 +379,8 @@ msgstr ""
 "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\"."
+"au caractère de retour à la ligne. ``.`` est souvent utilisé lorsque l'on "
+"veut trouver une correspondance avec « n'importe quel caractère »."
 
 #: howto/regex.rst:163
 msgid "Repeating Things"
@@ -444,9 +444,9 @@ 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 finit par un ``'b'``. "
-"Maintenant, supposons que nous cherchons une correspondance de cette RE avec "
-"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'``."
 
 #: howto/regex.rst:189
 msgid "Step"
@@ -486,7 +486,7 @@ msgid ""
 "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."
+"c.-à-d. la fin de la chaîne."
 
 #: howto/regex.rst:197
 msgid "3"
@@ -584,7 +584,7 @@ msgstr ""
 "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'``."
+"``'cht'``."
 
 #: howto/regex.rst:233
 msgid ""
@@ -675,7 +675,7 @@ msgid ""
 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 "
+"étudierons les options disponibles plus tard et, pour l'instant, un petit "
 "exemple suffit ::"
 
 #: howto/regex.rst:282
@@ -735,7 +735,7 @@ msgid ""
 "*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 "
+"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 "
@@ -809,7 +809,7 @@ msgstr ""
 "``'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\"."
+"écrites dans le code Python en utilisant la notation « chaînes brutes »."
 
 #: howto/regex.rst:333
 msgid ""
@@ -823,7 +823,7 @@ msgstr ""
 "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 "
+"invalides si la notation « chaîne brute » ou l'échappement des barres "
 "obliques inverses ne sont pas utilisés."
 
 #: howto/regex.rst:341
@@ -925,10 +925,10 @@ msgid ""
 msgstr ""
 ":meth:`~re.Pattern.match` et :meth:`~re.Pattern.search` renvoient ``None`` "
 "si aucune correspondance ne peut être trouvée. Si elles trouvent une "
-"correspondance, une instance d'objet :ref:`correspondance <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."
+"correspondance, une instance d'\\ :ref:`objet 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."
 
 #: howto/regex.rst:380
 msgid ""
@@ -966,7 +966,7 @@ msgid ""
 msgstr ""
 "Maintenant, vous pouvez tester des correspondances de la RE ``[a-z]+`` avec "
 "différentes chaînes. Une chaîne vide ne doit pas correspondre, puisque ``+`` "
-"indique \"une ou plusieurs occurrences\". :meth:`~re.Pattern.match` doit "
+"indique « une ou plusieurs occurrences ». :meth:`~re.Pattern.match` doit "
 "renvoyer ``None`` dans ce cas, ce qui fait que l'interpréteur n'affiche "
 "rien. Vous pouvez afficher le résultat de :meth:`!match` explicitement pour "
 "que ce soit clair. ::"
@@ -988,7 +988,7 @@ msgid ""
 "about the matching string.  Match object instances also have several methods "
 "and attributes; the most important ones are:"
 msgstr ""
-"Maintenant, vous pouvez interroger :ref:`l'objet correspondance <match-"
+"Maintenant, vous pouvez interroger l'\\ :ref:`objet correspondance <match-"
 "objects>` pour obtenir des informations sur la chaîne qui correspond. Les "
 "instances d'objets correspondances possèdent plusieurs méthodes et "
 "attributs ; les plus importants sont :"
@@ -1024,7 +1024,8 @@ msgstr "``span()``"
 #: howto/regex.rst:426
 msgid "Return a tuple containing the (start, end) positions  of the match"
 msgstr ""
-"Renvoie un *tuple* contenant les positions (début, fin) de la correspondance"
+"Renvoie un *n*-uplet contenant les positions (début, fin) de la "
+"correspondance"
 
 #: howto/regex.rst:430
 msgid "Trying these methods will soon clarify their meaning::"
@@ -1044,7 +1045,7 @@ msgstr ""
 ":meth:`~re.Match.group` renvoie la sous-chaîne qui correspond à la RE. :meth:"
 "`~re.Match.start` et :meth:`~re.Match.end` renvoient les indices de début et "
 "de fin de la correspondance. :meth:`~re.Match.span` renvoie les indices de "
-"début et de fin dans un seul *tuple*. Comme la méthode :meth:`~re.Pattern."
+"début et de fin dans un seul couple. Comme la méthode :meth:`~re.Pattern."
 "match` ne fait que vérifier si la RE correspond au début de la chaîne, :meth:"
 "`!start` vaut toujours zéro. Cependant, la méthode :meth:`~re.Pattern."
 "search` d'un motif analyse toute la chaîne, afin de trouver une "
@@ -1057,7 +1058,7 @@ msgid ""
 "usually looks like::"
 msgstr ""
 "Dans les programmes réels, la façon de faire la plus courante consiste à "
-"stocker :ref:`l'objet correspondance <match-objects>` dans une variable, "
+"stocker l'\\ :ref:`objet correspondance <match-objects>` dans une variable, "
 "puis à vérifier s'il vaut ``None``. Généralement, cela ressemble à ceci ::"
 
 #: howto/regex.rst:467
@@ -1079,9 +1080,9 @@ msgstr ""
 "Le préfixe ``r``, qui indique une chaîne brute littérale, est nécessaire "
 "dans cet exemple car les séquences d'échappement dans une chaîne littérale "
 "qui ne sont pas reconnues par Python, alors qu'elles le sont par les "
-"expressions régulières, induisent maintenant un :exc:`DeprecationWarning` et "
-"deviendront possiblement des :exc:`SyntaxError`.  Reportez-vous à :ref:`the-"
-"backslash-plague`."
+"expressions régulières, produisent maintenant un :exc:`DeprecationWarning` "
+"et deviendront possiblement des :exc:`SyntaxError`.  Reportez-vous à :ref:"
+"`the-backslash-plague`."
 
 #: howto/regex.rst:480
 msgid ""
@@ -1090,9 +1091,9 @@ msgid ""
 "sequence of :ref:`match object <match-objects>` instances as an :term:"
 "`iterator`::"
 msgstr ""
-":meth:`~re.Pattern.findall` doit créer la liste entière avant d'être renvoyé "
+":meth:`~re.Pattern.findall` doit créer la liste entière avant de la renvoyer "
 "comme résultat. La méthode :meth:`~re.Pattern.finditer` renvoie une séquence "
-"d'instances :ref:`d'objets correspondances <match-objects>` en tant :term:"
+"d'instances d'\\ :ref:`objets correspondances <match-objects>` en tant :term:"
 "`qu'itérateur <iterator>` ::"
 
 #: howto/regex.rst:496
@@ -1113,8 +1114,8 @@ msgstr ""
 "match`, :func:`~re.search`, :func:`~re.findall`, :func:`~re.sub` et ainsi de "
 "suite. Ces fonctions prennent les mêmes arguments que les méthodes "
 "correspondantes des objets motifs, avec la chaîne RE ajoutée en tant que "
-"premier argument. Elles renvoient toujours ``None`` ou une instance  :ref:"
-"`d'objet correspondance <match-objects>`. ::"
+"premier argument. Elles renvoient toujours ``None`` ou une instance d'\\ :"
+"ref:`objet correspondance <match-objects>`. ::"
 
 #: howto/regex.rst:510
 msgid ""
@@ -1316,7 +1317,7 @@ msgstr ""
 "utilise ces fonctions C pour ``\\w`` ; c'est plus lent mais cela permet à ``"
 "\\w+`` de correspondre avec les mots français tel qu'attendu. L'utilisation "
 "de cette option est déconseillée en Python 3 car le mécanisme de locale est "
-"très peu fiable, il ne gère qu'une seule \"culture\" à la fois et il ne "
+"très peu fiable, il ne gère qu'une seule « culture » à la fois et il ne "
 "fonctionne qu'avec des locales 8 bits. La correspondance Unicode est déjà "
 "activée par défaut dans Python 3 pour les motifs Unicode (type *str*) et "
 "elle est capable de gérer différentes configurations de régions."
@@ -1381,8 +1382,8 @@ msgid ""
 msgstr ""
 "Cette option vous permet d'écrire des expressions régulières plus lisibles "
 "en vous permettant plus de flexibilité pour le formatage. Lorsque cette "
-"option est activée, les \"blancs\" dans la chaîne RE sont ignorés, sauf "
-"lorsque le \"blanc\" se trouve dans une classe de caractères ou est précédé "
+"option est activée, les « blancs » dans la chaîne RE sont ignorés, sauf "
+"lorsque le « blancs » se trouve dans une classe de caractères ou est précédé "
 "d'une barre oblique inverse ; ceci vous permet d'organiser et d'indenter vos "
 "RE plus clairement. Cette option vous permet également de placer des "
 "commentaires dans une RE, ils seront ignorés par le moteur ; les "
@@ -1395,7 +1396,7 @@ msgid ""
 "it is to read? ::"
 msgstr ""
 "Par exemple, voici une RE qui utilise :const:`re.VERBOSE` ; vous pouvez "
-"constater qu'elle est beaucoup plus facile à lire ::"
+"constater qu'elle est beaucoup plus facile à lire ::"
 
 #: howto/regex.rst:660
 msgid "Without the verbose setting, the RE would look like this::"
@@ -1473,7 +1474,7 @@ msgid ""
 "``'Crow'`` or ``'Servo'``, not ``'Cro'``, a ``'w'`` or an ``'S'``, and "
 "``'ervo'``."
 msgstr ""
-"Union ensembliste ou opérateur \"ou\". Si *A* et *B* sont des expressions "
+"Union ensembliste ou opérateur « ou ». Si *A* et *B* sont des expressions "
 "régulières, ``A|B`` correspond à toute chaine qui correspond à A ou à B. La "
 "priorité de ``|`` est très faible afin de pouvoir effectuer simplement des "
 "unions de chaînes de plusieurs caractères. ``Crow|Servo`` correspond avec "
@@ -1548,7 +1549,7 @@ msgid ""
 "string, but ``^`` may match at any location inside the string that follows a "
 "newline character."
 msgstr ""
-"Correspond au début de la chaîne de caractère, uniquement. Si l'option :"
+"Correspond au début de la chaîne de caractères, uniquement. Si l'option :"
 "const:`MULTILINE` n'est pas activée, ``\\A`` et ``^`` sont équivalents. Dans "
 "le mode :const:`MULTILINE`, ils sont différents : ``\\A`` ne correspond "
 "toujours qu'au début de la chaîne alors que ``^`` correspond aussi aux "
@@ -1577,7 +1578,7 @@ msgstr ""
 "Limite de mot. C'est une assertion de largeur zéro qui correspond uniquement "
 "aux positions de début et de fin de mot. Un mot est défini comme une "
 "séquence de caractères alphanumériques ; ainsi, la fin d'un mot est indiquée "
-"par un \"blanc\" ou un caractère non-alphanumérique."
+"par un « blanc » ou un caractère non-alphanumérique."
 
 #: howto/regex.rst:749
 msgid ""
@@ -1601,11 +1602,11 @@ msgstr ""
 "Quand vous utilisez cette séquence spéciale, gardez deux choses à l'esprit. "
 "Tout d'abord, c'est la pire collision entre les littéraux des chaînes Python "
 "et les séquences d'expressions régulières.  Dans les littéraux de chaîne de "
-"caractères Python, ``\\b``` est le caractère de retour-arrière (*backspace* "
+"caractères Python, ``\\b`` est le caractère de retour-arrière (*backspace* "
 "en anglais), dont la valeur ASCII est 8.  Si vous n'utilisez pas les chaînes "
 "de caractères brutes, alors Python convertit le ``\\b`` en retour-arrière, "
 "et votre RE ne correspond pas à ce que vous attendez. L'exemple suivant "
-"ressemble à notre RE précédente, mais nous avons omis le ```'r'`` devant la "
+"ressemble à notre RE précédente, mais nous avons omis le ``'r'`` devant la "
 "chaîne RE. ::"
 
 #: howto/regex.rst:774
@@ -1670,7 +1671,7 @@ msgid ""
 "+``, ``?``, or ``{m,n}``.  For example, ``(ab)*`` will match zero or more "
 "repetitions of ``ab``. ::"
 msgstr ""
-"Les groupes sont délimités par les métacaractères marqueurs ``'('``et "
+"Les groupes sont délimités par les métacaractères marqueurs ``'('`` et "
 "``')'``. ``'('`` et ``')'`` ont à peu près le même sens que dans les "
 "expressions mathématiques ; ils forment un groupe à partir des expressions "
 "qu'ils encadrent ; vous pouvez répéter le contenu d'un groupe à l'aide d'un "
@@ -1688,15 +1689,15 @@ msgid ""
 "we'll see how to express groups that don't capture the span of text that "
 "they match. ::"
 msgstr ""
-"Les groupes délimités par ``'('``et ``')'`` capturent également les indices "
+"Les groupes délimités par ``'('`` et ``')'`` capturent également les indices "
 "de début et de fin du texte avec lequel ils correspondent ; ces indices "
 "peuvent être récupérés en passant un argument à :meth:`~re.Match.group`, :"
 "meth:`~re.Match.start`, :meth:`~re.Match.end` ou :meth:`~re.Match.span`. Les "
-"groupes sont numérotés à partir de 0, le groupe 0 est toujours présent ; "
-"c'est l'ensemble de la RE, donc les méthodes de :ref:`l'objet correspondance "
-"<match-objects>` ont le groupe 0 comme argument par défaut. Plus loin, nous "
-"voyons comment exprimer les groupes qui ne capturent pas l'étendue du texte "
-"avec lequel ils correspondent. ::"
+"groupes sont numérotés à partir de 0, le groupe 0 étant toujours présent ; "
+"c'est l'ensemble de la RE, donc les méthodes de l'\\ :ref:`objet "
+"correspondance <match-objects>` ont le groupe 0 comme argument par défaut. "
+"Plus loin, nous voyons comment exprimer les groupes qui ne capturent pas "
+"l'étendue du texte avec lequel ils correspondent. ::"
 
 #: howto/regex.rst:830
 msgid ""
@@ -1716,7 +1717,7 @@ msgid ""
 "those groups. ::"
 msgstr ""
 "Vous pouvez passer plusieurs numéros de groupes à :meth:`~re.Match.group` en "
-"même temps, elle vous renvoie alors un *tuple* contenant les valeurs "
+"même temps, elle vous renvoie alors un *n*-uplet contenant les valeurs "
 "correspondantes pour ces groupes. ::"
 
 #: howto/regex.rst:849
@@ -1724,7 +1725,7 @@ msgid ""
 "The :meth:`~re.Match.groups` method returns a tuple containing the strings "
 "for all the subgroups, from 1 up to however many there are. ::"
 msgstr ""
-"La méthode  :meth:`~re.Match.groups` renvoie un *tuple* contenant les "
+"La méthode  :meth:`~re.Match.groups` renvoie un *n*-uplet contenant les "
 "chaînes pour tous les sous-groupes, en commençant par le numéro 1 jusqu'au "
 "dernier. ::"
 
@@ -1759,9 +1760,9 @@ msgid ""
 "substitutions."
 msgstr ""
 "Les renvois tels que celui-ci ne sont pas très utiles pour effectuer une "
-"simple recherche dans une chaîne --- il n'y a que peu de formats de textes "
-"qui répètent des données ainsi --- mais vous verrez bientôt qu'ils sont "
-"*très* utiles pour effectuer des substitutions dans les chaînes."
+"simple recherche dans une chaîne —­ il n'y a que peu de formats de textes qui "
+"répètent des données ainsi — mais vous verrez bientôt qu'ils sont *très* "
+"utiles pour effectuer des substitutions dans les chaînes."
 
 #: howto/regex.rst:875
 msgid "Non-capturing and Named Groups"
@@ -1897,7 +1898,7 @@ msgid ""
 "ways::"
 msgstr ""
 "La syntaxe pour nommer les groupes est l'une des extensions spécifiques à "
-"Python : ``(?P<nom>....)```. *nom* est, vous vous en doutez, le nom du "
+"Python : ``(?P<nom>....)``. *nom* est, vous vous en doutez, le nom du "
 "groupe. Les groupes nommés se comportent exactement comme des groupes de "
 "capture, sauf qu'ils associent en plus un nom à un groupe. Les méthodes des :"
 "ref:`objets correspondances <match-objects>` qui gèrent les groupes de "
@@ -2069,7 +2070,7 @@ msgstr ""
 "L'expression devient plus confuse si nous essayons de réparer la première "
 "solution en spécifiant l'un des cas suivants : le premier caractère de "
 "l'extension n'est pas ``b`` ; le deuxième caractère n'est pas ``a`` ; ou le "
-"troisième caractère n'est pas ``t```. Ce motif accepte ``truc.bar`` et "
+"troisième caractère n'est pas ``t``. Ce motif accepte ``truc.bar`` et "
 "rejette ``autoexec.bat``, mais elle nécessite une extension de trois lettres "
 "et n'accepte pas un nom de fichier avec une extension de deux lettres comme "
 "``sendmail.cf``. Compliquons encore une fois le motif pour essayer de le "
@@ -2203,7 +2204,7 @@ msgstr ""
 "morceaux. C'est similaire à la méthode :meth:`~str.split` mais est beaucoup "
 "plus générale par les délimiteurs que vous pouvez spécifier ; la méthode  :"
 "meth:`!split` du type *string* ne gère que les découpages en suivant les "
-"\"blancs\" ou suivant une chaîne définie. Comme vous pouvez vous y attendre, "
+"« blancs » ou suivant une chaîne définie. Comme vous pouvez vous y attendre, "
 "il y a aussi une fonction :func:`re.split` de niveau module."
 
 #: howto/regex.rst:1092
@@ -2325,7 +2326,7 @@ msgid ""
 "string."
 msgstr ""
 "Si *replacement* est une chaîne de caractères, toute barre oblique inverse "
-"d'échappement est traitée.  C'est-à-dire que ```\\n`` est converti en "
+"d'échappement est traitée.  C'est-à-dire que ``\\n`` est converti en "
 "caractère de nouvelle ligne, ``\\r`` est converti en retour chariot, et "
 "ainsi de suite. Les échappements inconnus comme ``\\&`` sont laissés tels "
 "quels. Les renvois, tels que ``\\6``, sont remplacés par la sous-chaîne "
@@ -2398,8 +2399,8 @@ msgstr ""
 "d'objet ou de chaîne de caractères ; si vous avez besoin de spécifier des "
 "options pour l'expression régulière, vous devez soit utiliser un objet motif "
 "comme premier paramètre, soit utiliser des modificateurs intégrés dans la "
-"chaîne de caractères, par exemple ``sub(\"(?i)b+\", \"x\", \"bbbb BBBBB"
-"\")```renvoie ``'x x'``."
+"chaîne de caractères, par exemple ``sub(\"(?i)b+\", \"x\", \"bbbb BBBBB\")`` "
+"renvoie ``'x x'``."
 
 #: howto/regex.rst:1232
 msgid "Common Problems"
@@ -2526,13 +2527,13 @@ msgid ""
 msgstr ""
 "Vous pouvez être tenté d'utiliser :func:`re.match` en ajoutant simplement ``."
 "*`` au début de votre RE. Ce n'est pas une bonne idée, utilisez plutôt :func:"
-"`re.search`. Le compilateur d'expressions régulières analyse les REs pour "
+"`re.search`. Le compilateur d'expressions régulières analyse les RE pour "
 "optimiser le processus de recherche d'une correspondance. Cette analyse "
 "permet de déterminer ce que doit être le premier caractère d'une "
 "correspondance ; par exemple, un motif commençant par ``Corbeau`` doit faire "
 "correspondre un ``'C'`` en tête. L'analyse permet au moteur de parcourir "
 "rapidement la chaîne de caractères à la recherche du caractère de départ, "
-"n'essayant la correspondance complète que si un \"C\" a déjà été trouvé."
+"n'essayant la correspondance complète que si un ``'C'`` a déjà été trouvé."
 
 #: howto/regex.rst:1300
 msgid ""
@@ -2573,7 +2574,7 @@ msgid ""
 "The final match extends from the ``'<'`` in ``'<html>'`` to the ``'>'`` in "
 "``'</title>'``, which isn't what you want."
 msgstr ""
-"La RE correspond au ``'<'`` de ``'<html>'`` et le ``.*``` consomme le reste "
+"La RE correspond au ``'<'`` de ``'<html>'`` et le ``.*`` consomme le reste "
 "de la chaîne. Mais, comme il reste des éléments du motif dans la RE et que "
 "le ``>`` ne peut pas correspondre à la fin de la chaîne de caractères, le "
 "moteur d'expression régulière doit faire marche arrière caractère par "
@@ -2690,7 +2691,7 @@ msgid ""
 "you much.)  Consider checking it out from your library."
 msgstr ""
 "Le livre le plus complet sur les expressions régulières est certainement "
-"Mastering Regular Expressions de Jeffrey Friedl, publié par O'Reilly. "
+"*Mastering Regular Expressions* de Jeffrey Friedl, publié par O'Reilly. "
 "Malheureusement, il se concentre sur les déclinaisons Perl et Java des "
 "expressions régulières et ne contient aucun contenu pour Python ; il n'est "
 "donc pas utile d'en faire référence pour la programmation Python. (La "