# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001-2026, Python Software Foundation

# This file is distributed under the same license as the Python package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# python-doc bot, 2026

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: Python 3.13\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2026-04-05 15:15+0000\n"

"PO-Revision-Date: 2025-09-15 01:03+0000\n"

"Last-Translator: python-doc bot, 2026\n"

"Language-Team: Polish (https://app.transifex.com/python-doc/teams/5390/pl/)\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Language: pl\n"

"Plural-Forms: nplurals=4; plural=(n==1 ? 0 : (n%10>=2 && n%10<=4) && "

"(n%100<12 || n%100>14) ? 1 : n!=1 && (n%10>=0 && n%10<=1) || (n%10>=5 && "

"n%10<=9) || (n%100>=12 && n%100<=14) ? 2 : 3);\n"

msgid "Regular expression HOWTO"

msgstr ""

msgid "Author"

msgstr "Autor"

msgid "A.M. Kuchling <amk@amk.ca>"

msgstr "A.M. Kuchling <amk@amk.ca>"

msgid "Abstract"

msgstr "Streszczenie"

msgid ""

"This document is an introductory tutorial to using regular expressions in "

"Python with the :mod:`re` module. It provides a gentler introduction than "

"the corresponding section in the Library Reference."

msgstr ""

msgid "Introduction"

msgstr "Wprowadzenie"

msgid ""

"Regular expressions (called REs, or regexes, or regex patterns) are "

"essentially a tiny, highly specialized programming language embedded inside "

"Python and made available through the :mod:`re` module. Using this little "

"language, you specify the rules for the set of possible strings that you "

"want to match; this set might contain English sentences, or e-mail "

"addresses, or TeX commands, or anything you like. You can then ask "

"questions such as \"Does this string match the pattern?\", or \"Is there a "

"match for the pattern anywhere in this string?\". You can also use REs to "

"modify a string or to split it apart in various ways."

msgstr ""

msgid ""

"Regular expression patterns are compiled into a series of bytecodes which "

"are then executed by a matching engine written in C. For advanced use, it "

"may be necessary to pay careful attention to how the engine will execute a "

"given RE, and write the RE in a certain way in order to produce bytecode "

"that runs faster. Optimization isn't covered in this document, because it "

"requires that you have a good understanding of the matching engine's "

"internals."

msgstr ""

msgid ""

"The regular expression language is relatively small and restricted, so not "

"all possible string processing tasks can be done using regular expressions. "

"There are also tasks that *can* be done with regular expressions, but the "

"expressions turn out to be very complicated. In these cases, you may be "

"better off writing Python code to do the processing; while Python code will "

"be slower than an elaborate regular expression, it will also probably be "

"more understandable."

msgstr ""

msgid "Simple patterns"

msgstr ""

msgid ""

"We'll start by learning about the simplest possible regular expressions. "

"Since regular expressions are used to operate on strings, we'll begin with "

"the most common task: matching characters."

msgstr ""

msgid ""

"For a detailed explanation of the computer science underlying regular "

"expressions (deterministic and non-deterministic finite automata), you can "

"refer to almost any textbook on writing compilers."

msgstr ""

msgid "Matching characters"

msgstr ""

msgid ""

"Most letters and characters will simply match themselves. For example, the "

"regular expression ``test`` will match the string ``test`` exactly. (You "

"can enable a case-insensitive mode that would let this RE match ``Test`` or "

"``TEST`` as well; more about this later.)"

msgstr ""

msgid ""

"There are exceptions to this rule; some characters are special :dfn:"

"`metacharacters`, and don't match themselves. Instead, they signal that "

"some out-of-the-ordinary thing should be matched, or they affect other "

"portions of the RE by repeating them or changing their meaning. Much of "

"this document is devoted to discussing various metacharacters and what they "

"do."

msgstr ""

msgid ""

"Here's a complete list of the metacharacters; their meanings will be "

"discussed in the rest of this HOWTO."

msgstr ""

msgid ". ^ $ * + ? { } [ ] \\ | ( )"

msgstr ". ^ $ * + ? { } [ ] \\ | ( )"

msgid ""

"The first metacharacters we'll look at are ``[`` and ``]``. They're used for "

"specifying a character class, which is a set of characters that you wish to "

"match. Characters can be listed individually, or a range of characters can "

"be indicated by giving two characters and separating them by a ``'-'``. For "

"example, ``[abc]`` will match any of the characters ``a``, ``b``, or ``c``; "

"this is the same as ``[a-c]``, which uses a range to express the same set of "

"characters. If you wanted to match only lowercase letters, your RE would be "

"``[a-z]``."

msgstr ""

msgid ""

"Metacharacters (except ``\\``) are not active inside classes. For example, "

"``[akm$]`` will match any of the characters ``'a'``, ``'k'``, ``'m'``, or "

"``'$'``; ``'$'`` is usually a metacharacter, but inside a character class "

"it's stripped of its special nature."

msgstr ""

msgid ""

"You can match the characters not listed within the class by :dfn:"

"`complementing` the set. This is indicated by including a ``'^'`` as the "

"first character of the class. For example, ``[^5]`` will match any character "

"except ``'5'``. If the caret appears elsewhere in a character class, it "

"does not have special meaning. For example: ``[5^]`` will match either a "

"``'5'`` or a ``'^'``."

msgstr ""

msgid ""

"Perhaps the most important metacharacter is the backslash, ``\\``. As in "

"Python string literals, the backslash can be followed by various characters "

"to signal various special sequences. It's also used to escape all the "

"metacharacters so you can still match them in patterns; for example, if you "

"need to match a ``[`` or ``\\``, you can precede them with a backslash to "

"remove their special meaning: ``\\[`` or ``\\\\``."

msgstr ""

msgid ""

"Some of the special sequences beginning with ``'\\'`` represent predefined "

"sets of characters that are often useful, such as the set of digits, the set "

"of letters, or the set of anything that isn't whitespace."

msgstr ""

msgid ""

"Let's take an example: ``\\w`` matches any alphanumeric character. If the "

"regex pattern is expressed in bytes, this is equivalent to the class ``[a-zA-"

"Z0-9_]``. If the regex pattern is a string, ``\\w`` will match all the "

"characters marked as letters in the Unicode database provided by the :mod:"

"`unicodedata` module. You can use the more restricted definition of ``\\w`` "

"in a string pattern by supplying the :const:`re.ASCII` flag when compiling "

"the regular expression."

msgstr ""

msgid ""

"The following list of special sequences isn't complete. For a complete list "

"of sequences and expanded class definitions for Unicode string patterns, see "

"the last part of :ref:`Regular Expression Syntax <re-syntax>` in the "

"Standard Library reference. In general, the Unicode versions match any "

"character that's in the appropriate category in the Unicode database."

msgstr ""

msgid "``\\d``"

msgstr "``\\d``"

msgid "Matches any decimal digit; this is equivalent to the class ``[0-9]``."

msgstr ""

msgid "``\\D``"

msgstr "``\\D``"

msgid ""

"Matches any non-digit character; this is equivalent to the class ``[^0-9]``."

msgstr ""

"Wyszukuje każdy nieliczbowy ciąg znaków , jest to zamiennik klasy ``[^0-9]``"

msgid "``\\s``"

msgstr "``\\s``"

msgid ""

"Matches any whitespace character; this is equivalent to the class "

"``[ \\t\\n\\r\\f\\v]``."

msgstr ""

msgid "``\\S``"

msgstr "``\\S``"

msgid ""

"Matches any non-whitespace character; this is equivalent to the class ``[^ "

"\\t\\n\\r\\f\\v]``."

msgstr ""

msgid "``\\w``"

msgstr "``\\w``"

msgid ""

"Matches any alphanumeric character; this is equivalent to the class ``[a-zA-"

"Z0-9_]``."

msgstr ""

msgid "``\\W``"

msgstr "``\\W``"

msgid ""

"Matches any non-alphanumeric character; this is equivalent to the class "

"``[^a-zA-Z0-9_]``."

msgstr ""

msgid ""

"These sequences can be included inside a character class. For example, "

"``[\\s,.]`` is a character class that will match any whitespace character, "

"or ``','`` or ``'.'``."

msgstr ""

msgid ""

"The final metacharacter in this section is ``.``. It matches anything "

"except a newline character, and there's an alternate mode (:const:`re."

"DOTALL`) where it will match even a newline. ``.`` is often used where you "

"want to match \"any character\"."

msgstr ""

msgid "Repeating things"

msgstr ""

msgid ""

"Being able to match varying sets of characters is the first thing regular "

"expressions can do that isn't already possible with the methods available on "

"strings. However, if that was the only additional capability of regexes, "

"they wouldn't be much of an advance. Another capability is that you can "

"specify that portions of the RE must be repeated a certain number of times."

msgstr ""

msgid ""

"The first metacharacter for repeating things that we'll look at is ``*``. "

"``*`` doesn't match the literal character ``'*'``; instead, it specifies "

"that the previous character can be matched zero or more times, instead of "

"exactly once."

msgstr ""

msgid ""

"For example, ``ca*t`` will match ``'ct'`` (0 ``'a'`` characters), ``'cat'`` "

"(1 ``'a'``), ``'caaat'`` (3 ``'a'`` characters), and so forth."

msgstr ""

msgid ""

"Repetitions such as ``*`` are :dfn:`greedy`; when repeating a RE, the "

"matching engine will try to repeat it as many times as possible. If later "

"portions of the pattern don't match, the matching engine will then back up "

"and try again with fewer repetitions."

msgstr ""

msgid ""

"A step-by-step example will make this more obvious. Let's consider the "

"expression ``a[bcd]*b``. This matches the letter ``'a'``, zero or more "

"letters from the class ``[bcd]``, and finally ends with a ``'b'``. Now "

"imagine matching this RE against the string ``'abcbd'``."

msgstr ""

msgid "Step"

msgstr ""

msgid "Matched"

msgstr ""

msgid "Explanation"

msgstr "Wytłumaczenie"

msgid "1"

msgstr "1"

msgid "``a``"

msgstr "``a``"

msgid "The ``a`` in the RE matches."

msgstr ""

msgid "2"

msgstr "2"

msgid "``abcbd``"

msgstr "``abcbd``"

msgid ""

"The engine matches ``[bcd]*``, going as far as it can, which is to the end "

"of the string."

msgstr ""

msgid "3"

msgstr "3"

msgid "*Failure*"

msgstr ""

msgid ""

"The engine tries to match ``b``, but the current position is at the end of "

"the string, so it fails."

msgstr ""

msgid "4"

msgstr "4"

msgid "``abcb``"

msgstr "``abcb``"

msgid "Back up, so that ``[bcd]*`` matches one less character."

msgstr ""

msgid "5"

msgstr "5"

msgid ""

"Try ``b`` again, but the current position is at the last character, which is "

"a ``'d'``."

msgstr ""

msgid "6"

msgstr "6"

msgid "``abc``"

msgstr "``abc``"

msgid "Back up again, so that ``[bcd]*`` is only matching ``bc``."

msgstr ""

msgid "7"

msgstr "7"

msgid ""

"Try ``b`` again. This time the character at the current position is "

"``'b'``, so it succeeds."

msgstr ""

msgid ""

"The end of the RE has now been reached, and it has matched ``'abcb'``. This "

"demonstrates how the matching engine goes as far as it can at first, and if "

"no match is found it will then progressively back up and retry the rest of "

"the RE again and again. It will back up until it has tried zero matches for "

"``[bcd]*``, and if that subsequently fails, the engine will conclude that "

"the string doesn't match the RE at all."

msgstr ""

msgid ""

"Another repeating metacharacter is ``+``, which matches one or more times. "

"Pay careful attention to the difference between ``*`` and ``+``; ``*`` "

"matches *zero* or more times, so whatever's being repeated may not be "

"present at all, while ``+`` requires at least *one* occurrence. To use a "

"similar example, ``ca+t`` will match ``'cat'`` (1 ``'a'``), ``'caaat'`` (3 "

"``'a'``\\ s), but won't match ``'ct'``."

msgstr ""

msgid ""

"There are two more repeating operators or quantifiers. The question mark "

"character, ``?``, matches either once or zero times; you can think of it as "

"marking something as being optional. For example, ``home-?brew`` matches "

"either ``'homebrew'`` or ``'home-brew'``."

msgstr ""

msgid ""

"The most complicated quantifier is ``{m,n}``, where *m* and *n* are decimal "

"integers. This quantifier means there must be at least *m* repetitions, and "

"at most *n*. For example, ``a/{1,3}b`` will match ``'a/b'``, ``'a//b'``, "

"and ``'a///b'``. It won't match ``'ab'``, which has no slashes, or ``'a////"

"b'``, which has four."

msgstr ""

msgid ""

"You can omit either *m* or *n*; in that case, a reasonable value is assumed "

"for the missing value. Omitting *m* is interpreted as a lower limit of 0, "

"while omitting *n* results in an upper bound of infinity."

msgstr ""

msgid ""

"The simplest case ``{m}`` matches the preceding item exactly *m* times. For "

"example, ``a/{2}b`` will only match ``'a//b'``."

msgstr ""

msgid ""

"Readers of a reductionist bent may notice that the three other quantifiers "

"can all be expressed using this notation. ``{0,}`` is the same as ``*``, "

"``{1,}`` is equivalent to ``+``, and ``{0,1}`` is the same as ``?``. It's "

"better to use ``*``, ``+``, or ``?`` when you can, simply because they're "

"shorter and easier to read."

msgstr ""

msgid "Using regular expressions"

msgstr ""

msgid ""

"Now that we've looked at some simple regular expressions, how do we actually "

"use them in Python? The :mod:`re` module provides an interface to the "

"regular expression engine, allowing you to compile REs into objects and then "

"perform matches with them."

msgstr ""

msgid "Compiling regular expressions"

msgstr ""

msgid ""

"Regular expressions are compiled into pattern objects, which have methods "

"for various operations such as searching for pattern matches or performing "

"string substitutions. ::"

msgstr ""

msgid ""

">>> import re\n"

">>> p = re.compile('ab*')\n"

">>> p\n"

"re.compile('ab*')"

msgstr ""

">>> import re\n"

">>> p = re.compile('ab*')\n"

">>> p\n"

"re.compile('ab*')"

msgid ""

":func:`re.compile` also accepts an optional *flags* argument, used to enable "

"various special features and syntax variations. We'll go over the available "

"settings later, but for now a single example will do::"

msgstr ""

msgid ">>> p = re.compile('ab*', re.IGNORECASE)"

msgstr ">>> p = re.compile('ab*', re.IGNORECASE)"

msgid ""

"The RE is passed to :func:`re.compile` as a string. REs are handled as "

"strings because regular expressions aren't part of the core Python language, "

"and no special syntax was created for expressing them. (There are "

"applications that don't need REs at all, so there's no need to bloat the "

"language specification by including them.) Instead, the :mod:`re` module is "

"simply a C extension module included with Python, just like the :mod:"

"`socket` or :mod:`zlib` modules."

msgstr ""

msgid ""

"Putting REs in strings keeps the Python language simpler, but has one "

"disadvantage which is the topic of the next section."

msgstr ""

msgid "The backslash plague"

msgstr ""

msgid ""

"As stated earlier, regular expressions use the backslash character "

"(``'\\'``) to indicate special forms or to allow special characters to be "

"used without invoking their special meaning. This conflicts with Python's "

"usage of the same character for the same purpose in string literals."

msgstr ""

msgid ""

"Let's say you want to write a RE that matches the string ``\\section``, "

"which might be found in a LaTeX file. To figure out what to write in the "

"program code, start with the desired string to be matched. Next, you must "

"escape any backslashes and other metacharacters by preceding them with a "

"backslash, resulting in the string ``\\\\section``. The resulting string "

"that must be passed to :func:`re.compile` must be ``\\\\section``. However, "

"to express this as a Python string literal, both backslashes must be escaped "

"*again*."

msgstr ""

msgid "Characters"

msgstr ""

msgid "Stage"

msgstr ""

msgid "``\\section``"

msgstr "``\\section``"

msgid "Text string to be matched"

msgstr ""

msgid "``\\\\section``"

msgstr "``\\\\section``"

msgid "Escaped backslash for :func:`re.compile`"

msgstr ""

msgid "``\"\\\\\\\\section\"``"

msgstr "``\"\\\\\\\\section\"``"

msgid "Escaped backslashes for a string literal"

msgstr ""

msgid ""

"In short, to match a literal backslash, one has to write ``'\\\\\\\\'`` as "

"the RE string, because the regular expression must be ``\\\\``, and each "

"backslash must be expressed as ``\\\\`` inside a regular Python string "

"literal. In REs that feature backslashes repeatedly, this leads to lots of "

"repeated backslashes and makes the resulting strings difficult to understand."

msgstr ""

msgid ""

"The solution is to use Python's raw string notation for regular expressions; "

"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. Regular expressions will often be written in Python code using this "

"raw string notation."

msgstr ""

msgid ""

"In addition, special escape sequences that are valid in regular expressions, "

"but not valid as Python string literals, now result in a :exc:"

"`SyntaxWarning` and will eventually become a :exc:`SyntaxError`, which means "

"the sequences will be invalid if raw string notation or escaping the "

"backslashes isn't used."

msgstr ""

msgid "Regular String"

msgstr ""

msgid "Raw string"

msgstr ""

msgid "``\"ab*\"``"

msgstr "``\"ab*\"``"

msgid "``r\"ab*\"``"

msgstr "``r\"ab*\"``"

msgid "``r\"\\\\section\"``"

msgstr "``r\"\\\\section\"``"

msgid "``\"\\\\w+\\\\s+\\\\1\"``"

msgstr "``\"\\\\w+\\\\s+\\\\1\"``"

msgid "``r\"\\w+\\s+\\1\"``"

msgstr "``r\"\\w+\\s+\\1\"``"

msgid "Performing matches"

msgstr ""

msgid ""

"Once you have an object representing a compiled regular expression, what do "

"you do with it? Pattern objects have several methods and attributes. Only "

"the most significant ones will be covered here; consult the :mod:`re` docs "

"for a complete listing."

msgstr ""

msgid "Method/Attribute"

msgstr "Metoda/atrybut"

msgid "Purpose"

msgstr ""

msgid "``match()``"

msgstr "``match()``"

msgid "Determine if the RE matches at the beginning of the string."

msgstr ""

msgid "``search()``"

msgstr "``search()``"

msgid "Scan through a string, looking for any location where this RE matches."

msgstr ""

msgid "``findall()``"

msgstr "``findall()``"

msgid "Find all substrings where the RE matches, and return them as a list."

msgstr ""

msgid "``finditer()``"

msgstr "``finditer()``"

msgid ""

"Find all substrings where the RE matches, and return them as an :term:"

"`iterator`."

msgstr ""

msgid ""

":meth:`~re.Pattern.match` and :meth:`~re.Pattern.search` return ``None`` if "

"no match can be found. If they're successful, a :ref:`match object <match-"

"objects>` instance is returned, containing information about the match: "

"where it starts and ends, the substring it matched, and more."

msgstr ""

msgid ""

"You can learn about this by interactively experimenting with the :mod:`re` "

"module."

msgstr ""

msgid ""

"This HOWTO uses the standard Python interpreter for its examples. First, run "

"the Python interpreter, import the :mod:`re` module, and compile a RE::"

msgstr ""

msgid ""

">>> import re\n"

">>> p = re.compile('[a-z]+')\n"

">>> p\n"

"re.compile('[a-z]+')"

msgstr ""

">>> import re\n"

">>> p = re.compile('[a-z]+')\n"

">>> p\n"

"re.compile('[a-z]+')"

msgid ""

"Now, you can try matching various strings against the RE ``[a-z]+``. An "

"empty string shouldn't match at all, since ``+`` means 'one or more "

"repetitions'. :meth:`~re.Pattern.match` should return ``None`` in this case, "

"which will cause the interpreter to print no output. You can explicitly "

"print the result of :meth:`!match` to make this clear. ::"

msgstr ""

msgid ""

">>> p.match(\"\")\n"

">>> print(p.match(\"\"))\n"

"None"

msgstr ""

">>> p.match(\"\")\n"

">>> print(p.match(\"\"))\n"

"None"

msgid ""

"Now, let's try it on a string that it should match, such as ``tempo``. In "

"this case, :meth:`~re.Pattern.match` will return a :ref:`match object <match-"

"objects>`, so you should store the result in a variable for later use. ::"

msgstr ""

msgid ""

">>> m = p.match('tempo')\n"

">>> m\n"

"<re.Match object; span=(0, 5), match='tempo'>"

msgstr ""

">>> m = p.match('tempo')\n"

">>> m\n"

"<re.Match object; span=(0, 5), match='tempo'>"

msgid ""

"Now you can query the :ref:`match object <match-objects>` for information "

"about the matching string. Match object instances also have several methods "

"and attributes; the most important ones are:"

msgstr ""

msgid "``group()``"

msgstr "``group()``"

msgid "Return the string matched by the RE"

msgstr ""

msgid "``start()``"

msgstr "``start()``"

msgid "Return the starting position of the match"

msgstr ""

msgid "``end()``"

msgstr "``end()``"

msgid "Return the ending position of the match"

msgstr ""

msgid "``span()``"

msgstr "``span()``"

msgid "Return a tuple containing the (start, end) positions of the match"

msgstr ""

msgid "Trying these methods will soon clarify their meaning::"

msgstr ""

msgid ""

">>> m.group()\n"

"'tempo'\n"

">>> m.start(), m.end()\n"

"(0, 5)\n"

">>> m.span()\n"

"(0, 5)"

msgstr ""

">>> m.group()\n"

"'tempo'\n"

">>> m.start(), m.end()\n"

"(0, 5)\n"

">>> m.span()\n"

"(0, 5)"

msgid ""

":meth:`~re.Match.group` returns the substring that was matched by the RE. :"

"meth:`~re.Match.start` and :meth:`~re.Match.end` return the starting and "

"ending index of the match. :meth:`~re.Match.span` returns both start and end "

"indexes in a single tuple. Since the :meth:`~re.Pattern.match` method only "

"checks if the RE matches at the start of a string, :meth:`!start` will "

"always be zero. However, the :meth:`~re.Pattern.search` method of patterns "

"scans through the string, so the match may not start at zero in that "

"case. ::"

msgstr ""

msgid ""

">>> print(p.match('::: message'))\n"

"None\n"

">>> m = p.search('::: message'); print(m)\n"

"<re.Match object; span=(4, 11), match='message'>\n"

">>> m.group()\n"

"'message'\n"

">>> m.span()\n"

"(4, 11)"

msgstr ""

msgid ""

"In actual programs, the most common style is to store the :ref:`match object "

"<match-objects>` in a variable, and then check if it was ``None``. This "

"usually looks like::"

msgstr ""

msgid ""

"p = re.compile( ... )\n"

"m = p.match( 'string goes here' )\n"

"if m:\n"

" print('Match found: ', m.group())\n"

"else:\n"

" print('No match')"

msgstr ""

msgid ""

"Two pattern methods return all of the matches for a pattern. :meth:`~re."

"Pattern.findall` returns a list of matching strings::"

msgstr ""

msgid ""

">>> p = re.compile(r'\\d+')\n"

">>> p.findall('12 drummers drumming, 11 pipers piping, 10 lords a-leaping')\n"

"['12', '11', '10']"

msgstr ""

msgid ""

"The ``r`` prefix, making the literal a raw string literal, is needed in this "

"example because escape sequences in a normal \"cooked\" string literal that "

"are not recognized by Python, as opposed to regular expressions, now result "

"in a :exc:`SyntaxWarning` and will eventually become a :exc:`SyntaxError`. "

"See :ref:`the-backslash-plague`."

msgstr ""

msgid ""

":meth:`~re.Pattern.findall` has to create the entire list before it can be "

"returned as the result. The :meth:`~re.Pattern.finditer` method returns a "

"sequence of :ref:`match object <match-objects>` instances as an :term:"

"`iterator`::"

msgstr ""

msgid ""

">>> iterator = p.finditer('12 drummers drumming, 11 ... 10 ...')\n"

">>> iterator\n"

"<callable_iterator object at 0x...>\n"

">>> for match in iterator:\n"

"... print(match.span())\n"

"...\n"

"(0, 2)\n"

"(22, 24)\n"

"(29, 31)"

msgstr ""

msgid "Module-level functions"

msgstr ""

msgid ""

"You don't have to create a pattern object and call its methods; the :mod:"

"`re` module also provides top-level functions called :func:`~re.match`, :"

"func:`~re.search`, :func:`~re.findall`, :func:`~re.sub`, and so forth. "

"These functions take the same arguments as the corresponding pattern method "

"with the RE string added as the first argument, and still return either "

"``None`` or a :ref:`match object <match-objects>` instance. ::"

msgstr ""

msgid ""

">>> print(re.match(r'From\\s+', 'Fromage amk'))\n"

"None\n"

">>> re.match(r'From\\s+', 'From amk Thu May 14 19:12:10 1998')\n"

"<re.Match object; span=(0, 5), match='From '>"

msgstr ""

msgid ""

"Under the hood, these functions simply create a pattern object for you and "

"call the appropriate method on it. They also store the compiled object in a "

"cache, so future calls using the same RE won't need to parse the pattern "

"again and again."

msgstr ""

msgid ""

"Should you use these module-level functions, or should you get the pattern "

"and call its methods yourself? If you're accessing a regex within a loop, "

"pre-compiling it will save a few function calls. Outside of loops, there's "

"not much difference thanks to the internal cache."

msgstr ""

msgid "Compilation flags"

msgstr ""

msgid ""

"Compilation flags let you modify some aspects of how regular expressions "

"work. Flags are available in the :mod:`re` module under two names, a long "

"name such as :const:`IGNORECASE` and a short, one-letter form such as :const:"

"`I`. (If you're familiar with Perl's pattern modifiers, the one-letter "

"forms use the same letters; the short form of :const:`re.VERBOSE` is :const:"

"`re.X`, for example.) Multiple flags can be specified by bitwise OR-ing "

"them; ``re.I | re.M`` sets both the :const:`I` and :const:`M` flags, for "

"example."

msgstr ""

msgid ""

"Here's a table of the available flags, followed by a more detailed "

"explanation of each one."

msgstr ""

msgid "Flag"

msgstr ""

msgid "Meaning"

msgstr "Znaczenie"

msgid ":const:`ASCII`, :const:`A`"

msgstr ":const:`ASCII`, :const:`A`"

msgid ""

"Makes several escapes like ``\\w``, ``\\b``, ``\\s`` and ``\\d`` match only "

"on ASCII characters with the respective property."

msgstr ""

msgid ":const:`DOTALL`, :const:`S`"

msgstr ":const:`DOTALL`, :const:`S`"

msgid "Make ``.`` match any character, including newlines."

msgstr ""

msgid ":const:`IGNORECASE`, :const:`I`"

msgstr ":const:`IGNORECASE`, :const:`I`"

msgid "Do case-insensitive matches."

msgstr ""

msgid ":const:`LOCALE`, :const:`L`"

msgstr ":const:`LOCALE`, :const:`L`"

msgid "Do a locale-aware match."

msgstr ""

msgid ":const:`MULTILINE`, :const:`M`"

msgstr ":const:`MULTILINE`, :const:`M`"

msgid "Multi-line matching, affecting ``^`` and ``$``."

msgstr "Multi-line matching, affecting ``^`` and ``$``."

msgid ":const:`VERBOSE`, :const:`X` (for 'extended')"

msgstr ""

msgid ""

"Enable verbose REs, which can be organized more cleanly and understandably."

msgstr ""

msgid ""

"Perform case-insensitive matching; character class and literal strings will "

"match letters by ignoring case. For example, ``[A-Z]`` will match lowercase "

"letters, too. Full Unicode matching also works unless the :const:`ASCII` "

"flag is used to disable non-ASCII matches. When the Unicode patterns ``[a-"

"z]`` or ``[A-Z]`` are used in combination with the :const:`IGNORECASE` flag, "

"they will match the 52 ASCII letters and 4 additional non-ASCII letters: "

"'İ' (U+0130, Latin capital letter I with dot above), 'ı' (U+0131, Latin "

"small letter dotless i), 'ſ' (U+017F, Latin small letter long s) and "

"'K' (U+212A, Kelvin sign). ``Spam`` will match ``'Spam'``, ``'spam'``, "

"``'spAM'``, or ``'ſpam'`` (the latter is matched only in Unicode mode). This "

"lowercasing doesn't take the current locale into account; it will if you "

"also set the :const:`LOCALE` flag."

msgstr ""

msgid ""

"Make ``\\w``, ``\\W``, ``\\b``, ``\\B`` and case-insensitive matching "

"dependent on the current locale instead of the Unicode database."

msgstr ""

msgid ""

"Locales are a feature of the C library intended to help in writing programs "

"that take account of language differences. For example, if you're "

"processing encoded French text, you'd want to be able to write ``\\w+`` to "

"match words, but ``\\w`` only matches the character class ``[A-Za-z]`` in "

"bytes patterns; it won't match bytes corresponding to ``é`` or ``ç``. If "

"your system is configured properly and a French locale is selected, certain "

"C functions will tell the program that the byte corresponding to ``é`` "

"should also be considered a letter. Setting the :const:`LOCALE` flag when "

"compiling a regular expression will cause the resulting compiled object to "

"use these C functions for ``\\w``; this is slower, but also enables ``\\w+`` "

"to match French words as you'd expect. The use of this flag is discouraged "

"in Python 3 as the locale mechanism is very unreliable, it only handles one "

"\"culture\" at a time, and it only works with 8-bit locales. Unicode "

"matching is already enabled by default in Python 3 for Unicode (str) "

"patterns, and it is able to handle different locales/languages."

msgstr ""

msgid ""

"(``^`` and ``$`` haven't been explained yet; they'll be introduced in "

"section :ref:`more-metacharacters`.)"

msgstr ""

msgid ""

"Usually ``^`` matches only at the beginning of the string, and ``$`` matches "

"only at the end of the string and immediately before the newline (if any) at "

"the end of the string. When this flag is specified, ``^`` matches at the "

"beginning of the string and at the beginning of each line within the string, "

"immediately following each newline. Similarly, the ``$`` metacharacter "

"matches either at the end of the string and at the end of each line "

"(immediately preceding each newline)."

msgstr ""

msgid ""

"Makes the ``'.'`` special character match any character at all, including a "

"newline; without this flag, ``'.'`` will match anything *except* a newline."

msgstr ""

msgid ""

"Make ``\\w``, ``\\W``, ``\\b``, ``\\B``, ``\\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 ""

msgid ""

"This flag allows you to write regular expressions that are more readable by "

"granting you more flexibility in how you can format them. When this flag "

"has been specified, whitespace within the RE string is ignored, except when "

"the whitespace is in a character class or preceded by an unescaped "

"backslash; this lets you organize and indent the RE more clearly. This flag "

"also lets you put comments within a RE that will be ignored by the engine; "

"comments are marked by a ``'#'`` that's neither in a character class nor "

"preceded by an unescaped backslash."

msgstr ""

msgid ""

"For example, here's a RE that uses :const:`re.VERBOSE`; see how much easier "

"it is to read? ::"

msgstr ""

msgid ""

"charref = re.compile(r\"\"\"\n"

" &[#] # Start of a numeric entity reference\n"

" (\n"

" 0[0-7]+ # Octal form\n"

" | [0-9]+ # Decimal form\n"

" | x[0-9a-fA-F]+ # Hexadecimal form\n"

" )\n"

" ; # Trailing semicolon\n"

"\"\"\", re.VERBOSE)"

msgstr ""

msgid "Without the verbose setting, the RE would look like this::"

msgstr ""

msgid ""

"charref = re.compile(\"&#(0[0-7]+\"\n"

" \"|[0-9]+\"\n"

" \"|x[0-9a-fA-F]+);\")"

msgstr ""

"charref = re.compile(\"&#(0[0-7]+\"\n"

" \"|[0-9]+\"\n"

" \"|x[0-9a-fA-F]+);\")"

msgid ""

"In the above example, Python's automatic concatenation of string literals "

"has been used to break up the RE into smaller pieces, but it's still more "

"difficult to understand than the version using :const:`re.VERBOSE`."

msgstr ""

msgid "More pattern power"

msgstr ""

msgid ""

"So far we've only covered a part of the features of regular expressions. In "

"this section, we'll cover some new metacharacters, and how to use groups to "

"retrieve portions of the text that was matched."

msgstr ""

msgid "More metacharacters"

msgstr ""

msgid ""

"There are some metacharacters that we haven't covered yet. Most of them "

"will be covered in this section."

msgstr ""

msgid ""

"Some of the remaining metacharacters to be discussed are :dfn:`zero-width "

"assertions`. They don't cause the engine to advance through the string; "

"instead, they consume no characters at all, and simply succeed or fail. For "