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

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

Browse source
This commit is contained in:
Christophe Nanteuil 2020-11-18 23:33:54 +01:00 • committed by GitHub
commit 96f037a2d3
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
1 changed files with 75 additions and 74 deletions
Download patch file Download diff file Expand all files Collapse all files

149
howto/regex.po
View file

@ -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 "