forked from AFPy/python-docs-fr
Relecture du guide des expressions régulières (#1467)
This commit is contained in:
parent
77353e7823
commit
96f037a2d3
149
howto/regex.po
149
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 "
|
||||
|
|
Loading…
Reference in New Issue
Block a user