python-docs-fr/library/re.po

# 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-04-02 22:11+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: \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 ""

#: ../Doc/library/re.rst:10
msgid "**Source code:** :source:`Lib/re.py`"
msgstr ""

#: ../Doc/library/re.rst:14
msgid ""
"This module provides regular expression matching operations similar to those "
"found in Perl."
msgstr ""

#: ../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 ""

#: ../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 ""

#: ../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 ""

#: ../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 ""

#: ../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 ""

#: ../Doc/library/re.rst:55
msgid "Regular Expression Syntax"
msgstr ""

#: ../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 ""

#: ../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 ""

#: ../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 ""

#: ../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 ""

#: ../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 ""

#: ../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 ""

#: ../Doc/library/re.rst:95
msgid "The special characters are:"
msgstr ""

#: ../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 ""

#: ../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 ""

#: ../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 ""

#: ../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 ""

#: ../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 ""

#: ../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 ""

#: ../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 ""

#: ../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 ""

#: ../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 ""

#: ../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 ""

#: ../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 ""

#: ../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 ""

#: ../Doc/library/re.rst:202
msgid "``[]``"
msgstr "``[]``"

#: ../Doc/library/re.rst:173
msgid "Used to indicate a set of characters.  In a set:"
msgstr ""

#: ../Doc/library/re.rst:175
msgid ""
"Characters can be listed individually, e.g. ``[amk]`` will match ``'a'``, "
"``'m'``, or ``'k'``."
msgstr ""

#: ../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 ""

#: ../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 ""

#: ../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 ""

#: ../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 ""

#: ../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 ""

#: ../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 ""

#: ../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 ""

#: ../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 ""

#: ../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 ""

#: ../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 ""

#: ../Doc/library/re.rst:256
msgid "``(?imsx-imsx:...)``"
msgstr ""

#: ../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 ""

#: ../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 ""

#: ../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 ""

#: ../Doc/library/re.rst:270
msgid "Context of reference to group \"quote\""
msgstr ""

#: ../Doc/library/re.rst:270
msgid "Ways to reference it"
msgstr ""

#: ../Doc/library/re.rst:272
msgid "in the same pattern itself"
msgstr ""

#: ../Doc/library/re.rst:272
msgid "``(?P=quote)`` (as shown)"
msgstr ""

#: ../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 ""

#: ../Doc/library/re.rst:275
msgid "``m.group('quote')``"
msgstr "``m.group('quote')``"

#: ../Doc/library/re.rst:276
msgid "``m.end('quote')`` (etc.)"
msgstr ""

#: ../Doc/library/re.rst:278
msgid "in a string passed to the ``repl`` argument of ``re.sub()``"
msgstr ""

#: ../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 ""

#: ../Doc/library/re.rst:288
msgid "``(?#...)``"
msgstr "``(?#...)``"

#: ../Doc/library/re.rst:288
msgid "A comment; the contents of the parentheses are simply ignored."
msgstr ""

#: ../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 ""

#: ../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 ""

#: ../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 ""

#: ../Doc/library/re.rst:316
msgid "This example looks for a word following a hyphen:"
msgstr ""

#: ../Doc/library/re.rst:322
msgid "Added support for group references of fixed length."
msgstr ""

#: ../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 ""

#: ../Doc/library/re.rst:339
msgid "``(?(id/name)yes-pattern|no-pattern)``"
msgstr ""

#: ../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 ""

#: ../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 ""

#: ../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:984
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."
msgstr ""

#: ../Doc/library/re.rst:793
msgid "The ``'_'`` character is no longer escaped."
msgstr ""

#: ../Doc/library/re.rst:799
msgid "Clear the regular expression cache."
msgstr ""

#: ../Doc/library/re.rst:804
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:812
msgid "The unformatted error message."
msgstr ""

#: ../Doc/library/re.rst:816
msgid "The regular expression pattern."
msgstr ""

#: ../Doc/library/re.rst:820
msgid "The index of *pattern* where compilation failed."
msgstr ""

#: ../Doc/library/re.rst:824
msgid "The line corresponding to *pos*."
msgstr ""

#: ../Doc/library/re.rst:828
msgid "The column corresponding to *pos*."
msgstr ""

#: ../Doc/library/re.rst:830
msgid "Added additional attributes."
msgstr ""

#: ../Doc/library/re.rst:836
msgid "Regular Expression Objects"
msgstr ""

#: ../Doc/library/re.rst:838
msgid ""
"Compiled regular expression objects support the following methods and "
"attributes:"
msgstr ""

#: ../Doc/library/re.rst:843
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:849
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:855
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:870
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:875 ../Doc/library/re.rst:893
msgid ""
"The optional *pos* and *endpos* parameters have the same meaning as for the :"
"meth:`~regex.search` method."
msgstr ""

#: ../Doc/library/re.rst:883
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:889
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:907
msgid "Identical to the :func:`split` function, using the compiled pattern."
msgstr ""

#: ../Doc/library/re.rst:912
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:919
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:926
msgid "Identical to the :func:`sub` function, using the compiled pattern."
msgstr ""

#: ../Doc/library/re.rst:931
msgid "Identical to the :func:`subn` function, using the compiled pattern."
msgstr ""

#: ../Doc/library/re.rst:936
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:943
msgid "The number of capturing groups in the pattern."
msgstr ""

#: ../Doc/library/re.rst:948
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:955
msgid "The pattern string from which the RE object was compiled."
msgstr ""

#: ../Doc/library/re.rst:961
msgid "Match Objects"
msgstr ""

#: ../Doc/library/re.rst:963
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:972
msgid "Match objects support the following methods and attributes:"
msgstr ""

#: ../Doc/library/re.rst:977
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:989
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:1011
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:1016
msgid "A moderately complicated example:"
msgstr ""

#: ../Doc/library/re.rst:1024
msgid "Named groups can also be referred to by their index:"
msgstr ""

#: ../Doc/library/re.rst:1031
msgid "If a group matches multiple times, only the last match is accessible:"
msgstr ""

#: ../Doc/library/re.rst:1040
msgid ""
"This is identical to ``m.group(g)``.  This allows easier access to an "
"individual group from a match:"
msgstr ""

#: ../Doc/library/re.rst:1056
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:1060
msgid "For example:"
msgstr "Par exemple : ::"

#: ../Doc/library/re.rst:1066
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:1079
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:1091
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:1099
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:1104
msgid "An example that will remove *remove_this* from email addresses:"
msgstr ""

#: ../Doc/library/re.rst:1114
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:1121
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:1128
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:1135
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:1144
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:1150
msgid ""
"The regular expression object whose :meth:`~regex.match` or :meth:`~regex."
"search` method produced this match instance."
msgstr ""

#: ../Doc/library/re.rst:1156
msgid "The string passed to :meth:`~regex.match` or :meth:`~regex.search`."
msgstr ""

#: ../Doc/library/re.rst:1162
msgid "Regular Expression Examples"
msgstr ""

#: ../Doc/library/re.rst:1166
msgid "Checking for a Pair"
msgstr ""

#: ../Doc/library/re.rst:1168
msgid ""
"In this example, we'll use the following helper function to display match "
"objects a little more gracefully:"
msgstr ""

#: ../Doc/library/re.rst:1178
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:1183
msgid "To see if a given string is a valid hand, one could do the following:"
msgstr ""

#: ../Doc/library/re.rst:1193
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:1203
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:1223
msgid "Simulating scanf()"
msgstr ""

#: ../Doc/library/re.rst:1227
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:1234
msgid ":c:func:`scanf` Token"
msgstr ""

#: ../Doc/library/re.rst:1234
msgid "Regular Expression"
msgstr ""

#: ../Doc/library/re.rst:1236
msgid "``%c``"
msgstr "``%c``"

#: ../Doc/library/re.rst:1236
msgid "``.``"
msgstr "``.``"

#: ../Doc/library/re.rst:1238
msgid "``%5c``"
msgstr "``%5c``"

#: ../Doc/library/re.rst:1238
msgid "``.{5}``"
msgstr "``.{5}``"

#: ../Doc/library/re.rst:1240
msgid "``%d``"
msgstr "``%d``"

#: ../Doc/library/re.rst:1240
msgid "``[-+]?\\d+``"
msgstr "``[-+]?\\d+``"

#: ../Doc/library/re.rst:1242
msgid "``%e``, ``%E``, ``%f``, ``%g``"
msgstr "``%e``, ``%E``, ``%f``, ``%g``"

#: ../Doc/library/re.rst:1242
msgid "``[-+]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?``"
msgstr "``[-+]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?``"

#: ../Doc/library/re.rst:1244
msgid "``%i``"
msgstr "``%i``"

#: ../Doc/library/re.rst:1244
msgid "``[-+]?(0[xX][\\dA-Fa-f]+|0[0-7]*|\\d+)``"
msgstr "``[-+]?(0[xX][\\dA-Fa-f]+|0[0-7]*|\\d+)``"

#: ../Doc/library/re.rst:1246
msgid "``%o``"
msgstr "``%o``"

#: ../Doc/library/re.rst:1246
msgid "``[-+]?[0-7]+``"
msgstr "``[-+]?[0-7]+``"

#: ../Doc/library/re.rst:1248
msgid "``%s``"
msgstr "``%s``"

#: ../Doc/library/re.rst:1248
msgid "``\\S+``"
msgstr "``\\S+``"

#: ../Doc/library/re.rst:1250
msgid "``%u``"
msgstr "``%u``"

#: ../Doc/library/re.rst:1250
msgid "``\\d+``"
msgstr "``\\d+``"

#: ../Doc/library/re.rst:1252
msgid "``%x``, ``%X``"
msgstr "``%x``, ``%X``"

#: ../Doc/library/re.rst:1252
msgid "``[-+]?(0[xX])?[\\dA-Fa-f]+``"
msgstr "``[-+]?(0[xX])?[\\dA-Fa-f]+``"

#: ../Doc/library/re.rst:1255
msgid "To extract the filename and numbers from a string like ::"
msgstr ""

#: ../Doc/library/re.rst:1259
msgid "you would use a :c:func:`scanf` format like ::"
msgstr ""

#: ../Doc/library/re.rst:1263
msgid "The equivalent regular expression would be ::"
msgstr ""

#: ../Doc/library/re.rst:1271
msgid "search() vs. match()"
msgstr ""

#: ../Doc/library/re.rst:1275
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:1280
msgid "For example::"
msgstr "Par exemple : ::"

#: ../Doc/library/re.rst:1286
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:1294
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:1304
msgid "Making a Phonebook"
msgstr ""

#: ../Doc/library/re.rst:1306
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:1311
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:1322
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:1335
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:1348
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:1363
msgid "Text Munging"
msgstr ""

#: ../Doc/library/re.rst:1365
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:1382
msgid "Finding all Adverbs"
msgstr ""

#: ../Doc/library/re.rst:1384
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:1395
msgid "Finding all Adverbs and their Positions"
msgstr ""

#: ../Doc/library/re.rst:1397
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:1411
msgid "Raw String Notation"
msgstr ""

#: ../Doc/library/re.rst:1413
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:1423
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:1435
msgid "Writing a Tokenizer"
msgstr ""

#: ../Doc/library/re.rst:1437
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:1441
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:1491
msgid "The tokenizer produces the following output::"
msgstr ""