forked from AFPy/python-docs-fr
1995 lines
77 KiB
Plaintext
1995 lines
77 KiB
Plaintext
# SOME DESCRIPTIVE TITLE.
|
||
# Copyright (C) 2001-2016, Python Software Foundation
|
||
# This file is distributed under the same license as the Python package.
|
||
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
|
||
#
|
||
#, fuzzy
|
||
msgid ""
|
||
msgstr ""
|
||
"Project-Id-Version: Python 3.6\n"
|
||
"Report-Msgid-Bugs-To: \n"
|
||
"POT-Creation-Date: 2017-05-27 19:40+0200\n"
|
||
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
|
||
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
|
||
"Language-Team: LANGUAGE <LL@li.org>\n"
|
||
"Language: fr\n"
|
||
"MIME-Version: 1.0\n"
|
||
"Content-Type: text/plain; charset=UTF-8\n"
|
||
"Content-Transfer-Encoding: 8bit\n"
|
||
|
||
#: ../Doc/library/re.rst:2
|
||
msgid ":mod:`re` --- Regular expression operations"
|
||
msgstr ":mod:`re` --- Opérations à base d'expressions rationnelles"
|
||
|
||
#: ../Doc/library/re.rst:10
|
||
msgid "**Source code:** :source:`Lib/re.py`"
|
||
msgstr "**Code source :** :source:`Lib/re.py`"
|
||
|
||
#: ../Doc/library/re.rst:14
|
||
msgid ""
|
||
"This module provides regular expression matching operations similar to those "
|
||
"found in Perl."
|
||
msgstr ""
|
||
"Ce module fournit des opérations sur les expressions rationnelles "
|
||
"similaires à celles que l'on trouve dans Perl."
|
||
|
||
#: ../Doc/library/re.rst:17
|
||
msgid ""
|
||
"Both patterns and strings to be searched can be Unicode strings as well as 8-"
|
||
"bit strings. However, Unicode strings and 8-bit strings cannot be mixed: "
|
||
"that is, you cannot match a Unicode string with a byte pattern or vice-"
|
||
"versa; similarly, when asking for a substitution, the replacement string "
|
||
"must be of the same type as both the pattern and the search string."
|
||
msgstr ""
|
||
"Motifs comme chaînes à analyser peuvent aussi bien être des chaînes Unicode "
|
||
"que des chaînes 8-bit. Cependant, chaînes Unicode et 8-bit ne peuvent pas "
|
||
"être mélangées : vous ne pouvez ainsi pas analyser une chaîne Unicode avec "
|
||
"un motif 8-bit, et inversement ; similairement, lors d'une substitution, la "
|
||
"chaîne de remplacement doit être du même type que le motif et la chaîne "
|
||
"analysée."
|
||
|
||
#: ../Doc/library/re.rst:23
|
||
msgid ""
|
||
"Regular expressions use the backslash character (``'\\'``) to indicate "
|
||
"special forms or to allow special characters to be used without invoking "
|
||
"their special meaning. This collides with Python's usage of the same "
|
||
"character for the same purpose in string literals; for example, to match a "
|
||
"literal backslash, one might have to write ``'\\\\\\\\'`` as the pattern "
|
||
"string, because the regular expression must be ``\\\\``, and each backslash "
|
||
"must be expressed as ``\\\\`` inside a regular Python string literal."
|
||
msgstr ""
|
||
"Les expressions rationnelles utilisent le caractère *backslash* (``'\\'``) "
|
||
"pour indiquer des formes spéciales ou permettre d'utiliser des caractères "
|
||
"spéciaux sans en invoquer le sens. Cela entre en conflit avec l'utilisation "
|
||
"en Python du même caractère pour la même raison dans les chaînes "
|
||
"littérales ; par exemple, pour rechercher un *backslash* littéral il "
|
||
"faudrait écrire ``'\\\\\\\\'`` comme motif, parce que l'expression "
|
||
"rationnelle devrait être ``\\\\``, et chaque *backslash* exprimé par ``\\"
|
||
"\\`` au sein des chaînes littérales Python."
|
||
|
||
#: ../Doc/library/re.rst:32
|
||
msgid ""
|
||
"The solution is to use Python's raw string notation for regular expression "
|
||
"patterns; backslashes are not handled in any special way in a string literal "
|
||
"prefixed with ``'r'``. So ``r\"\\n\"`` is a two-character string containing "
|
||
"``'\\'`` and ``'n'``, while ``\"\\n\"`` is a one-character string containing "
|
||
"a newline. Usually patterns will be expressed in Python code using this raw "
|
||
"string notation."
|
||
msgstr ""
|
||
"La solution est d'utiliser la notation des chaînes brutes en Python pour les "
|
||
"expressions rationnelles ; Les *backslashes* ne provoquent aucun traitement "
|
||
"spécifique dans les chaînes littérales préfixées par ``'r'``. Ainsi, ``r"
|
||
"\"\\n\"`` est une chaîne de deux caractères contenant ``'\\'`` et ``'n'``, "
|
||
"tandis que ``\"\\n\"`` est une chaîne contenant un unique caractère : un "
|
||
"saut de ligne. Généralement, les motifs seront exprimés en Python à l'aide "
|
||
"de chaînes brutes."
|
||
|
||
#: ../Doc/library/re.rst:39
|
||
msgid ""
|
||
"It is important to note that most regular expression operations are "
|
||
"available as module-level functions and methods on :ref:`compiled regular "
|
||
"expressions <re-objects>`. The functions are shortcuts that don't require "
|
||
"you to compile a regex object first, but miss some fine-tuning parameters."
|
||
msgstr ""
|
||
"Il est important de noter que la plupart des opérations sur les expressions "
|
||
"rationnelles sont disponibles comme fonctions au niveau du module et comme "
|
||
"méthodes des :ref:`expressions rationnelles compilées <re-objects>`. Les "
|
||
"fonctions sont des raccourcis qui ne vous obligent pas à d'abord compiler un "
|
||
"objet *regex*, mais auxquelles manquent certains paramètres de configuration "
|
||
"fine."
|
||
|
||
#: ../Doc/library/re.rst:47
|
||
msgid ""
|
||
"The third-party `regex <https://pypi.python.org/pypi/regex/>`_ module, which "
|
||
"has an API compatible with the standard library :mod:`re` module, but offers "
|
||
"additional functionality and a more thorough Unicode support."
|
||
msgstr ""
|
||
"Le module tiers `regex <https://pypi.python.org/pypi/regex/>`_, dont "
|
||
"l'interface est compatible avec le module :mod:`re` de la bibliothèque "
|
||
"standard, mais offre des fonctionnalités additionnelles et un meilleur "
|
||
"support de l'Unicode."
|
||
|
||
#: ../Doc/library/re.rst:55
|
||
msgid "Regular Expression Syntax"
|
||
msgstr "Syntaxe des Expressions Rationnelles"
|
||
|
||
#: ../Doc/library/re.rst:57
|
||
msgid ""
|
||
"A regular expression (or RE) specifies a set of strings that matches it; the "
|
||
"functions in this module let you check if a particular string matches a "
|
||
"given regular expression (or if a given regular expression matches a "
|
||
"particular string, which comes down to the same thing)."
|
||
msgstr ""
|
||
"Une expression rationnelle (*regular expression* ou *RE*) spécifie un "
|
||
"ensemble de chaînes de caractères qui lui correspondent ; les fonctions de "
|
||
"ce module vous permettent de vérifier si une chaîne particulière correspond "
|
||
"à une expression rationnelle donnée (ou si un expression rationnelle donnée "
|
||
"correspond à une chaîne particulière, ce qui revient à la même chose)."
|
||
|
||
#: ../Doc/library/re.rst:62
|
||
msgid ""
|
||
"Regular expressions can be concatenated to form new regular expressions; if "
|
||
"*A* and *B* are both regular expressions, then *AB* is also a regular "
|
||
"expression. In general, if a string *p* matches *A* and another string *q* "
|
||
"matches *B*, the string *pq* will match AB. This holds unless *A* or *B* "
|
||
"contain low precedence operations; boundary conditions between *A* and *B*; "
|
||
"or have numbered group references. Thus, complex expressions can easily be "
|
||
"constructed from simpler primitive expressions like the ones described "
|
||
"here. For details of the theory and implementation of regular expressions, "
|
||
"consult the Friedl book referenced above, or almost any textbook about "
|
||
"compiler construction."
|
||
msgstr ""
|
||
"Les expressions rationnelles peuvent être concaténées pour former de "
|
||
"nouvelles expressions : si *A* et *B* sont deux expressions rationnelles, "
|
||
"alors *AB* est aussi une expression rationnelle. En général, si une chaîne "
|
||
"*p* valide *A* et qu'une autre chaîne *q* valide *B*, la chaîne *pq* "
|
||
"validera AB. Cela est vrai tant que *A* et *B* ne contiennent pas "
|
||
"d'opérations de précédence ; de conditions liées entre *A* et *B* ; ou de "
|
||
"références vers des groupes numérotés. Ainsi, des expressions complexes "
|
||
"peuvent facilement être construites depuis de plus simples expressions "
|
||
"primitives comme celles décrites ici. Pour plus de détails sur la théorie "
|
||
"et l'implémentation des expressions rationnelles, consultez le livre de "
|
||
"Frield référencé plus tôt, ou à peu près n'importe quel livre dédié à la "
|
||
"construction de compilateurs."
|
||
|
||
#: ../Doc/library/re.rst:72
|
||
msgid ""
|
||
"A brief explanation of the format of regular expressions follows. For "
|
||
"further information and a gentler presentation, consult the :ref:`regex-"
|
||
"howto`."
|
||
msgstr ""
|
||
"Une brève explication sur le format des expressions rationnelles suit. Pour "
|
||
"de plus amples informations, et une meilleure présentation, référez-vous au :"
|
||
"ref:`regex-howto`."
|
||
|
||
#: ../Doc/library/re.rst:75
|
||
msgid ""
|
||
"Regular expressions can contain both special and ordinary characters. Most "
|
||
"ordinary characters, like ``'A'``, ``'a'``, or ``'0'``, are the simplest "
|
||
"regular expressions; they simply match themselves. You can concatenate "
|
||
"ordinary characters, so ``last`` matches the string ``'last'``. (In the "
|
||
"rest of this section, we'll write RE's in ``this special style``, usually "
|
||
"without quotes, and strings to be matched ``'in single quotes'``.)"
|
||
msgstr ""
|
||
"Les expressions rationnelles peuvent contenir à la fois des caractères "
|
||
"spéciaux et ordinaires. Les plus ordinaires, comme ``'A'``, ``'a'`` ou "
|
||
"``'0'`` sont les expressions rationnelles les plus simples : elles "
|
||
"correspondent simplement à elles-mêmes. Vous pouvez concaténer deux "
|
||
"caractères ordinaires, donc ``last`` correspond à la chaîne ``'last'``. "
|
||
"(Dans la suite de cette section, nous écrirons les expressions rationnelles "
|
||
"dans ``ce style spécifique``, généralement sans guillemets, et les chaînes à "
|
||
"tester ``'entourées de simples guillemets'``.)"
|
||
|
||
#: ../Doc/library/re.rst:82
|
||
msgid ""
|
||
"Some characters, like ``'|'`` or ``'('``, are special. Special characters "
|
||
"either stand for classes of ordinary characters, or affect how the regular "
|
||
"expressions around them are interpreted. Regular expression pattern strings "
|
||
"may not contain null bytes, but can specify the null byte using a ``"
|
||
"\\number`` notation such as ``'\\x00'``."
|
||
msgstr ""
|
||
"Certains caractères, comme ``'|'`` ou ``'('``, sont spéciaux. Des caractères "
|
||
"spéciaux peuvent aussi exister pour les classes de caractères ordinaires, ou "
|
||
"affecter comment les expressions rationnelles autour d'eux seront "
|
||
"interprétées. Les motifs d'expressions rationnelles ne devraient pas "
|
||
"contenir de caractères nuls, mais peuvent spécifier le caractère nul en "
|
||
"utilisant une notation ``\\number`` comme ``\\x00``."
|
||
|
||
#: ../Doc/library/re.rst:88
|
||
msgid ""
|
||
"Repetition qualifiers (``*``, ``+``, ``?``, ``{m,n}``, etc) cannot be "
|
||
"directly nested. This avoids ambiguity with the non-greedy modifier suffix "
|
||
"``?``, and with other modifiers in other implementations. To apply a second "
|
||
"repetition to an inner repetition, parentheses may be used. For example, the "
|
||
"expression ``(?:a{6})*`` matches any multiple of six ``'a'`` characters."
|
||
msgstr ""
|
||
"Les caractères de répétition (``*``, ``+``, ``?``, ``{m,n}``, etc.) ne "
|
||
"peuvent être directement imbriqués. Cela empêche l'ambiguïté avec le suffixe "
|
||
"modificateur non gourmand ``?``, et avec les autres modificateurs dans "
|
||
"d'autres implémentations. Pour appliquer une seconde répétition à une "
|
||
"première, des parenthèses peuvent être utilisées. Par exemple, l'expression "
|
||
"``(?:a{6})*`` valide toutes les chaînes composées d'un nombre de caractères "
|
||
"``'a'`` multiple de six."
|
||
|
||
#: ../Doc/library/re.rst:95
|
||
msgid "The special characters are:"
|
||
msgstr "Les caractères spéciaux sont :"
|
||
|
||
#: ../Doc/library/re.rst:100
|
||
msgid "``'.'``"
|
||
msgstr "``'.'``"
|
||
|
||
#: ../Doc/library/re.rst:98
|
||
msgid ""
|
||
"(Dot.) In the default mode, this matches any character except a newline. "
|
||
"If the :const:`DOTALL` flag has been specified, this matches any character "
|
||
"including a newline."
|
||
msgstr ""
|
||
"(Point.) Dans le mode par défaut, il valide tout caractère à l'exception du "
|
||
"saut de ligne. Si l'option :const:`DOTALL` a été spécifiée, il valide tout "
|
||
"caractère, saut de ligne compris."
|
||
|
||
#: ../Doc/library/re.rst:104
|
||
msgid "``'^'``"
|
||
msgstr "``'^'``"
|
||
|
||
#: ../Doc/library/re.rst:103
|
||
msgid ""
|
||
"(Caret.) Matches the start of the string, and in :const:`MULTILINE` mode "
|
||
"also matches immediately after each newline."
|
||
msgstr ""
|
||
"(Accent circonflexe.) Valide le début d'une chaîne de caractères, ainsi que "
|
||
"ce qui suit chaque saut de ligne en mode :const:`MULTILINE`."
|
||
|
||
#: ../Doc/library/re.rst:113
|
||
msgid "``'$'``"
|
||
msgstr "``'$'``"
|
||
|
||
#: ../Doc/library/re.rst:107
|
||
msgid ""
|
||
"Matches the end of the string or just before the newline at the end of the "
|
||
"string, and in :const:`MULTILINE` mode also matches before a newline. "
|
||
"``foo`` matches both 'foo' and 'foobar', while the regular expression ``foo"
|
||
"$`` matches only 'foo'. More interestingly, searching for ``foo.$`` in "
|
||
"``'foo1\\nfoo2\\n'`` matches 'foo2' normally, but 'foo1' in :const:"
|
||
"`MULTILINE` mode; searching for a single ``$`` in ``'foo\\n'`` will find two "
|
||
"(empty) matches: one just before the newline, and one at the end of the "
|
||
"string."
|
||
msgstr ""
|
||
"Valide la fin d'une chaîne de caractères, ou juste avant le saut de ligne à "
|
||
"la fin de la chaîne, ainsi qu'avant chaque saut de ligne en mode :const:"
|
||
"`MULTILINE`. ``foo`` valide à la fois 'foo' et 'foobar', tandis que "
|
||
"l'expression rationnelle ``foo$`` ne correspond qu'à 'foo'. Plus "
|
||
"intéressant, chercher ``foo.$`` dans ``'foo1\\nfoo2\\n'`` trouve normalement "
|
||
"'foo2', mais 'foo1' en mode :const:`MULTILINE` ; chercher un simple ``$`` "
|
||
"dans ``'foo\\n'`` trouvera deux correspondances (vides) : une juste avant le "
|
||
"saut de ligne, et une à la fin de la chaîne."
|
||
|
||
#: ../Doc/library/re.rst:118
|
||
msgid "``'*'``"
|
||
msgstr "``'*'``"
|
||
|
||
#: ../Doc/library/re.rst:116
|
||
msgid ""
|
||
"Causes the resulting RE to match 0 or more repetitions of the preceding RE, "
|
||
"as many repetitions as are possible. ``ab*`` will match 'a', 'ab', or 'a' "
|
||
"followed by any number of 'b's."
|
||
msgstr ""
|
||
"Implique à l'expression rationnelle résultante de valider 0 répétition ou "
|
||
"plus de l'expression qui précède, avec autant de répétitions que possible. "
|
||
"``ab*`` validera 'a', 'ab' ou 'a' suivi de n'importe quel nombre de 'b'."
|
||
|
||
#: ../Doc/library/re.rst:123
|
||
msgid "``'+'``"
|
||
msgstr "``'+'``"
|
||
|
||
#: ../Doc/library/re.rst:121
|
||
msgid ""
|
||
"Causes the resulting RE to match 1 or more repetitions of the preceding RE. "
|
||
"``ab+`` will match 'a' followed by any non-zero number of 'b's; it will not "
|
||
"match just 'a'."
|
||
msgstr ""
|
||
"Implique à l'expression rationnelle résultante de valider une répétition ou "
|
||
"plus de l'expression qui précède. ``ab+`` validera 'a' suivi de n'importe "
|
||
"quel nombre non nul de 'b' ; ça ne validera pas la chaîne 'a'."
|
||
|
||
#: ../Doc/library/re.rst:127
|
||
msgid "``'?'``"
|
||
msgstr "``'?'``"
|
||
|
||
#: ../Doc/library/re.rst:126
|
||
msgid ""
|
||
"Causes the resulting RE to match 0 or 1 repetitions of the preceding RE. "
|
||
"``ab?`` will match either 'a' or 'ab'."
|
||
msgstr ""
|
||
"Implique à l'expression rationnelle résultante de valider 0 ou 1 répétition "
|
||
"de l'expression qui précède. ``ab?`` correspondra à la fois à 'a' et 'ab'."
|
||
|
||
#: ../Doc/library/re.rst:136
|
||
msgid "``*?``, ``+?``, ``??``"
|
||
msgstr "``*?``, ``+?``, ``??``"
|
||
|
||
#: ../Doc/library/re.rst:130
|
||
msgid ""
|
||
"The ``'*'``, ``'+'``, and ``'?'`` qualifiers are all :dfn:`greedy`; they "
|
||
"match as much text as possible. Sometimes this behaviour isn't desired; if "
|
||
"the RE ``<.*>`` is matched against ``<a> b <c>``, it will match the entire "
|
||
"string, and not just ``<a>``. Adding ``?`` after the qualifier makes it "
|
||
"perform the match in :dfn:`non-greedy` or :dfn:`minimal` fashion; as *few* "
|
||
"characters as possible will be matched. Using the RE ``<.*?>`` will match "
|
||
"only ``<a>``."
|
||
msgstr ""
|
||
"Les qualificateurs ``'*'``, ``'+'`` et ``'?'`` sont tous :dfn:`greedy` "
|
||
"(gourmands) ; ils valident autant de texte que possible. Parfois ce "
|
||
"comportement n'est pas désiré ; si l'expression rationnelle ``<.*>`` est "
|
||
"testée avec la chaîne ``<a> b <c>``, cela correspondra à la chaîne entière, "
|
||
"et non juste à ``<a>``. Ajouter ``?`` derrière le qualificateur lui fait "
|
||
"réaliser l'opération de façon :dfn:`non-greedy` (ou :dfn:`minimal`) ; le "
|
||
"*moins* de caractères possibles seront validés. Utiliser l'expression "
|
||
"rationnelle ``<.*?>`` validera uniquement ``<a>``."
|
||
|
||
#: ../Doc/library/re.rst:141
|
||
msgid "``{m}``"
|
||
msgstr "``{m}``"
|
||
|
||
#: ../Doc/library/re.rst:139
|
||
msgid ""
|
||
"Specifies that exactly *m* copies of the previous RE should be matched; "
|
||
"fewer matches cause the entire RE not to match. For example, ``a{6}`` will "
|
||
"match exactly six ``'a'`` characters, but not five."
|
||
msgstr ""
|
||
"Spécifie qu'exactement *m* copies de l'expression rationnelle qui précède "
|
||
"devront être validées ; un nombre plus faible de correspondances empêche "
|
||
"l'expression entière de correspondre. Par exemple, ``a{6}`` correspondra "
|
||
"exactement à six caractères ``'a'``, mais pas à cinq."
|
||
|
||
#: ../Doc/library/re.rst:150
|
||
msgid "``{m,n}``"
|
||
msgstr "``{m,n}``"
|
||
|
||
#: ../Doc/library/re.rst:144
|
||
msgid ""
|
||
"Causes the resulting RE to match from *m* to *n* repetitions of the "
|
||
"preceding RE, attempting to match as many repetitions as possible. For "
|
||
"example, ``a{3,5}`` will match from 3 to 5 ``'a'`` characters. Omitting *m* "
|
||
"specifies a lower bound of zero, and omitting *n* specifies an infinite "
|
||
"upper bound. As an example, ``a{4,}b`` will match ``aaaab`` or a thousand "
|
||
"``'a'`` characters followed by a ``b``, but not ``aaab``. The comma may not "
|
||
"be omitted or the modifier would be confused with the previously described "
|
||
"form."
|
||
msgstr ""
|
||
"Implique à l'expression rationnelle résultante de valider entre *m* et *n* "
|
||
"répétitions de l'expression qui précède, cherchant à en valider le plus "
|
||
"possible. Par exemple, ``a{3,5}`` validera entre 3 et 5 caractères "
|
||
"``'a'``. Omettre *m* revient à spécifier 0 comme borne inférieure, et "
|
||
"omettre *n* à avoir une borne supérieure infinie. Par exemple, ``a{4,}b`` "
|
||
"correspondra à ``aaaab`` ou à un millier de caractères ``'a'`` suivis d'un "
|
||
"``b``, mais pas à ``aaab``. La virgule ne doit pas être omise, auquel cas le "
|
||
"modificateur serait confondu avec la forme décrite précédemment."
|
||
|
||
#: ../Doc/library/re.rst:157
|
||
msgid "``{m,n}?``"
|
||
msgstr "``{m,n}?``"
|
||
|
||
#: ../Doc/library/re.rst:153
|
||
msgid ""
|
||
"Causes the resulting RE to match from *m* to *n* repetitions of the "
|
||
"preceding RE, attempting to match as *few* repetitions as possible. This is "
|
||
"the non-greedy version of the previous qualifier. For example, on the 6-"
|
||
"character string ``'aaaaaa'``, ``a{3,5}`` will match 5 ``'a'`` characters, "
|
||
"while ``a{3,5}?`` will only match 3 characters."
|
||
msgstr ""
|
||
"Implique à l'expression rationnelle résultante de valider entre *m* et *n* "
|
||
"répétitions de l'expression qui précède, cherchant à en valider le moins "
|
||
"possible. Il s'agit de la version non gourmande du précédent "
|
||
"qualificateur. Par exemple, dans la chaîne de 6 caractères ``'aaaaaa'``, "
|
||
"``a{3,5}`` trouvera 5 caractères ``'a'``, alors que ``a{3,5}?`` n'en "
|
||
"trouvera que 3."
|
||
|
||
#: ../Doc/library/re.rst:170
|
||
msgid "``'\\'``"
|
||
msgstr "``'\\'``"
|
||
|
||
#: ../Doc/library/re.rst:160
|
||
msgid ""
|
||
"Either escapes special characters (permitting you to match characters like "
|
||
"``'*'``, ``'?'``, and so forth), or signals a special sequence; special "
|
||
"sequences are discussed below."
|
||
msgstr ""
|
||
"Échappe à la fois les caractères spéciaux (permettant d'utiliser des "
|
||
"caractères comme ``'*'``, ``'?'`` et autres), ou signale une séquence "
|
||
"spéciale ; les séquences spéciales sont décrites ci-dessous."
|
||
|
||
#: ../Doc/library/re.rst:164
|
||
msgid ""
|
||
"If you're not using a raw string to express the pattern, remember that "
|
||
"Python also uses the backslash as an escape sequence in string literals; if "
|
||
"the escape sequence isn't recognized by Python's parser, the backslash and "
|
||
"subsequent character are included in the resulting string. However, if "
|
||
"Python would recognize the resulting sequence, the backslash should be "
|
||
"repeated twice. This is complicated and hard to understand, so it's highly "
|
||
"recommended that you use raw strings for all but the simplest expressions."
|
||
msgstr ""
|
||
"Si vous n'utilisez pas de chaînes brutes pour exprimer le motif, souvenez-"
|
||
"vous que Python utilise aussi le *backslash* comme une séquence "
|
||
"d'échappement dans les chaînes littérales ; si la séquence d'échappement "
|
||
"n'est pas reconnue par le parseur Python, le *backslash* et les caractères "
|
||
"qui le suivent sont inclus dans la chaîne retournée. Cependant, si Python "
|
||
"avait reconnu la séquence, le *backslash* aurait dû être doublé. C'est "
|
||
"assez compliqué et difficile à comprendre, c'est pourquoi il est hautement "
|
||
"recommandé d'utiliser des chaînes brutes pour tout sauf les expressions les "
|
||
"plus simples."
|
||
|
||
#: ../Doc/library/re.rst:202
|
||
msgid "``[]``"
|
||
msgstr "``[]``"
|
||
|
||
#: ../Doc/library/re.rst:173
|
||
msgid "Used to indicate a set of characters. In a set:"
|
||
msgstr "Utilisé pour indiquer un ensemble de caractères. Dans un ensemble :"
|
||
|
||
#: ../Doc/library/re.rst:175
|
||
msgid ""
|
||
"Characters can be listed individually, e.g. ``[amk]`` will match ``'a'``, "
|
||
"``'m'``, or ``'k'``."
|
||
msgstr ""
|
||
"Les caractères peuvent être listés individuellement, e.g. ``[amk]`` "
|
||
"correspondra à ``'a'``, ``'m'`` ou ``'k'``."
|
||
|
||
#: ../Doc/library/re.rst:178
|
||
msgid ""
|
||
"Ranges of characters can be indicated by giving two characters and "
|
||
"separating them by a ``'-'``, for example ``[a-z]`` will match any lowercase "
|
||
"ASCII letter, ``[0-5][0-9]`` will match all the two-digits numbers from "
|
||
"``00`` to ``59``, and ``[0-9A-Fa-f]`` will match any hexadecimal digit. If "
|
||
"``-`` is escaped (e.g. ``[a\\-z]``) or if it's placed as the first or last "
|
||
"character (e.g. ``[a-]``), it will match a literal ``'-'``."
|
||
msgstr ""
|
||
"Des intervalles de caractères peuvent être indiqués en donnant deux "
|
||
"caractères et les séparant par un ``'-'``, par exemple ``[a-z]`` "
|
||
"correspondra à toute lettre minuscule *ASCII*, ``[0-5][0-9]`` à tous nombres "
|
||
"de deux chiffres entre ``00` et ``59``, et ``[0-9A-Fa-f]`` correspondra à "
|
||
"n'importe quel chiffre hexadécimal. Si ``'-'`` est échappé (``[a\\-z]``) ou "
|
||
"s'il est placé comme premier ou dernier caractère (e.g. ``[a-]``), il "
|
||
"correspondra à un ``'-'`` littéral."
|
||
|
||
#: ../Doc/library/re.rst:185
|
||
msgid ""
|
||
"Special characters lose their special meaning inside sets. For example, "
|
||
"``[(+*)]`` will match any of the literal characters ``'('``, ``'+'``, "
|
||
"``'*'``, or ``')'``."
|
||
msgstr ""
|
||
"Les caractères spéciaux perdent leur sens à l'intérieur des ensembles. Par "
|
||
"exemple, ``[(+*)]`` validera chacun des caractères littéraux ``'('``, "
|
||
"``'+'``, ``'*'`` ou ``')'``."
|
||
|
||
#: ../Doc/library/re.rst:189
|
||
msgid ""
|
||
"Character classes such as ``\\w`` or ``\\S`` (defined below) are also "
|
||
"accepted inside a set, although the characters they match depends on "
|
||
"whether :const:`ASCII` or :const:`LOCALE` mode is in force."
|
||
msgstr ""
|
||
"Les classes de caractères telles que ``\\w`` ou ``\\S`` (définies ci-"
|
||
"dessous) sont aussi acceptées à l'intérieur d'un ensemble, bien que les "
|
||
"caractères correspondant dépendent de quel mode est actif entre :const:"
|
||
"`ASCII` et :const:`LOCALE`."
|
||
|
||
#: ../Doc/library/re.rst:193
|
||
msgid ""
|
||
"Characters that are not within a range can be matched by :dfn:"
|
||
"`complementing` the set. If the first character of the set is ``'^'``, all "
|
||
"the characters that are *not* in the set will be matched. For example, "
|
||
"``[^5]`` will match any character except ``'5'``, and ``[^^]`` will match "
|
||
"any character except ``'^'``. ``^`` has no special meaning if it's not the "
|
||
"first character in the set."
|
||
msgstr ""
|
||
"Les caractères qui ne sont pas dans un intervalle peuvent être trouvés avec "
|
||
"l'ensemble complémentaire (:dfn:`complementing`). Si le premier caractère "
|
||
"de l'ensemble est ``'^'``, tous les caractères qui *ne sont pas* dans "
|
||
"l'ensemble seront validés. Par exemple, ``[^5]`` correspondra à tout "
|
||
"caractère autre que ``'5'``, et ``[^^]`` validera n'importe quel caractère "
|
||
"excepté ``'^'``. ``^`` n'a pas de sens particulier s'il n'est pas le "
|
||
"premier caractère de l'ensemble."
|
||
|
||
#: ../Doc/library/re.rst:200
|
||
msgid ""
|
||
"To match a literal ``']'`` inside a set, precede it with a backslash, or "
|
||
"place it at the beginning of the set. For example, both ``[()[\\]{}]`` and "
|
||
"``[]()[{}]`` will both match a parenthesis."
|
||
msgstr ""
|
||
"Pour insérer un ``']'`` littéral dans un ensemble, il faut le précéder d'un "
|
||
"*backslash* ou le placer au début de l'ensemble. Par exemple, ``[()[\\]"
|
||
"{}]`` et ``[]()[{}]`` vont tous deux correspondre à une parenthèse, un "
|
||
"crochet ou une accolade."
|
||
|
||
#: ../Doc/library/re.rst:213
|
||
msgid "``'|'``"
|
||
msgstr "``'|'``"
|
||
|
||
#: ../Doc/library/re.rst:205
|
||
msgid ""
|
||
"``A|B``, where A and B can be arbitrary REs, creates a regular expression "
|
||
"that will match either A or B. An arbitrary number of REs can be separated "
|
||
"by the ``'|'`` in this way. This can be used inside groups (see below) as "
|
||
"well. As the target string is scanned, REs separated by ``'|'`` are tried "
|
||
"from left to right. When one pattern completely matches, that branch is "
|
||
"accepted. This means that once ``A`` matches, ``B`` will not be tested "
|
||
"further, even if it would produce a longer overall match. In other words, "
|
||
"the ``'|'`` operator is never greedy. To match a literal ``'|'``, use ``\\|"
|
||
"``, or enclose it inside a character class, as in ``[|]``."
|
||
msgstr ""
|
||
"``A|B``, où A et B peuvent être deux expressions rationnelles arbitraires, "
|
||
"crée une expression rationnelle qui validera à la fois A et B. Un nombre "
|
||
"arbitraire d'expressions peuvent être séparées de cette façon par des "
|
||
"``'|'``. Cela peut aussi être utilisé au sein de groupes (voir ci-"
|
||
"dessous). Quand une chaîne cible est analysée, les expressions séparées par "
|
||
"``'|'`` sont essayées de la gauche vers la droite. Quand un motif correspond "
|
||
"complètement, cette branche est acceptée. Cela signifie qu'une fois que "
|
||
"``A`` correspond, ``B`` ne sera pas testée plus loin, même si elle pourrait "
|
||
"provoquer une plus ample correspondance. En d'autres termes, l'opérateur "
|
||
"``'|'`` n'est jamais gourmand. Pour valider un ``'|'`` littéral, utilisez ``"
|
||
"\\|``, ou enveloppez-le dans une classe de caractères, comme ``[|]``."
|
||
|
||
#: ../Doc/library/re.rst:220
|
||
msgid "``(...)``"
|
||
msgstr "``(...)``"
|
||
|
||
#: ../Doc/library/re.rst:216
|
||
msgid ""
|
||
"Matches whatever regular expression is inside the parentheses, and indicates "
|
||
"the start and end of a group; the contents of a group can be retrieved after "
|
||
"a match has been performed, and can be matched later in the string with the "
|
||
"``\\number`` special sequence, described below. To match the literals "
|
||
"``'('`` or ``')'``, use ``\\(`` or ``\\)``, or enclose them inside a "
|
||
"character class: ``[(] [)]``."
|
||
msgstr ""
|
||
"Valide n'importe quelle expression rationnelle comprise entre les "
|
||
"parenthèses, et indique le début et la fin d'un groupe ; le contenu d'un "
|
||
"groupe peut être récupéré après qu'une analyse a été effectuée, et peut être "
|
||
"réutilisé plus loin dans la chaîne avec une séquence spéciale ``\\number``, "
|
||
"décrite ci-dessous. Pour écrire des ``'('`` ou ``')'`` littéraux, utilisez "
|
||
"``\\(`` ou ``\\)``, ou enveloppez-les dans une classe de caractères : ``[(] "
|
||
"[)]``."
|
||
|
||
#: ../Doc/library/re.rst:227
|
||
msgid "``(?...)``"
|
||
msgstr "``(?...)``"
|
||
|
||
#: ../Doc/library/re.rst:223
|
||
msgid ""
|
||
"This is an extension notation (a ``'?'`` following a ``'('`` is not "
|
||
"meaningful otherwise). The first character after the ``'?'`` determines "
|
||
"what the meaning and further syntax of the construct is. Extensions usually "
|
||
"do not create a new group; ``(?P<name>...)`` is the only exception to this "
|
||
"rule. Following are the currently supported extensions."
|
||
msgstr ""
|
||
"Il s'agit d'une notation pour les extensions (un ``'?'`` suivant une ``'('`` "
|
||
"n'a pas de sens autrement). Le premier caractère après le ``'?'`` détermine "
|
||
"quel sens donner à l'expression. Les extensions ne créent généralement pas "
|
||
"de nouveaux groupes ; ``(?P<name>...)`` est la seule exception à la règle. "
|
||
"Retrouvez ci-dessous la liste des extensions actuellement supportées."
|
||
|
||
#: ../Doc/library/re.rst:240
|
||
msgid "``(?aiLmsux)``"
|
||
msgstr "``(?aiLmsux)``"
|
||
|
||
#: ../Doc/library/re.rst:230
|
||
msgid ""
|
||
"(One or more letters from the set ``'a'``, ``'i'``, ``'L'``, ``'m'``, "
|
||
"``'s'``, ``'u'``, ``'x'``.) The group matches the empty string; the letters "
|
||
"set the corresponding flags: :const:`re.A` (ASCII-only matching), :const:`re."
|
||
"I` (ignore case), :const:`re.L` (locale dependent), :const:`re.M` (multi-"
|
||
"line), :const:`re.S` (dot matches all), and :const:`re.X` (verbose), for the "
|
||
"entire regular expression. (The flags are described in :ref:`contents-of-"
|
||
"module-re`.) This is useful if you wish to include the flags as part of the "
|
||
"regular expression, instead of passing a *flag* argument to the :func:`re."
|
||
"compile` function. Flags should be used first in the expression string."
|
||
msgstr ""
|
||
"(Une lettre ou plus de l'ensemble ``'a'``, ``'i'``, ``'L'``, ``'m'``, "
|
||
"``'s'``, ``'u'``, ``'x'``.) Le groupe valide la chaîne vide ; les lettres "
|
||
"activent les modes correspondant : :const:`re.A` (validation *ASCII* "
|
||
"seulement), :const:`re.I` (ignorer la casse)`, :const:`re.L` (dépendant de "
|
||
"la locale), :const:`re.M` (multi-ligne), :const:`re.S` (les points "
|
||
"correspondent à tous les caractères) et :const:`re.X` (verbeux), pour "
|
||
"l'ensemble de l'expression rationnelle. (Les options dans décrites dans la "
|
||
"section :ref:`contents-of-module-re`.) C'est utile si vous souhaitez "
|
||
"préciser l'option dans l'expression rationnelle, plutôt qu'en passant un "
|
||
"argument *flag* à la fonction :func:`re.compile`. Les options devraient "
|
||
"être spécifiées en premier dans la chaîne de l'expression."
|
||
|
||
#: ../Doc/library/re.rst:246
|
||
msgid "``(?:...)``"
|
||
msgstr "``(?:...)``"
|
||
|
||
#: ../Doc/library/re.rst:243
|
||
msgid ""
|
||
"A non-capturing version of regular parentheses. Matches whatever regular "
|
||
"expression is inside the parentheses, but the substring matched by the group "
|
||
"*cannot* be retrieved after performing a match or referenced later in the "
|
||
"pattern."
|
||
msgstr ""
|
||
"Une version non capturante des parenthèses habituelles. Valide n'importe "
|
||
"quelle expression rationnelle à l'intérieur des parenthèses, mais la sous-"
|
||
"chaîne correspondant au groupe *ne peut pas* être récupérée après l'analyse "
|
||
"ou être référencée plus loin dans le motif."
|
||
|
||
#: ../Doc/library/re.rst:256
|
||
msgid "``(?imsx-imsx:...)``"
|
||
msgstr "``(?imsx-imsx:...)``"
|
||
|
||
#: ../Doc/library/re.rst:249
|
||
msgid ""
|
||
"(Zero or more letters from the set ``'i'``, ``'m'``, ``'s'``, ``'x'``, "
|
||
"optionally followed by ``'-'`` followed by one or more letters from the same "
|
||
"set.) The letters set or removes the corresponding flags: :const:`re.I` "
|
||
"(ignore case), :const:`re.M` (multi-line), :const:`re.S` (dot matches all), "
|
||
"and :const:`re.X` (verbose), for the part of the expression. (The flags are "
|
||
"described in :ref:`contents-of-module-re`.)"
|
||
msgstr ""
|
||
"(Zéro lettres ou plus de l'ensemble ``'i'``, ``'m'``, ``'s'``, ``'x'``, "
|
||
"optionnellement suivies par ``'-'`` ainsi qu'une ou plusieurs lettres du "
|
||
"même ensemble.) Les lettres activent ou désactivent les options "
|
||
"correspondantes : :const:`re.I` (ignorer la casse), :const:`re.M` (multi-"
|
||
"ligne), :const:`re.S` (les points correspondent à tous les caractères) et :"
|
||
"const:`re.X` (verbeux), pour cette partie de l'expression. (Les options "
|
||
"sont décrites dans la section :ref:`contents-of-module-re`.)"
|
||
|
||
#: ../Doc/library/re.rst:281
|
||
msgid "``(?P<name>...)``"
|
||
msgstr "``(?P<name>...)``"
|
||
|
||
#: ../Doc/library/re.rst:259
|
||
msgid ""
|
||
"Similar to regular parentheses, but the substring matched by the group is "
|
||
"accessible via the symbolic group name *name*. Group names must be valid "
|
||
"Python identifiers, and each group name must be defined only once within a "
|
||
"regular expression. A symbolic group is also a numbered group, just as if "
|
||
"the group were not named."
|
||
msgstr ""
|
||
"Similaires aux parenthèses habituelles, mais la sous-chaîne validée par le "
|
||
"groupe est accessible via le nom *name* du groupe symbolique. Les noms de "
|
||
"groupes doivent être des identifiants Python valides, et chaque nom de "
|
||
"groupe ne doit être défini qu'une seule fois dans une expression "
|
||
"rationnelle. Un groupe symbolique est aussi un groupe numéroté, de la même "
|
||
"manière que si le groupe n'était pas nommé."
|
||
|
||
#: ../Doc/library/re.rst:265
|
||
msgid ""
|
||
"Named groups can be referenced in three contexts. If the pattern is ``(?"
|
||
"P<quote>['\"]).*?(?P=quote)`` (i.e. matching a string quoted with either "
|
||
"single or double quotes):"
|
||
msgstr ""
|
||
"Les groupes nommés peuvent être référencés dans trois contextes. Si le "
|
||
"motif est ``(?P<quote>['\"]).*?(?P=quote)`` (i.e. correspondant à une chaîne "
|
||
"entourée de guillemets simples ou doubles)."
|
||
|
||
#: ../Doc/library/re.rst:270
|
||
msgid "Context of reference to group \"quote\""
|
||
msgstr "Contexte de référence au groupe \"quote\""
|
||
|
||
#: ../Doc/library/re.rst:270
|
||
msgid "Ways to reference it"
|
||
msgstr "Manières de le référencer"
|
||
|
||
#: ../Doc/library/re.rst:272
|
||
msgid "in the same pattern itself"
|
||
msgstr "lui-même dans le même motif"
|
||
|
||
#: ../Doc/library/re.rst:272
|
||
msgid "``(?P=quote)`` (as shown)"
|
||
msgstr "``(?P=quote)`` (comme vu)"
|
||
|
||
#: ../Doc/library/re.rst:273 ../Doc/library/re.rst:280
|
||
msgid "``\\1``"
|
||
msgstr "``\\1``"
|
||
|
||
#: ../Doc/library/re.rst:275
|
||
msgid "when processing match object ``m``"
|
||
msgstr "en analysant l'objet résultat ``m``"
|
||
|
||
#: ../Doc/library/re.rst:275
|
||
msgid "``m.group('quote')``"
|
||
msgstr "``m.group('quote')``"
|
||
|
||
#: ../Doc/library/re.rst:276
|
||
msgid "``m.end('quote')`` (etc.)"
|
||
msgstr "``m.end('quote')`` (etc.)"
|
||
|
||
#: ../Doc/library/re.rst:278
|
||
msgid "in a string passed to the ``repl`` argument of ``re.sub()``"
|
||
msgstr "dans une chaîne passée à l'argument ``repl`` de ``re.sub()``"
|
||
|
||
#: ../Doc/library/re.rst:278
|
||
msgid "``\\g<quote>``"
|
||
msgstr "``\\g<quote>``"
|
||
|
||
#: ../Doc/library/re.rst:279
|
||
msgid "``\\g<1>``"
|
||
msgstr "``\\g<1>``"
|
||
|
||
#: ../Doc/library/re.rst:285
|
||
msgid "``(?P=name)``"
|
||
msgstr "``(?P=name)``"
|
||
|
||
#: ../Doc/library/re.rst:284
|
||
msgid ""
|
||
"A backreference to a named group; it matches whatever text was matched by "
|
||
"the earlier group named *name*."
|
||
msgstr ""
|
||
"Une référence arrière à un groupe nommé ; elle correspond à n'importe quel "
|
||
"texte validé plus tôt par le groupe nommé *name*."
|
||
|
||
#: ../Doc/library/re.rst:288
|
||
msgid "``(?#...)``"
|
||
msgstr "``(?#...)``"
|
||
|
||
#: ../Doc/library/re.rst:288
|
||
msgid "A comment; the contents of the parentheses are simply ignored."
|
||
msgstr "Un commentaire ; le contenu des parenthèses est simplement ignoré."
|
||
|
||
#: ../Doc/library/re.rst:293
|
||
msgid "``(?=...)``"
|
||
msgstr "``(?=...)``"
|
||
|
||
#: ../Doc/library/re.rst:291
|
||
msgid ""
|
||
"Matches if ``...`` matches next, but doesn't consume any of the string. "
|
||
"This is called a lookahead assertion. For example, ``Isaac (?=Asimov)`` "
|
||
"will match ``'Isaac '`` only if it's followed by ``'Asimov'``."
|
||
msgstr ""
|
||
"Valide si ``...`` valide la suite, mais ne consomme rien de la chaîne. On "
|
||
"appelle cela une assertion *lookahead*. Par exemple, ``Isaac (?=Asimov)`` "
|
||
"correspondra à la chaîne ``'Isaac'`` seulement si elle est suivie par "
|
||
"``'Asimov'``."
|
||
|
||
#: ../Doc/library/re.rst:298
|
||
msgid "``(?!...)``"
|
||
msgstr "``(?!...)``"
|
||
|
||
#: ../Doc/library/re.rst:296
|
||
msgid ""
|
||
"Matches if ``...`` doesn't match next. This is a negative lookahead "
|
||
"assertion. For example, ``Isaac (?!Asimov)`` will match ``'Isaac '`` only if "
|
||
"it's *not* followed by ``'Asimov'``."
|
||
msgstr ""
|
||
"Valide si ``...`` ne valide pas la suite. C'est une assertion *lookahead* "
|
||
"négative. Par exemple, ``Isaac (?!Asimov)`` correspondra à la chaîne "
|
||
"``'Isaac'`` seulement si elle *n'est pas* suivie par ``'Asimov'``."
|
||
|
||
#: ../Doc/library/re.rst:323
|
||
msgid "``(?<=...)``"
|
||
msgstr "``(?<=...)``"
|
||
|
||
#: ../Doc/library/re.rst:301
|
||
msgid ""
|
||
"Matches if the current position in the string is preceded by a match for "
|
||
"``...`` that ends at the current position. This is called a :dfn:`positive "
|
||
"lookbehind assertion`. ``(?<=abc)def`` will find a match in ``abcdef``, "
|
||
"since the lookbehind will back up 3 characters and check if the contained "
|
||
"pattern matches. The contained pattern must only match strings of some fixed "
|
||
"length, meaning that ``abc`` or ``a|b`` are allowed, but ``a*`` and ``a{3,4}"
|
||
"`` are not. Note that patterns which start with positive lookbehind "
|
||
"assertions will not match at the beginning of the string being searched; you "
|
||
"will most likely want to use the :func:`search` function rather than the :"
|
||
"func:`match` function:"
|
||
msgstr ""
|
||
"Valide si la position courante dans la chaîne est précédée par une "
|
||
"correspondance sur ``...`` qui se termine à la position courante. On "
|
||
"appelle cela une :dfn:`positive lookbehind assertion`. ``(?<=abc)def`` "
|
||
"cherchera une correspondance dans ``abcdef``, puisque le *lookbehind** "
|
||
"mettra de côté 3 caractères et vérifiera que le motif contenu correspond. "
|
||
"Le motif ne devra correspondre qu'à des chaînes de taille fixe, cela veut "
|
||
"dire que ``abc`` ou ``a|b` sont autorisées, mais pas ``a*`` ou ``a{3,4}``. "
|
||
"Notez que les motifs qui commencent par des assertions *lookbehind* "
|
||
"positives ne peuvent pas correspondre au début de la chaîne analysée ; vous "
|
||
"préférerez sûrement utiliser la fonction :func:`search` plutôt que la "
|
||
"fonction :func:`match` :"
|
||
|
||
#: ../Doc/library/re.rst:316
|
||
msgid "This example looks for a word following a hyphen:"
|
||
msgstr "Cet exemple recherche un mot suivi d'un trait d'union :"
|
||
|
||
#: ../Doc/library/re.rst:322
|
||
msgid "Added support for group references of fixed length."
|
||
msgstr "Ajout du support des références aux groupes de taille fixe."
|
||
|
||
#: ../Doc/library/re.rst:330
|
||
msgid "``(?<!...)``"
|
||
msgstr "``(?<!...)``"
|
||
|
||
#: ../Doc/library/re.rst:326
|
||
msgid ""
|
||
"Matches if the current position in the string is not preceded by a match for "
|
||
"``...``. This is called a :dfn:`negative lookbehind assertion`. Similar to "
|
||
"positive lookbehind assertions, the contained pattern must only match "
|
||
"strings of some fixed length. Patterns which start with negative lookbehind "
|
||
"assertions may match at the beginning of the string being searched."
|
||
msgstr ""
|
||
"Valide si la position courante dans la chaîne n'est pas précédée par une "
|
||
"correspondance sur ``...``. On appelle cela une :dfn:`negative lookbehind "
|
||
"assertion`. À la manière des assertions *lookbehind* positives, le motif "
|
||
"contenu ne peut que correspondre à des chaînes de taille fixe. Les motifs "
|
||
"débutant par une assertion *lookbehind* négative peuvent correspondre au "
|
||
"début de la chaîne analysée."
|
||
|
||
#: ../Doc/library/re.rst:339
|
||
msgid "``(?(id/name)yes-pattern|no-pattern)``"
|
||
msgstr "``(?(id/name)yes-pattern|no-pattern)``"
|
||
|
||
#: ../Doc/library/re.rst:333
|
||
msgid ""
|
||
"Will try to match with ``yes-pattern`` if the group with given *id* or "
|
||
"*name* exists, and with ``no-pattern`` if it doesn't. ``no-pattern`` is "
|
||
"optional and can be omitted. For example, ``(<)?(\\w+@\\w+(?:\\.\\w+)+)(?"
|
||
"(1)>|$)`` is a poor email matching pattern, which will match with "
|
||
"``'<user@host.com>'`` as well as ``'user@host.com'``, but not with "
|
||
"``'<user@host.com'`` nor ``'user@host.com>'``."
|
||
msgstr ""
|
||
"Essaiera de faire la correspondance avec ``yes-pattern`` si le groupe "
|
||
"indiqué par *id* ou *name* existe, et avec ``no-pattern`` s'il n'existe pas. "
|
||
"``no-pattern`` est optionnel et peut être omis. Par exemple, ``(<)?(\\w+@\\w"
|
||
"+(?:\\.\\w+)+)(?(1)>|$)`` est un motif simpliste pour identifier une adresse "
|
||
"courriel, qui validera ``'<user@host.com>'`` ainsi que ``'user@host.com'`` "
|
||
"mais pas ``'<user@host.com'`` ni ``'user@host.com>'``."
|
||
|
||
#: ../Doc/library/re.rst:341
|
||
msgid ""
|
||
"The special sequences consist of ``'\\'`` and a character from the list "
|
||
"below. If the ordinary character is not an ASCII digit or an ASCII letter, "
|
||
"then the resulting RE will match the second character. For example, ``\\$`` "
|
||
"matches the character ``'$'``."
|
||
msgstr ""
|
||
"Les séquences spéciales sont composées de ``'\\'`` et d'un caractère de la "
|
||
"liste qui suit. Si le caractère ordinaire n'est pas un chiffre *ASCII* ou "
|
||
"une lettre *ASCII*, alors l'expression rationnelle résultante validera le "
|
||
"second caractère de la séquence. Par exemple, ``\\$`` correspond au "
|
||
"caractère ``'$'``."
|
||
|
||
#: ../Doc/library/re.rst:354
|
||
msgid "``\\number``"
|
||
msgstr "``\\number``"
|
||
|
||
#: ../Doc/library/re.rst:347
|
||
msgid ""
|
||
"Matches the contents of the group of the same number. Groups are numbered "
|
||
"starting from 1. For example, ``(.+) \\1`` matches ``'the the'`` or ``'55 "
|
||
"55'``, but not ``'thethe'`` (note the space after the group). This special "
|
||
"sequence can only be used to match one of the first 99 groups. If the first "
|
||
"digit of *number* is 0, or *number* is 3 octal digits long, it will not be "
|
||
"interpreted as a group match, but as the character with octal value "
|
||
"*number*. Inside the ``'['`` and ``']'`` of a character class, all numeric "
|
||
"escapes are treated as characters."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:357
|
||
msgid "``\\A``"
|
||
msgstr "``\\A``"
|
||
|
||
#: ../Doc/library/re.rst:357
|
||
msgid "Matches only at the start of the string."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:372
|
||
msgid "``\\b``"
|
||
msgstr "``\\b``"
|
||
|
||
#: ../Doc/library/re.rst:360
|
||
msgid ""
|
||
"Matches the empty string, but only at the beginning or end of a word. A word "
|
||
"is defined as a sequence of Unicode alphanumeric or underscore characters, "
|
||
"so the end of a word is indicated by whitespace or a non-alphanumeric, non-"
|
||
"underscore Unicode character. Note that formally, ``\\b`` is defined as the "
|
||
"boundary between a ``\\w`` and a ``\\W`` character (or vice versa), or "
|
||
"between ``\\w`` and the beginning/end of the string. This means that "
|
||
"``r'\\bfoo\\b'`` matches ``'foo'``, ``'foo.'``, ``'(foo)'``, ``'bar foo "
|
||
"baz'`` but not ``'foobar'`` or ``'foo3'``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:369
|
||
msgid ""
|
||
"By default Unicode alphanumerics are the ones used, but this can be changed "
|
||
"by using the :const:`ASCII` flag. Inside a character range, ``\\b`` "
|
||
"represents the backspace character, for compatibility with Python's string "
|
||
"literals."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:380
|
||
msgid "``\\B``"
|
||
msgstr "``\\B``"
|
||
|
||
#: ../Doc/library/re.rst:375
|
||
msgid ""
|
||
"Matches the empty string, but only when it is *not* at the beginning or end "
|
||
"of a word. This means that ``r'py\\B'`` matches ``'python'``, ``'py3'``, "
|
||
"``'py2'``, but not ``'py'``, ``'py.'``, or ``'py!'``. ``\\B`` is just the "
|
||
"opposite of ``\\b``, so word characters are Unicode alphanumerics or the "
|
||
"underscore, although this can be changed by using the :const:`ASCII` flag."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:391
|
||
msgid "``\\d``"
|
||
msgstr "``\\d``"
|
||
|
||
#: ../Doc/library/re.rst:388 ../Doc/library/re.rst:408
|
||
#: ../Doc/library/re.rst:427
|
||
msgid "For Unicode (str) patterns:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:384
|
||
msgid ""
|
||
"Matches any Unicode decimal digit (that is, any character in Unicode "
|
||
"character category [Nd]). This includes ``[0-9]``, and also many other "
|
||
"digit characters. If the :const:`ASCII` flag is used only ``[0-9]`` is "
|
||
"matched (but the flag affects the entire regular expression, so in such "
|
||
"cases using an explicit ``[0-9]`` may be a better choice)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:391 ../Doc/library/re.rst:412
|
||
#: ../Doc/library/re.rst:431
|
||
msgid "For 8-bit (bytes) patterns:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:391
|
||
msgid "Matches any decimal digit; this is equivalent to ``[0-9]``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:398
|
||
msgid "``\\D``"
|
||
msgstr "``\\D``"
|
||
|
||
#: ../Doc/library/re.rst:394
|
||
msgid ""
|
||
"Matches any character which is not a Unicode decimal digit. This is the "
|
||
"opposite of ``\\d``. If the :const:`ASCII` flag is used this becomes the "
|
||
"equivalent of ``[^0-9]`` (but the flag affects the entire regular "
|
||
"expression, so in such cases using an explicit ``[^0-9]`` may be a better "
|
||
"choice)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:412
|
||
msgid "``\\s``"
|
||
msgstr "``\\s``"
|
||
|
||
#: ../Doc/library/re.rst:402
|
||
msgid ""
|
||
"Matches Unicode whitespace characters (which includes ``[ \\t\\n\\r\\f"
|
||
"\\v]``, and also many other characters, for example the non-breaking spaces "
|
||
"mandated by typography rules in many languages). If the :const:`ASCII` flag "
|
||
"is used, only ``[ \\t\\n\\r\\f\\v]`` is matched (but the flag affects the "
|
||
"entire regular expression, so in such cases using an explicit ``[ \\t\\n\\r"
|
||
"\\f\\v]`` may be a better choice)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:411
|
||
msgid ""
|
||
"Matches characters considered whitespace in the ASCII character set; this is "
|
||
"equivalent to ``[ \\t\\n\\r\\f\\v]``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:419
|
||
msgid "``\\S``"
|
||
msgstr "``\\S``"
|
||
|
||
#: ../Doc/library/re.rst:415
|
||
msgid ""
|
||
"Matches any character which is not a Unicode whitespace character. This is "
|
||
"the opposite of ``\\s``. If the :const:`ASCII` flag is used this becomes the "
|
||
"equivalent of ``[^ \\t\\n\\r\\f\\v]`` (but the flag affects the entire "
|
||
"regular expression, so in such cases using an explicit ``[^ \\t\\n\\r\\f"
|
||
"\\v]`` may be a better choice)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:431
|
||
msgid "``\\w``"
|
||
msgstr "``\\w``"
|
||
|
||
#: ../Doc/library/re.rst:423
|
||
msgid ""
|
||
"Matches Unicode word characters; this includes most characters that can be "
|
||
"part of a word in any language, as well as numbers and the underscore. If "
|
||
"the :const:`ASCII` flag is used, only ``[a-zA-Z0-9_]`` is matched (but the "
|
||
"flag affects the entire regular expression, so in such cases using an "
|
||
"explicit ``[a-zA-Z0-9_]`` may be a better choice)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:430
|
||
msgid ""
|
||
"Matches characters considered alphanumeric in the ASCII character set; this "
|
||
"is equivalent to ``[a-zA-Z0-9_]``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:438
|
||
msgid "``\\W``"
|
||
msgstr "``\\W``"
|
||
|
||
#: ../Doc/library/re.rst:434
|
||
msgid ""
|
||
"Matches any character which is not a Unicode word character. This is the "
|
||
"opposite of ``\\w``. If the :const:`ASCII` flag is used this becomes the "
|
||
"equivalent of ``[^a-zA-Z0-9_]`` (but the flag affects the entire regular "
|
||
"expression, so in such cases using an explicit ``[^a-zA-Z0-9_]`` may be a "
|
||
"better choice)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:441
|
||
msgid "``\\Z``"
|
||
msgstr "``\\Z``"
|
||
|
||
#: ../Doc/library/re.rst:441
|
||
msgid "Matches only at the end of the string."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:443
|
||
msgid ""
|
||
"Most of the standard escapes supported by Python string literals are also "
|
||
"accepted by the regular expression parser::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:450
|
||
msgid ""
|
||
"(Note that ``\\b`` is used to represent word boundaries, and means "
|
||
"\"backspace\" only inside character classes.)"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:453
|
||
msgid ""
|
||
"``'\\u'`` and ``'\\U'`` escape sequences are only recognized in Unicode "
|
||
"patterns. In bytes patterns they are not treated specially."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:456
|
||
msgid ""
|
||
"Octal escapes are included in a limited form. If the first digit is a 0, or "
|
||
"if there are three octal digits, it is considered an octal escape. "
|
||
"Otherwise, it is a group reference. As for string literals, octal escapes "
|
||
"are always at most three digits in length."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:461
|
||
msgid "The ``'\\u'`` and ``'\\U'`` escape sequences have been added."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:464
|
||
msgid ""
|
||
"Unknown escapes consisting of ``'\\'`` and an ASCII letter now are errors."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:472
|
||
msgid "Mastering Regular Expressions"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:471
|
||
msgid ""
|
||
"Book on regular expressions by Jeffrey Friedl, published by O'Reilly. The "
|
||
"second edition of the book no longer covers Python at all, but the first "
|
||
"edition covered writing good regular expression patterns in great detail."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:480
|
||
msgid "Module Contents"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:482
|
||
msgid ""
|
||
"The module defines several functions, constants, and an exception. Some of "
|
||
"the functions are simplified versions of the full featured methods for "
|
||
"compiled regular expressions. Most non-trivial applications always use the "
|
||
"compiled form."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:487
|
||
msgid ""
|
||
"Flag constants are now instances of :class:`RegexFlag`, which is a subclass "
|
||
"of :class:`enum.IntFlag`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:493
|
||
msgid ""
|
||
"Compile a regular expression pattern into a regular expression object, which "
|
||
"can be used for matching using its :func:`~regex.match` and :func:`~regex."
|
||
"search` methods, described below."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:497
|
||
msgid ""
|
||
"The expression's behaviour can be modified by specifying a *flags* value. "
|
||
"Values can be any of the following variables, combined using bitwise OR (the "
|
||
"``|`` operator)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:501
|
||
msgid "The sequence ::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:506
|
||
msgid "is equivalent to ::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:510
|
||
msgid ""
|
||
"but using :func:`re.compile` and saving the resulting regular expression "
|
||
"object for reuse is more efficient when the expression will be used several "
|
||
"times in a single program."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:516
|
||
msgid ""
|
||
"The compiled versions of the most recent patterns passed to :func:`re."
|
||
"compile` and the module-level matching functions are cached, so programs "
|
||
"that use only a few regular expressions at a time needn't worry about "
|
||
"compiling regular expressions."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:525
|
||
msgid ""
|
||
"Make ``\\w``, ``\\W``, ``\\b``, ``\\B``, ``\\d``, ``\\D``, ``\\s`` and ``"
|
||
"\\S`` perform ASCII-only matching instead of full Unicode matching. This is "
|
||
"only meaningful for Unicode patterns, and is ignored for byte patterns."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:529
|
||
msgid ""
|
||
"Note that for backward compatibility, the :const:`re.U` flag still exists "
|
||
"(as well as its synonym :const:`re.UNICODE` and its embedded counterpart ``(?"
|
||
"u)``), but these are redundant in Python 3 since matches are Unicode by "
|
||
"default for strings (and Unicode matching isn't allowed for bytes)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:538
|
||
msgid "Display debug information about compiled expression."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:544
|
||
msgid ""
|
||
"Perform case-insensitive matching; expressions like ``[A-Z]`` will match "
|
||
"lowercase letters, too. This is not affected by the current locale and "
|
||
"works for Unicode characters as expected."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:552
|
||
msgid ""
|
||
"Make ``\\w``, ``\\W``, ``\\b``, ``\\B``, ``\\s`` and ``\\S`` dependent on "
|
||
"the current locale. The use of this flag is discouraged as the locale "
|
||
"mechanism is very unreliable, and it only handles one \"culture\" at a time "
|
||
"anyway; you should use Unicode matching instead, which is the default in "
|
||
"Python 3 for Unicode (str) patterns. This flag can be used only with bytes "
|
||
"patterns."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:558
|
||
msgid ""
|
||
":const:`re.LOCALE` can be used only with bytes patterns and is not "
|
||
"compatible with :const:`re.ASCII`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:566
|
||
msgid ""
|
||
"When specified, the pattern character ``'^'`` matches at the beginning of "
|
||
"the string and at the beginning of each line (immediately following each "
|
||
"newline); and the pattern character ``'$'`` matches at the end of the string "
|
||
"and at the end of each line (immediately preceding each newline). By "
|
||
"default, ``'^'`` matches only at the beginning of the string, and ``'$'`` "
|
||
"only at the end of the string and immediately before the newline (if any) at "
|
||
"the end of the string."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:577
|
||
msgid ""
|
||
"Make the ``'.'`` special character match any character at all, including a "
|
||
"newline; without this flag, ``'.'`` will match anything *except* a newline."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:584
|
||
msgid ""
|
||
"This flag allows you to write regular expressions that look nicer and are "
|
||
"more readable by allowing you to visually separate logical sections of the "
|
||
"pattern and add comments. Whitespace within the pattern is ignored, except "
|
||
"when in a character class or when preceded by an unescaped backslash. When a "
|
||
"line contains a ``#`` that is not in a character class and is not preceded "
|
||
"by an unescaped backslash, all characters from the leftmost such ``#`` "
|
||
"through the end of the line are ignored."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:592
|
||
msgid ""
|
||
"This means that the two following regular expression objects that match a "
|
||
"decimal number are functionally equal::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:605
|
||
msgid ""
|
||
"Scan through *string* looking for the first location where the regular "
|
||
"expression *pattern* produces a match, and return a corresponding :ref:"
|
||
"`match object <match-objects>`. Return ``None`` if no position in the "
|
||
"string matches the pattern; note that this is different from finding a zero-"
|
||
"length match at some point in the string."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:614
|
||
msgid ""
|
||
"If zero or more characters at the beginning of *string* match the regular "
|
||
"expression *pattern*, return a corresponding :ref:`match object <match-"
|
||
"objects>`. Return ``None`` if the string does not match the pattern; note "
|
||
"that this is different from a zero-length match."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:619
|
||
msgid ""
|
||
"Note that even in :const:`MULTILINE` mode, :func:`re.match` will only match "
|
||
"at the beginning of the string and not at the beginning of each line."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:622
|
||
msgid ""
|
||
"If you want to locate a match anywhere in *string*, use :func:`search` "
|
||
"instead (see also :ref:`search-vs-match`)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:628
|
||
msgid ""
|
||
"If the whole *string* matches the regular expression *pattern*, return a "
|
||
"corresponding :ref:`match object <match-objects>`. Return ``None`` if the "
|
||
"string does not match the pattern; note that this is different from a zero-"
|
||
"length match."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:638
|
||
msgid ""
|
||
"Split *string* by the occurrences of *pattern*. If capturing parentheses "
|
||
"are used in *pattern*, then the text of all groups in the pattern are also "
|
||
"returned as part of the resulting list. If *maxsplit* is nonzero, at most "
|
||
"*maxsplit* splits occur, and the remainder of the string is returned as the "
|
||
"final element of the list. ::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:653
|
||
msgid ""
|
||
"If there are capturing groups in the separator and it matches at the start "
|
||
"of the string, the result will start with an empty string. The same holds "
|
||
"for the end of the string:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:660
|
||
msgid ""
|
||
"That way, separator components are always found at the same relative indices "
|
||
"within the result list."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:665
|
||
msgid ""
|
||
":func:`split` doesn't currently split a string on an empty pattern match. "
|
||
"For example:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:671
|
||
msgid ""
|
||
"Even though ``'x*'`` also matches 0 'x' before 'a', between 'b' and 'c', and "
|
||
"after 'c', currently these matches are ignored. The correct behavior (i.e. "
|
||
"splitting on empty matches too and returning ``['', 'a', 'b', 'c', '']``) "
|
||
"will be implemented in future versions of Python, but since this is a "
|
||
"backward incompatible change, a :exc:`FutureWarning` will be raised in the "
|
||
"meanwhile."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:678
|
||
msgid ""
|
||
"Patterns that can only match empty strings currently never split the "
|
||
"string. Since this doesn't match the expected behavior, a :exc:`ValueError` "
|
||
"will be raised starting from Python 3.5::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:688 ../Doc/library/re.rst:760
|
||
#: ../Doc/library/re.rst:780
|
||
msgid "Added the optional flags argument."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:691
|
||
msgid ""
|
||
"Splitting on a pattern that could match an empty string now raises a "
|
||
"warning. Patterns that can only match empty strings are now rejected."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:697
|
||
msgid ""
|
||
"Return all non-overlapping matches of *pattern* in *string*, as a list of "
|
||
"strings. The *string* is scanned left-to-right, and matches are returned in "
|
||
"the order found. If one or more groups are present in the pattern, return a "
|
||
"list of groups; this will be a list of tuples if the pattern has more than "
|
||
"one group. Empty matches are included in the result unless they touch the "
|
||
"beginning of another match."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:707
|
||
msgid ""
|
||
"Return an :term:`iterator` yielding :ref:`match objects <match-objects>` "
|
||
"over all non-overlapping matches for the RE *pattern* in *string*. The "
|
||
"*string* is scanned left-to-right, and matches are returned in the order "
|
||
"found. Empty matches are included in the result unless they touch the "
|
||
"beginning of another match."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:716
|
||
msgid ""
|
||
"Return the string obtained by replacing the leftmost non-overlapping "
|
||
"occurrences of *pattern* in *string* by the replacement *repl*. If the "
|
||
"pattern isn't found, *string* is returned unchanged. *repl* can be a string "
|
||
"or a function; if it is a string, any backslash escapes in it are "
|
||
"processed. That is, ``\\n`` is converted to a single newline character, ``"
|
||
"\\r`` is converted to a carriage return, and so forth. Unknown escapes such "
|
||
"as ``\\&`` are left alone. Backreferences, such as ``\\6``, are replaced "
|
||
"with the substring matched by group 6 in the pattern. For example:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:730
|
||
msgid ""
|
||
"If *repl* is a function, it is called for every non-overlapping occurrence "
|
||
"of *pattern*. The function takes a single match object argument, and "
|
||
"returns the replacement string. For example:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:742
|
||
msgid "The pattern may be a string or an RE object."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:744
|
||
msgid ""
|
||
"The optional argument *count* is the maximum number of pattern occurrences "
|
||
"to be replaced; *count* must be a non-negative integer. If omitted or zero, "
|
||
"all occurrences will be replaced. Empty matches for the pattern are replaced "
|
||
"only when not adjacent to a previous match, so ``sub('x*', '-', 'abc')`` "
|
||
"returns ``'-a-b-c-'``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:750
|
||
msgid ""
|
||
"In string-type *repl* arguments, in addition to the character escapes and "
|
||
"backreferences described above, ``\\g<name>`` will use the substring matched "
|
||
"by the group named ``name``, as defined by the ``(?P<name>...)`` syntax. ``"
|
||
"\\g<number>`` uses the corresponding group number; ``\\g<2>`` is therefore "
|
||
"equivalent to ``\\2``, but isn't ambiguous in a replacement such as ``"
|
||
"\\g<2>0``. ``\\20`` would be interpreted as a reference to group 20, not a "
|
||
"reference to group 2 followed by the literal character ``'0'``. The "
|
||
"backreference ``\\g<0>`` substitutes in the entire substring matched by the "
|
||
"RE."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:763 ../Doc/library/re.rst:783
|
||
#: ../Doc/library/re.rst:995
|
||
msgid "Unmatched groups are replaced with an empty string."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:766
|
||
msgid ""
|
||
"Unknown escapes in *pattern* consisting of ``'\\'`` and an ASCII letter now "
|
||
"are errors."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:772
|
||
msgid ""
|
||
"Deprecated since version 3.5, will be removed in version 3.7: Unknown "
|
||
"escapes in repl consisting of '\\' and an ASCII letter now raise a "
|
||
"deprecation warning and will be forbidden in Python 3.7."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:772
|
||
msgid ""
|
||
"Unknown escapes in *repl* consisting of ``'\\'`` and an ASCII letter now "
|
||
"raise a deprecation warning and will be forbidden in Python 3.7."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:777
|
||
msgid ""
|
||
"Perform the same operation as :func:`sub`, but return a tuple ``(new_string, "
|
||
"number_of_subs_made)``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:789
|
||
msgid ""
|
||
"Escape all the characters in *pattern* except ASCII letters, numbers and "
|
||
"``'_'``. This is useful if you want to match an arbitrary literal string "
|
||
"that may have regular expression metacharacters in it. For example::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:804
|
||
msgid "The ``'_'`` character is no longer escaped."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:810
|
||
msgid "Clear the regular expression cache."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:815
|
||
msgid ""
|
||
"Exception raised when a string passed to one of the functions here is not a "
|
||
"valid regular expression (for example, it might contain unmatched "
|
||
"parentheses) or when some other error occurs during compilation or "
|
||
"matching. It is never an error if a string contains no match for a "
|
||
"pattern. The error instance has the following additional attributes:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:823
|
||
msgid "The unformatted error message."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:827
|
||
msgid "The regular expression pattern."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:831
|
||
msgid "The index of *pattern* where compilation failed."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:835
|
||
msgid "The line corresponding to *pos*."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:839
|
||
msgid "The column corresponding to *pos*."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:841
|
||
msgid "Added additional attributes."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:847
|
||
msgid "Regular Expression Objects"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:849
|
||
msgid ""
|
||
"Compiled regular expression objects support the following methods and "
|
||
"attributes:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:854
|
||
msgid ""
|
||
"Scan through *string* looking for the first location where this regular "
|
||
"expression produces a match, and return a corresponding :ref:`match object "
|
||
"<match-objects>`. Return ``None`` if no position in the string matches the "
|
||
"pattern; note that this is different from finding a zero-length match at "
|
||
"some point in the string."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:860
|
||
msgid ""
|
||
"The optional second parameter *pos* gives an index in the string where the "
|
||
"search is to start; it defaults to ``0``. This is not completely equivalent "
|
||
"to slicing the string; the ``'^'`` pattern character matches at the real "
|
||
"beginning of the string and at positions just after a newline, but not "
|
||
"necessarily at the index where the search is to start."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:866
|
||
msgid ""
|
||
"The optional parameter *endpos* limits how far the string will be searched; "
|
||
"it will be as if the string is *endpos* characters long, so only the "
|
||
"characters from *pos* to ``endpos - 1`` will be searched for a match. If "
|
||
"*endpos* is less than *pos*, no match will be found; otherwise, if *rx* is a "
|
||
"compiled regular expression object, ``rx.search(string, 0, 50)`` is "
|
||
"equivalent to ``rx.search(string[:50], 0)``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:881
|
||
msgid ""
|
||
"If zero or more characters at the *beginning* of *string* match this regular "
|
||
"expression, return a corresponding :ref:`match object <match-objects>`. "
|
||
"Return ``None`` if the string does not match the pattern; note that this is "
|
||
"different from a zero-length match."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:886 ../Doc/library/re.rst:904
|
||
msgid ""
|
||
"The optional *pos* and *endpos* parameters have the same meaning as for the :"
|
||
"meth:`~regex.search` method."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:894
|
||
msgid ""
|
||
"If you want to locate a match anywhere in *string*, use :meth:`~regex."
|
||
"search` instead (see also :ref:`search-vs-match`)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:900
|
||
msgid ""
|
||
"If the whole *string* matches this regular expression, return a "
|
||
"corresponding :ref:`match object <match-objects>`. Return ``None`` if the "
|
||
"string does not match the pattern; note that this is different from a zero-"
|
||
"length match."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:918
|
||
msgid "Identical to the :func:`split` function, using the compiled pattern."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:923
|
||
msgid ""
|
||
"Similar to the :func:`findall` function, using the compiled pattern, but "
|
||
"also accepts optional *pos* and *endpos* parameters that limit the search "
|
||
"region like for :meth:`match`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:930
|
||
msgid ""
|
||
"Similar to the :func:`finditer` function, using the compiled pattern, but "
|
||
"also accepts optional *pos* and *endpos* parameters that limit the search "
|
||
"region like for :meth:`match`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:937
|
||
msgid "Identical to the :func:`sub` function, using the compiled pattern."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:942
|
||
msgid "Identical to the :func:`subn` function, using the compiled pattern."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:947
|
||
msgid ""
|
||
"The regex matching flags. This is a combination of the flags given to :func:"
|
||
"`.compile`, any ``(?...)`` inline flags in the pattern, and implicit flags "
|
||
"such as :data:`UNICODE` if the pattern is a Unicode string."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:954
|
||
msgid "The number of capturing groups in the pattern."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:959
|
||
msgid ""
|
||
"A dictionary mapping any symbolic group names defined by ``(?P<id>)`` to "
|
||
"group numbers. The dictionary is empty if no symbolic groups were used in "
|
||
"the pattern."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:966
|
||
msgid "The pattern string from which the RE object was compiled."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:972
|
||
msgid "Match Objects"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:974
|
||
msgid ""
|
||
"Match objects always have a boolean value of ``True``. Since :meth:`~regex."
|
||
"match` and :meth:`~regex.search` return ``None`` when there is no match, you "
|
||
"can test whether there was a match with a simple ``if`` statement::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:983
|
||
msgid "Match objects support the following methods and attributes:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:988
|
||
msgid ""
|
||
"Return the string obtained by doing backslash substitution on the template "
|
||
"string *template*, as done by the :meth:`~regex.sub` method. Escapes such as "
|
||
"``\\n`` are converted to the appropriate characters, and numeric "
|
||
"backreferences (``\\1``, ``\\2``) and named backreferences (``\\g<1>``, ``"
|
||
"\\g<name>``) are replaced by the contents of the corresponding group."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1000
|
||
msgid ""
|
||
"Returns one or more subgroups of the match. If there is a single argument, "
|
||
"the result is a single string; if there are multiple arguments, the result "
|
||
"is a tuple with one item per argument. Without arguments, *group1* defaults "
|
||
"to zero (the whole match is returned). If a *groupN* argument is zero, the "
|
||
"corresponding return value is the entire matching string; if it is in the "
|
||
"inclusive range [1..99], it is the string matching the corresponding "
|
||
"parenthesized group. If a group number is negative or larger than the "
|
||
"number of groups defined in the pattern, an :exc:`IndexError` exception is "
|
||
"raised. If a group is contained in a part of the pattern that did not match, "
|
||
"the corresponding result is ``None``. If a group is contained in a part of "
|
||
"the pattern that matched multiple times, the last match is returned."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1022
|
||
msgid ""
|
||
"If the regular expression uses the ``(?P<name>...)`` syntax, the *groupN* "
|
||
"arguments may also be strings identifying groups by their group name. If a "
|
||
"string argument is not used as a group name in the pattern, an :exc:"
|
||
"`IndexError` exception is raised."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1027
|
||
msgid "A moderately complicated example:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1035
|
||
msgid "Named groups can also be referred to by their index:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1042
|
||
msgid "If a group matches multiple times, only the last match is accessible:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1051
|
||
msgid ""
|
||
"This is identical to ``m.group(g)``. This allows easier access to an "
|
||
"individual group from a match:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1067
|
||
msgid ""
|
||
"Return a tuple containing all the subgroups of the match, from 1 up to "
|
||
"however many groups are in the pattern. The *default* argument is used for "
|
||
"groups that did not participate in the match; it defaults to ``None``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1071
|
||
msgid "For example:"
|
||
msgstr "Par exemple : ::"
|
||
|
||
#: ../Doc/library/re.rst:1077
|
||
msgid ""
|
||
"If we make the decimal place and everything after it optional, not all "
|
||
"groups might participate in the match. These groups will default to "
|
||
"``None`` unless the *default* argument is given:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1090
|
||
msgid ""
|
||
"Return a dictionary containing all the *named* subgroups of the match, keyed "
|
||
"by the subgroup name. The *default* argument is used for groups that did "
|
||
"not participate in the match; it defaults to ``None``. For example:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1102
|
||
msgid ""
|
||
"Return the indices of the start and end of the substring matched by *group*; "
|
||
"*group* defaults to zero (meaning the whole matched substring). Return "
|
||
"``-1`` if *group* exists but did not contribute to the match. For a match "
|
||
"object *m*, and a group *g* that did contribute to the match, the substring "
|
||
"matched by group *g* (equivalent to ``m.group(g)``) is ::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1110
|
||
msgid ""
|
||
"Note that ``m.start(group)`` will equal ``m.end(group)`` if *group* matched "
|
||
"a null string. For example, after ``m = re.search('b(c?)', 'cba')``, ``m."
|
||
"start(0)`` is 1, ``m.end(0)`` is 2, ``m.start(1)`` and ``m.end(1)`` are both "
|
||
"2, and ``m.start(2)`` raises an :exc:`IndexError` exception."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1115
|
||
msgid "An example that will remove *remove_this* from email addresses:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1125
|
||
msgid ""
|
||
"For a match *m*, return the 2-tuple ``(m.start(group), m.end(group))``. Note "
|
||
"that if *group* did not contribute to the match, this is ``(-1, -1)``. "
|
||
"*group* defaults to zero, the entire match."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1132
|
||
msgid ""
|
||
"The value of *pos* which was passed to the :meth:`~regex.search` or :meth:"
|
||
"`~regex.match` method of a :ref:`regex object <re-objects>`. This is the "
|
||
"index into the string at which the RE engine started looking for a match."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1139
|
||
msgid ""
|
||
"The value of *endpos* which was passed to the :meth:`~regex.search` or :meth:"
|
||
"`~regex.match` method of a :ref:`regex object <re-objects>`. This is the "
|
||
"index into the string beyond which the RE engine will not go."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1146
|
||
msgid ""
|
||
"The integer index of the last matched capturing group, or ``None`` if no "
|
||
"group was matched at all. For example, the expressions ``(a)b``, ``((a)"
|
||
"(b))``, and ``((ab))`` will have ``lastindex == 1`` if applied to the string "
|
||
"``'ab'``, while the expression ``(a)(b)`` will have ``lastindex == 2``, if "
|
||
"applied to the same string."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1155
|
||
msgid ""
|
||
"The name of the last matched capturing group, or ``None`` if the group "
|
||
"didn't have a name, or if no group was matched at all."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1161
|
||
msgid ""
|
||
"The regular expression object whose :meth:`~regex.match` or :meth:`~regex."
|
||
"search` method produced this match instance."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1167
|
||
msgid "The string passed to :meth:`~regex.match` or :meth:`~regex.search`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1173
|
||
msgid "Regular Expression Examples"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1177
|
||
msgid "Checking for a Pair"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1179
|
||
msgid ""
|
||
"In this example, we'll use the following helper function to display match "
|
||
"objects a little more gracefully:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1189
|
||
msgid ""
|
||
"Suppose you are writing a poker program where a player's hand is represented "
|
||
"as a 5-character string with each character representing a card, \"a\" for "
|
||
"ace, \"k\" for king, \"q\" for queen, \"j\" for jack, \"t\" for 10, and "
|
||
"\"2\" through \"9\" representing the card with that value."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1194
|
||
msgid "To see if a given string is a valid hand, one could do the following:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1204
|
||
msgid ""
|
||
"That last hand, ``\"727ak\"``, contained a pair, or two of the same valued "
|
||
"cards. To match this with a regular expression, one could use backreferences "
|
||
"as such:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1214
|
||
msgid ""
|
||
"To find out what card the pair consists of, one could use the :meth:`~match."
|
||
"group` method of the match object in the following manner:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1234
|
||
msgid "Simulating scanf()"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1238
|
||
msgid ""
|
||
"Python does not currently have an equivalent to :c:func:`scanf`. Regular "
|
||
"expressions are generally more powerful, though also more verbose, than :c:"
|
||
"func:`scanf` format strings. The table below offers some more-or-less "
|
||
"equivalent mappings between :c:func:`scanf` format tokens and regular "
|
||
"expressions."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1245
|
||
msgid ":c:func:`scanf` Token"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1245
|
||
msgid "Regular Expression"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1247
|
||
msgid "``%c``"
|
||
msgstr "``%c``"
|
||
|
||
#: ../Doc/library/re.rst:1247
|
||
msgid "``.``"
|
||
msgstr "``.``"
|
||
|
||
#: ../Doc/library/re.rst:1249
|
||
msgid "``%5c``"
|
||
msgstr "``%5c``"
|
||
|
||
#: ../Doc/library/re.rst:1249
|
||
msgid "``.{5}``"
|
||
msgstr "``.{5}``"
|
||
|
||
#: ../Doc/library/re.rst:1251
|
||
msgid "``%d``"
|
||
msgstr "``%d``"
|
||
|
||
#: ../Doc/library/re.rst:1251
|
||
msgid "``[-+]?\\d+``"
|
||
msgstr "``[-+]?\\d+``"
|
||
|
||
#: ../Doc/library/re.rst:1253
|
||
msgid "``%e``, ``%E``, ``%f``, ``%g``"
|
||
msgstr "``%e``, ``%E``, ``%f``, ``%g``"
|
||
|
||
#: ../Doc/library/re.rst:1253
|
||
msgid "``[-+]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?``"
|
||
msgstr "``[-+]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?``"
|
||
|
||
#: ../Doc/library/re.rst:1255
|
||
msgid "``%i``"
|
||
msgstr "``%i``"
|
||
|
||
#: ../Doc/library/re.rst:1255
|
||
msgid "``[-+]?(0[xX][\\dA-Fa-f]+|0[0-7]*|\\d+)``"
|
||
msgstr "``[-+]?(0[xX][\\dA-Fa-f]+|0[0-7]*|\\d+)``"
|
||
|
||
#: ../Doc/library/re.rst:1257
|
||
msgid "``%o``"
|
||
msgstr "``%o``"
|
||
|
||
#: ../Doc/library/re.rst:1257
|
||
msgid "``[-+]?[0-7]+``"
|
||
msgstr "``[-+]?[0-7]+``"
|
||
|
||
#: ../Doc/library/re.rst:1259
|
||
msgid "``%s``"
|
||
msgstr "``%s``"
|
||
|
||
#: ../Doc/library/re.rst:1259
|
||
msgid "``\\S+``"
|
||
msgstr "``\\S+``"
|
||
|
||
#: ../Doc/library/re.rst:1261
|
||
msgid "``%u``"
|
||
msgstr "``%u``"
|
||
|
||
#: ../Doc/library/re.rst:1261
|
||
msgid "``\\d+``"
|
||
msgstr "``\\d+``"
|
||
|
||
#: ../Doc/library/re.rst:1263
|
||
msgid "``%x``, ``%X``"
|
||
msgstr "``%x``, ``%X``"
|
||
|
||
#: ../Doc/library/re.rst:1263
|
||
msgid "``[-+]?(0[xX])?[\\dA-Fa-f]+``"
|
||
msgstr "``[-+]?(0[xX])?[\\dA-Fa-f]+``"
|
||
|
||
#: ../Doc/library/re.rst:1266
|
||
msgid "To extract the filename and numbers from a string like ::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1270
|
||
msgid "you would use a :c:func:`scanf` format like ::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1274
|
||
msgid "The equivalent regular expression would be ::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1282
|
||
msgid "search() vs. match()"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1286
|
||
msgid ""
|
||
"Python offers two different primitive operations based on regular "
|
||
"expressions: :func:`re.match` checks for a match only at the beginning of "
|
||
"the string, while :func:`re.search` checks for a match anywhere in the "
|
||
"string (this is what Perl does by default)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1291
|
||
msgid "For example::"
|
||
msgstr "Par exemple : ::"
|
||
|
||
#: ../Doc/library/re.rst:1297
|
||
msgid ""
|
||
"Regular expressions beginning with ``'^'`` can be used with :func:`search` "
|
||
"to restrict the match at the beginning of the string::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1305
|
||
msgid ""
|
||
"Note however that in :const:`MULTILINE` mode :func:`match` only matches at "
|
||
"the beginning of the string, whereas using :func:`search` with a regular "
|
||
"expression beginning with ``'^'`` will match at the beginning of each line."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1315
|
||
msgid "Making a Phonebook"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1317
|
||
msgid ""
|
||
":func:`split` splits a string into a list delimited by the passed pattern. "
|
||
"The method is invaluable for converting textual data into data structures "
|
||
"that can be easily read and modified by Python as demonstrated in the "
|
||
"following example that creates a phonebook."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1322
|
||
msgid ""
|
||
"First, here is the input. Normally it may come from a file, here we are "
|
||
"using triple-quoted string syntax:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1333
|
||
msgid ""
|
||
"The entries are separated by one or more newlines. Now we convert the string "
|
||
"into a list with each nonempty line having its own entry:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1346
|
||
msgid ""
|
||
"Finally, split each entry into a list with first name, last name, telephone "
|
||
"number, and address. We use the ``maxsplit`` parameter of :func:`split` "
|
||
"because the address has spaces, our splitting pattern, in it:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1359
|
||
msgid ""
|
||
"The ``:?`` pattern matches the colon after the last name, so that it does "
|
||
"not occur in the result list. With a ``maxsplit`` of ``4``, we could "
|
||
"separate the house number from the street name:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1374
|
||
msgid "Text Munging"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1376
|
||
msgid ""
|
||
":func:`sub` replaces every occurrence of a pattern with a string or the "
|
||
"result of a function. This example demonstrates using :func:`sub` with a "
|
||
"function to \"munge\" text, or randomize the order of all the characters in "
|
||
"each word of a sentence except for the first and last characters::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1393
|
||
msgid "Finding all Adverbs"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1395
|
||
msgid ""
|
||
":func:`findall` matches *all* occurrences of a pattern, not just the first "
|
||
"one as :func:`search` does. For example, if one was a writer and wanted to "
|
||
"find all of the adverbs in some text, he or she might use :func:`findall` in "
|
||
"the following manner:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1406
|
||
msgid "Finding all Adverbs and their Positions"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1408
|
||
msgid ""
|
||
"If one wants more information about all matches of a pattern than the "
|
||
"matched text, :func:`finditer` is useful as it provides :ref:`match objects "
|
||
"<match-objects>` instead of strings. Continuing with the previous example, "
|
||
"if one was a writer who wanted to find all of the adverbs *and their "
|
||
"positions* in some text, he or she would use :func:`finditer` in the "
|
||
"following manner:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1422
|
||
msgid "Raw String Notation"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1424
|
||
msgid ""
|
||
"Raw string notation (``r\"text\"``) keeps regular expressions sane. Without "
|
||
"it, every backslash (``'\\'``) in a regular expression would have to be "
|
||
"prefixed with another one to escape it. For example, the two following "
|
||
"lines of code are functionally identical:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1434
|
||
msgid ""
|
||
"When one wants to match a literal backslash, it must be escaped in the "
|
||
"regular expression. With raw string notation, this means ``r\"\\\\\"``. "
|
||
"Without raw string notation, one must use ``\"\\\\\\\\\"``, making the "
|
||
"following lines of code functionally identical:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1446
|
||
msgid "Writing a Tokenizer"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1448
|
||
msgid ""
|
||
"A `tokenizer or scanner <https://en.wikipedia.org/wiki/Lexical_analysis>`_ "
|
||
"analyzes a string to categorize groups of characters. This is a useful "
|
||
"first step in writing a compiler or interpreter."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1452
|
||
msgid ""
|
||
"The text categories are specified with regular expressions. The technique "
|
||
"is to combine those into a single master regular expression and to loop over "
|
||
"successive matches::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/re.rst:1502
|
||
msgid "The tokenizer produces the following output::"
|
||
msgstr ""
|