regex.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2022, Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
# Albin Sun <yunpin.sun@gmail.com>, 2015
# Kai-han Chang <rasca0027@gmail.com>, 2015
msgid ""
msgstr ""
"Project-Id-Version: Python 3.12\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-04-18 00:04+0000\n"
"PO-Revision-Date: 2018-05-23 14:37+0000\n"
"Last-Translator: Adrian Liaw <adrianliaw2000@gmail.com>\n"
"Language-Team: Chinese - TAIWAN (https://github.com/python/python-docs-zh-"
"tw)\n"
"Language: zh_TW\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#:../../howto/regex.rst:5
msgid"Regular Expression HOWTO"
msgstr"如何使用正規表達式"

#:../../howto/regex.rst:0
msgid"Author"
msgstr"作者"

#:../../howto/regex.rst:7
msgid"A.M. Kuchling <amk@amk.ca>"
msgstr"A.M. Kuchling <amk@amk.ca>"

#:../../howto/regex.rst:-1
msgid"Abstract"
msgstr"摘要"

#:../../howto/regex.rst:18
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""
"此文件為如何在 Python 中使用 :mod:`re` 模組來撰寫正規表達式的入門指導。進階使"
"用及參考文件請見函式庫參考一章。"

#:../../howto/regex.rst:24
msgid"Introduction"
msgstr"簡介"

#:../../howto/regex.rst:26
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""
"正規表示式 (也稱為 REs、regexes 或 regex patterns) 是一個輕量且高專業化的程式"
"語言。在 Python 中可透過內建的 :mod:`re` 模組直接使用。你可以使用此輕量化的"
"語言針對想要匹配的一組字串撰寫規則，這組字串可能包含了英語句子、e-mail 地址、"
"TeX 命令或任何東西。你可以檢查如「這組字串是否匹配這個規則？」或「這組字串中"
"是否有任一處匹配這個規則？」。除此之外，你也可以使用 REs 來修改或是切割字串。"

#:../../howto/regex.rst:35
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""

#:../../howto/regex.rst:42
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""

#:../../howto/regex.rst:51
msgid"Simple Patterns"
msgstr""

#:../../howto/regex.rst:53
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""

#:../../howto/regex.rst:57
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""

#:../../howto/regex.rst:63
msgid"Matching Characters"
msgstr""

#:../../howto/regex.rst:65
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""

#:../../howto/regex.rst:70
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""

#:../../howto/regex.rst:76
msgid""
"Here's a complete list of the metacharacters; their meanings will be "
"discussed in the rest of this HOWTO."
msgstr""

#:../../howto/regex.rst:83
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""

#:../../howto/regex.rst:92
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""

#:../../howto/regex.rst:97
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""

#:../../howto/regex.rst:103
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""

#:../../howto/regex.rst:110
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""

#:../../howto/regex.rst:115
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""

#:../../howto/regex.rst:123
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""

#:../../howto/regex.rst:130
msgid"``\\d``"
msgstr"``\\d``"

#:../../howto/regex.rst:131
msgid"Matches any decimal digit; this is equivalent to the class ``[0-9]``."
msgstr""

#:../../howto/regex.rst:133
msgid"``\\D``"
msgstr"``\\D``"

#:../../howto/regex.rst:134
msgid""
"Matches any non-digit character; this is equivalent to the class ``[^0-9]``."
msgstr""

#:../../howto/regex.rst:136
msgid"``\\s``"
msgstr"``\\s``"

#:../../howto/regex.rst:137
msgid""
"Matches any whitespace character; this is equivalent to the class "
"``[ \\t\\n\\r\\f\\v]``."
msgstr""

#:../../howto/regex.rst:140
msgid"``\\S``"
msgstr"``\\S``"

#:../../howto/regex.rst:141
msgid""
"Matches any non-whitespace character; this is equivalent to the class ``[^ "
"\\t\\n\\r\\f\\v]``."
msgstr""

#:../../howto/regex.rst:144
msgid"``\\w``"
msgstr"``\\w``"

#:../../howto/regex.rst:145
msgid""
"Matches any alphanumeric character; this is equivalent to the class ``[a-zA-"
"Z0-9_]``."
msgstr""

#:../../howto/regex.rst:148
msgid"``\\W``"
msgstr"``\\W``"

#:../../howto/regex.rst:149
msgid""
"Matches any non-alphanumeric character; this is equivalent to the class "
"``[^a-zA-Z0-9_]``."
msgstr""

#:../../howto/regex.rst:152
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""

#:../../howto/regex.rst:156
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""

#:../../howto/regex.rst:163
msgid"Repeating Things"
msgstr""

#:../../howto/regex.rst:165
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""

#:../../howto/regex.rst:171
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""

#:../../howto/regex.rst:175
msgid""
"For example, ``ca*t`` will match ``'ct'`` (0 ``'a'`` characters), ``'cat'`` "
"(1 ``'a'``), ``'caaat'`` (3 ``'a'`` characters), and so forth."
msgstr""

#:../../howto/regex.rst:178
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""

#:../../howto/regex.rst:183
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""

#:../../howto/regex.rst:189
msgid"Step"
msgstr""

#:../../howto/regex.rst:189
msgid"Matched"
msgstr""

#:../../howto/regex.rst:189
msgid"Explanation"
msgstr""

#:../../howto/regex.rst:191
msgid"1"
msgstr"1"

#:../../howto/regex.rst:191
msgid"``a``"
msgstr"``a``"

#:../../howto/regex.rst:191
msgid"The ``a`` in the RE matches."
msgstr""

#:../../howto/regex.rst:193
msgid"2"
msgstr"2"

#:../../howto/regex.rst:193
msgid"``abcbd``"
msgstr"``abcbd``"

#:../../howto/regex.rst:193
msgid""
"The engine matches ``[bcd]*``, going as far as it can, which is to the end "
"of the string."
msgstr""

#:../../howto/regex.rst:197
msgid"3"
msgstr"3"

#:../../howto/regex.rst:197../../howto/regex.rst:205
msgid"*Failure*"
msgstr""

#:../../howto/regex.rst:197
msgid""
"The engine tries to match ``b``, but the current position is at the end of "
"the string, so it fails."
msgstr""

#:../../howto/regex.rst:202
msgid"4"
msgstr"4"

#:../../howto/regex.rst:202../../howto/regex.rst:213
msgid"``abcb``"
msgstr"``abcb``"

#:../../howto/regex.rst:202
msgid"Back up, so that ``[bcd]*`` matches one less character."
msgstr""

#:../../howto/regex.rst:205
msgid"5"
msgstr"5"

#:../../howto/regex.rst:205
msgid""
"Try ``b`` again, but the current position is at the last character, which is "
"a ``'d'``."
msgstr""

#:../../howto/regex.rst:209../../howto/regex.rst:213
msgid"6"
msgstr"6"

#:../../howto/regex.rst:209
msgid"``abc``"
msgstr"``abc``"

#:../../howto/regex.rst:209
msgid"Back up again, so that ``[bcd]*`` is only matching ``bc``."
msgstr""

#:../../howto/regex.rst:213
msgid""
"Try ``b`` again. This time the character at the current position is "
"``'b'``, so it succeeds."
msgstr""

#:../../howto/regex.rst:219
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""

#:../../howto/regex.rst:226
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""

#:../../howto/regex.rst:233
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""

#:../../howto/regex.rst:238
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""

#:../../howto/regex.rst:244
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""

#:../../howto/regex.rst:248
msgid""
"The simplest case ``{m}`` matches the preceding item exactly *m* times. For "
"example, ``a/{2}b`` will only match ``'a//b'``."
msgstr""

#:../../howto/regex.rst:251
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""

#:../../howto/regex.rst:259
msgid"Using Regular Expressions"
msgstr""

#:../../howto/regex.rst:261
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""

#:../../howto/regex.rst:268
msgid"Compiling Regular Expressions"
msgstr""

#:../../howto/regex.rst:270
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""

#:../../howto/regex.rst:279
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""

#:../../howto/regex.rst:285
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""

#:../../howto/regex.rst:292
msgid""
"Putting REs in strings keeps the Python language simpler, but has one "
"disadvantage which is the topic of the next section."
msgstr""

#:../../howto/regex.rst:299
msgid"The Backslash Plague"
msgstr""

#:../../howto/regex.rst:301
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""

#:../../howto/regex.rst:306
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""

#:../../howto/regex.rst:315
msgid"Characters"
msgstr""

#:../../howto/regex.rst:315
msgid"Stage"
msgstr""

#:../../howto/regex.rst:317
msgid"``\\section``"
msgstr"``\\section``"

#:../../howto/regex.rst:317
msgid"Text string to be matched"
msgstr""

#:../../howto/regex.rst:319
msgid"``\\\\section``"
msgstr"``\\\\section``"

#:../../howto/regex.rst:319
msgid"Escaped backslash for :func:`re.compile`"
msgstr""

#:../../howto/regex.rst:321../../howto/regex.rst:348
msgid"``\"\\\\\\\\section\"``"
msgstr"``\"\\\\\\\\section\"``"

#:../../howto/regex.rst:321
msgid"Escaped backslashes for a string literal"
msgstr""

#:../../howto/regex.rst:324
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""

#:../../howto/regex.rst:330
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""

#:../../howto/regex.rst:336
msgid""
"In addition, special escape sequences that are valid in regular expressions, "
"but not valid as Python string literals, now result in a :exc:"
"`DeprecationWarning` 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""

#:../../howto/regex.rst:344
msgid"Regular String"
msgstr""

#:../../howto/regex.rst:344
msgid"Raw string"
msgstr""

#:../../howto/regex.rst:346
msgid"``\"ab*\"``"
msgstr"``\"ab*\"``"

#:../../howto/regex.rst:346
msgid"``r\"ab*\"``"
msgstr"``r\"ab*\"``"

#:../../howto/regex.rst:348
msgid"``r\"\\\\section\"``"
msgstr"``r\"\\\\section\"``"

#:../../howto/regex.rst:350
msgid"``\"\\\\w+\\\\s+\\\\1\"``"
msgstr"``\"\\\\w+\\\\s+\\\\1\"``"

#:../../howto/regex.rst:350
msgid"``r\"\\w+\\s+\\1\"``"
msgstr"``r\"\\w+\\s+\\1\"``"

#:../../howto/regex.rst:355
msgid"Performing Matches"
msgstr""

#:../../howto/regex.rst:357
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""

#:../../howto/regex.rst:363../../howto/regex.rst:417
#:../../howto/regex.rst:1065
msgid"Method/Attribute"
msgstr""

#:../../howto/regex.rst:363../../howto/regex.rst:417
#:../../howto/regex.rst:1065
msgid"Purpose"
msgstr""

#:../../howto/regex.rst:365
msgid"``match()``"
msgstr"``match()``"

#:../../howto/regex.rst:365
msgid"Determine if the RE matches at the beginning of the string."
msgstr""

#:../../howto/regex.rst:368
msgid"``search()``"
msgstr"``search()``"

#:../../howto/regex.rst:368
msgid"Scan through a string, looking for any location where this RE matches."
msgstr""

#:../../howto/regex.rst:371
msgid"``findall()``"
msgstr"``findall()``"

#:../../howto/regex.rst:371
msgid"Find all substrings where the RE matches, and returns them as a list."
msgstr""

#:../../howto/regex.rst:374
msgid"``finditer()``"
msgstr"``finditer()``"

#:../../howto/regex.rst:374
msgid""
"Find all substrings where the RE matches, and returns them as an :term:"
"`iterator`."
msgstr""

#:../../howto/regex.rst:378
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""

#:../../howto/regex.rst:383
msgid""
"You can learn about this by interactively experimenting with the :mod:`re` "
"module."
msgstr""

#:../../howto/regex.rst:386
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""

#:../../howto/regex.rst:394
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""

#:../../howto/regex.rst:404
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""

#:../../howto/regex.rst:412
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""

#:../../howto/regex.rst:419
msgid"``group()``"
msgstr"``group()``"

#:../../howto/regex.rst:419
msgid"Return the string matched by the RE"
msgstr""

#:../../howto/regex.rst:421
msgid"``start()``"
msgstr"``start()``"

#:../../howto/regex.rst:421
msgid"Return the starting position of the match"
msgstr""

#:../../howto/regex.rst:423
msgid"``end()``"
msgstr"``end()``"

#:../../howto/regex.rst:423
msgid"Return the ending position of the match"
msgstr""

#:../../howto/regex.rst:425
msgid"``span()``"
msgstr"``span()``"

#:../../howto/regex.rst:425
msgid"Return a tuple containing the (start, end) positions of the match"
msgstr""

#:../../howto/regex.rst:429
msgid"Trying these methods will soon clarify their meaning::"
msgstr""

#:../../howto/regex.rst:438
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""

#:../../howto/regex.rst:455
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""

#:../../howto/regex.rst:466
msgid""
"Two pattern methods return all of the matches for a pattern. :meth:`~re."
"Pattern.findall` returns a list of matching strings::"
msgstr""

#:../../howto/regex.rst:473
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:`DeprecationWarning` and will eventually become a :exc:"
"`SyntaxError`. See :ref:`the-backslash-plague`."
msgstr""

#:../../howto/regex.rst:479
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""

#:../../howto/regex.rst:495
msgid"Module-Level Functions"
msgstr""

#:../../howto/regex.rst:497
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""

#:../../howto/regex.rst:509
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""

#:../../howto/regex.rst:514
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""

#:../../howto/regex.rst:522
msgid"Compilation Flags"
msgstr""

#:../../howto/regex.rst:526
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""

#:../../howto/regex.rst:534
msgid""
"Here's a table of the available flags, followed by a more detailed "
"explanation of each one."
msgstr""

#:../../howto/regex.rst:538
msgid"Flag"
msgstr""

#:../../howto/regex.rst:538
msgid"Meaning"
msgstr""

#:../../howto/regex.rst:540
msgid":const:`ASCII`, :const:`A`"
msgstr":const:`ASCII`, :const:`A`"

#:../../howto/regex.rst:540
msgid""
"Makes several escapes like ``\\w``, ``\\b``, ``\\s`` and ``\\d`` match only "
"on ASCII characters with the respective property."
msgstr""

#:../../howto/regex.rst:544
msgid":const:`DOTALL`, :const:`S`"
msgstr":const:`DOTALL`, :const:`S`"

#:../../howto/regex.rst:544
msgid"Make ``.`` match any character, including newlines."
msgstr""

#:../../howto/regex.rst:547
msgid":const:`IGNORECASE`, :const:`I`"
msgstr":const:`IGNORECASE`, :const:`I`"

#:../../howto/regex.rst:547
msgid"Do case-insensitive matches."
msgstr""

#:../../howto/regex.rst:549
msgid":const:`LOCALE`, :const:`L`"
msgstr":const:`LOCALE`, :const:`L`"

#:../../howto/regex.rst:549
msgid"Do a locale-aware match."
msgstr""

#:../../howto/regex.rst:551
msgid":const:`MULTILINE`, :const:`M`"
msgstr":const:`MULTILINE`, :const:`M`"

#:../../howto/regex.rst:551
msgid"Multi-line matching, affecting ``^`` and ``$``."
msgstr""

#:../../howto/regex.rst:554
msgid":const:`VERBOSE`, :const:`X` (for 'extended')"
msgstr""

#:../../howto/regex.rst:554
msgid""
"Enable verbose REs, which can be organized more cleanly and understandably."
msgstr""

#:../../howto/regex.rst:563
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""

#:../../howto/regex.rst:581
msgid""
"Make ``\\w``, ``\\W``, ``\\b``, ``\\B`` and case-insensitive matching "
"dependent on the current locale instead of the Unicode database."
msgstr""

#:../../howto/regex.rst:584
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""

#:../../howto/regex.rst:606
msgid""
"(``^`` and ``$`` haven't been explained yet; they'll be introduced in "
"section :ref:`more-metacharacters`.)"
msgstr""

#:../../howto/regex.rst:609
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""

#:../../howto/regex.rst:622
msgid""
"Makes the ``'.'`` special character match any character at all, including a "
"newline; without this flag, ``'.'`` will match anything *except* a newline."
msgstr""

#:../../howto/regex.rst:630
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""

#:../../howto/regex.rst:639
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 or "
"preceded by an unescaped backslash."
msgstr""