# SOME DESCRIPTIVE TITLE. # Copyright (C) 2001-2016, Python Software Foundation # This file is distributed under the same license as the Python package. # FIRST AUTHOR , 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 \n" "Language-Team: LANGUAGE \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 `. 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 `_ 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 `` b ``, it will match the entire " "string, and not just ````. 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 ````." 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...)`` 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...)``" msgstr "``(?P...)``" #: ../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['\"]).*?(?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``" msgstr "``\\g``" #: ../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 "``(?|$)`` is a poor email matching pattern, which will match with " "``''`` as well as ``'user@host.com'``, but not with " "``''``." 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 `. 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 `. 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 `. 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 ` " "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`` will use the substring matched " "by the group named ``name``, as defined by the ``(?P...)`` syntax. ``" "\\g`` 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 " "`. 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 `. " "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 `. 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)`` 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``) 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...)`` 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 `. 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 `. 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 " "` 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 `_ " "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 ""