forked from AFPy/python-docs-fr
1828 lines
63 KiB
Plaintext
1828 lines
63 KiB
Plaintext
|
# SOME DESCRIPTIVE TITLE.
|
||
|
# Copyright (C) 2001-2016, Python Software Foundation
|
||
|
# This file is distributed under the same license as the Python package.
|
||
|
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
|
||
|
#
|
||
|
#, fuzzy
|
||
|
msgid ""
|
||
|
msgstr ""
|
||
|
"Project-Id-Version: Python 3.6\n"
|
||
|
"Report-Msgid-Bugs-To: \n"
|
||
|
"POT-Creation-Date: 2016-10-30 10:40+0100\n"
|
||
|
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
|
||
|
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
|
||
|
"Language-Team: LANGUAGE <LL@li.org>\n"
|
||
|
"MIME-Version: 1.0\n"
|
||
|
"Content-Type: text/plain; charset=UTF-8\n"
|
||
|
"Content-Transfer-Encoding: 8bit\n"
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:5
|
||
|
msgid "Regular Expression HOWTO"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:7
|
||
|
msgid "A.M. Kuchling <amk@amk.ca>"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:0
|
||
|
msgid "Abstract"
|
||
|
msgstr "Résumé"
|
||
|
|
||
|
#: ../Doc/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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:24
|
||
|
msgid "Introduction"
|
||
|
msgstr "Introduction"
|
||
|
|
||
|
#: ../Doc/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 ""
|
||
|
|
||
|
#: ../Doc/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 ""
|
||
|
|
||
|
#: ../Doc/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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:51
|
||
|
msgid "Simple Patterns"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/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 ""
|
||
|
|
||
|
#: ../Doc/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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:63
|
||
|
msgid "Matching Characters"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/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 ""
|
||
|
|
||
|
#: ../Doc/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 ""
|
||
|
|
||
|
#: ../Doc/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 ""
|
||
|
|
||
|
#: ../Doc/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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:92
|
||
|
msgid ""
|
||
|
"Metacharacters 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 ""
|
||
|
|
||
|
#: ../Doc/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; ``'^'`` outside a character class will simply "
|
||
|
"match the ``'^'`` character. For example, ``[^5]`` will match any character "
|
||
|
"except ``'5'``."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:102
|
||
|
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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:109
|
||
|
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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:114
|
||
|
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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:122
|
||
|
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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:130
|
||
|
msgid "``\\d``"
|
||
|
msgstr "``\\d``"
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:130
|
||
|
msgid "Matches any decimal digit; this is equivalent to the class ``[0-9]``."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:133
|
||
|
msgid "``\\D``"
|
||
|
msgstr "``\\D``"
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:133
|
||
|
msgid ""
|
||
|
"Matches any non-digit character; this is equivalent to the class ``[^0-9]``."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:137
|
||
|
msgid "``\\s``"
|
||
|
msgstr "``\\s``"
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:136
|
||
|
msgid ""
|
||
|
"Matches any whitespace character; this is equivalent to the class ``[ \\t\\n"
|
||
|
"\\r\\f\\v]``."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:141
|
||
|
msgid "``\\S``"
|
||
|
msgstr "``\\S``"
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:140
|
||
|
msgid ""
|
||
|
"Matches any non-whitespace character; this is equivalent to the class ``[^ "
|
||
|
"\\t\\n\\r\\f\\v]``."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:145
|
||
|
msgid "``\\w``"
|
||
|
msgstr "``\\w``"
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:144
|
||
|
msgid ""
|
||
|
"Matches any alphanumeric character; this is equivalent to the class ``[a-zA-"
|
||
|
"Z0-9_]``."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:149
|
||
|
msgid "``\\W``"
|
||
|
msgstr "``\\W``"
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:148
|
||
|
msgid ""
|
||
|
"Matches any non-alphanumeric character; this is equivalent to the class "
|
||
|
"``[^a-zA-Z0-9_]``."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:151
|
||
|
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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:155
|
||
|
msgid ""
|
||
|
"The final metacharacter in this section is ``.``. It matches anything "
|
||
|
"except a newline character, and there's an alternate mode (``re.DOTALL``) "
|
||
|
"where it will match even a newline. ``'.'`` is often used where you want to "
|
||
|
"match \"any character\"."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:162
|
||
|
msgid "Repeating Things"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:164
|
||
|
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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:170
|
||
|
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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:174
|
||
|
msgid ""
|
||
|
"For example, ``ca*t`` will match ``ct`` (0 ``a`` characters), ``cat`` (1 "
|
||
|
"``a``), ``caaat`` (3 ``a`` characters), and so forth. The RE engine has "
|
||
|
"various internal limitations stemming from the size of C's ``int`` type that "
|
||
|
"will prevent it from matching over 2 billion ``a`` characters; patterns are "
|
||
|
"usually not written to match that much data."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:180
|
||
|
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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:185
|
||
|
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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:191
|
||
|
msgid "Step"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:191
|
||
|
msgid "Matched"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:191
|
||
|
msgid "Explanation"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:193
|
||
|
msgid "1"
|
||
|
msgstr "1"
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:193
|
||
|
msgid "``a``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:193
|
||
|
msgid "The ``a`` in the RE matches."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:195
|
||
|
msgid "2"
|
||
|
msgstr "2"
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:195
|
||
|
msgid "``abcbd``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:195
|
||
|
msgid ""
|
||
|
"The engine matches ``[bcd]*``, going as far as it can, which is to the end "
|
||
|
"of the string."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:199
|
||
|
msgid "3"
|
||
|
msgstr "3"
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:199 ../Doc/howto/regex.rst:207
|
||
|
msgid "*Failure*"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:199
|
||
|
msgid ""
|
||
|
"The engine tries to match ``b``, but the current position is at the end of "
|
||
|
"the string, so it fails."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:204
|
||
|
msgid "4"
|
||
|
msgstr "4"
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:204 ../Doc/howto/regex.rst:215
|
||
|
msgid "``abcb``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:204
|
||
|
msgid "Back up, so that ``[bcd]*`` matches one less character."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:207
|
||
|
msgid "5"
|
||
|
msgstr "5"
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:207
|
||
|
msgid ""
|
||
|
"Try ``b`` again, but the current position is at the last character, which is "
|
||
|
"a ``'d'``."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:211 ../Doc/howto/regex.rst:215
|
||
|
msgid "6"
|
||
|
msgstr "6"
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:211
|
||
|
msgid "``abc``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:211
|
||
|
msgid "Back up again, so that ``[bcd]*`` is only matching ``bc``."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:215
|
||
|
msgid ""
|
||
|
"Try ``b`` again. This time the character at the current position is "
|
||
|
"``'b'``, so it succeeds."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:221
|
||
|
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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:228
|
||
|
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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:235
|
||
|
msgid ""
|
||
|
"There are two more repeating qualifiers. 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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:240
|
||
|
msgid ""
|
||
|
"The most complicated repeated qualifier is ``{m,n}``, where *m* and *n* are "
|
||
|
"decimal integers. This qualifier 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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:246
|
||
|
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 --- actually, the "
|
||
|
"upper bound is the 2-billion limit mentioned earlier, but that might as well "
|
||
|
"be infinity."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:251
|
||
|
msgid ""
|
||
|
"Readers of a reductionist bent may notice that the three other qualifiers "
|
||
|
"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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:259
|
||
|
msgid "Using Regular Expressions"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:268
|
||
|
msgid "Compiling Regular Expressions"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/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 ""
|
||
|
|
||
|
#: ../Doc/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 ""
|
||
|
|
||
|
#: ../Doc/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 ""
|
||
|
|
||
|
#: ../Doc/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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:297
|
||
|
msgid "The Backslash Plague"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:299
|
||
|
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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:304
|
||
|
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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:313
|
||
|
msgid "Characters"
|
||
|
msgstr "Caractères"
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:313
|
||
|
msgid "Stage"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:315
|
||
|
msgid "``\\section``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:315
|
||
|
msgid "Text string to be matched"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:317
|
||
|
msgid "``\\\\section``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:317
|
||
|
msgid "Escaped backslash for :func:`re.compile`"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:319 ../Doc/howto/regex.rst:339
|
||
|
msgid "``\"\\\\\\\\section\"``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:319
|
||
|
msgid "Escaped backslashes for a string literal"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:322
|
||
|
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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:328
|
||
|
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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:335
|
||
|
msgid "Regular String"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:335
|
||
|
msgid "Raw string"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:337
|
||
|
msgid "``\"ab*\"``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:337
|
||
|
msgid "``r\"ab*\"``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:339
|
||
|
msgid "``r\"\\\\section\"``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:341
|
||
|
msgid "``\"\\\\w+\\\\s+\\\\1\"``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:341
|
||
|
msgid "``r\"\\w+\\s+\\1\"``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:346
|
||
|
msgid "Performing Matches"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:348
|
||
|
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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:354 ../Doc/howto/regex.rst:412
|
||
|
#: ../Doc/howto/regex.rst:1029
|
||
|
msgid "Method/Attribute"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:354 ../Doc/howto/regex.rst:412
|
||
|
#: ../Doc/howto/regex.rst:1029
|
||
|
msgid "Purpose"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:356
|
||
|
msgid "``match()``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:356
|
||
|
msgid "Determine if the RE matches at the beginning of the string."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:359
|
||
|
msgid "``search()``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:359
|
||
|
msgid "Scan through a string, looking for any location where this RE matches."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:362
|
||
|
msgid "``findall()``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:362
|
||
|
msgid "Find all substrings where the RE matches, and returns them as a list."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:365
|
||
|
msgid "``finditer()``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:365
|
||
|
msgid ""
|
||
|
"Find all substrings where the RE matches, and returns them as an :term:"
|
||
|
"`iterator`."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:369
|
||
|
msgid ""
|
||
|
":meth:`~re.regex.match` and :meth:`~re.regex.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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:374
|
||
|
msgid ""
|
||
|
"You can learn about this by interactively experimenting with the :mod:`re` "
|
||
|
"module. If you have :mod:`tkinter` available, you may also want to look at :"
|
||
|
"source:`Tools/demo/redemo.py`, a demonstration program included with the "
|
||
|
"Python distribution. It allows you to enter REs and strings, and displays "
|
||
|
"whether the RE matches or fails. :file:`redemo.py` can be quite useful when "
|
||
|
"trying to debug a complicated RE."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:381
|
||
|
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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:389
|
||
|
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:`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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:399
|
||
|
msgid ""
|
||
|
"Now, let's try it on a string that it should match, such as ``tempo``. In "
|
||
|
"this case, :meth:`match` will return a :ref:`match object <match-objects>`, "
|
||
|
"so you should store the result in a variable for later use. ::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:407
|
||
|
msgid ""
|
||
|
"Now you can query the :ref:`match object <match-objects>` for information "
|
||
|
"about the matching string. :ref:`match object <match-objects>` instances "
|
||
|
"also have several methods and attributes; the most important ones are:"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:414
|
||
|
msgid "``group()``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:414
|
||
|
msgid "Return the string matched by the RE"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:416
|
||
|
msgid "``start()``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:416
|
||
|
msgid "Return the starting position of the match"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:418
|
||
|
msgid "``end()``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:418
|
||
|
msgid "Return the ending position of the match"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:420
|
||
|
msgid "``span()``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:420
|
||
|
msgid "Return a tuple containing the (start, end) positions of the match"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:424
|
||
|
msgid "Trying these methods will soon clarify their meaning::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:433
|
||
|
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:`match` method only checks if "
|
||
|
"the RE matches at the start of a string, :meth:`start` will always be zero. "
|
||
|
"However, the :meth:`search` method of patterns scans through the string, so "
|
||
|
"the match may not start at zero in that case. ::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:450
|
||
|
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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:461
|
||
|
msgid ""
|
||
|
"Two pattern methods return all of the matches for a pattern. :meth:`~re."
|
||
|
"regex.findall` returns a list of matching strings::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:468
|
||
|
msgid ""
|
||
|
":meth:`findall` has to create the entire list before it can be returned as "
|
||
|
"the result. The :meth:`~re.regex.finditer` method returns a sequence of :"
|
||
|
"ref:`match object <match-objects>` instances as an :term:`iterator`::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:484
|
||
|
msgid "Module-Level Functions"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:486
|
||
|
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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:498
|
||
|
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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:503
|
||
|
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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:511
|
||
|
msgid "Compilation Flags"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:513
|
||
|
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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:521
|
||
|
msgid ""
|
||
|
"Here's a table of the available flags, followed by a more detailed "
|
||
|
"explanation of each one."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:525
|
||
|
msgid "Flag"
|
||
|
msgstr "Option"
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:525
|
||
|
msgid "Meaning"
|
||
|
msgstr "Signification"
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:527
|
||
|
msgid ":const:`ASCII`, :const:`A`"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:527
|
||
|
msgid ""
|
||
|
"Makes several escapes like ``\\w``, ``\\b``, ``\\s`` and ``\\d`` match only "
|
||
|
"on ASCII characters with the respective property."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:531
|
||
|
msgid ":const:`DOTALL`, :const:`S`"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:531
|
||
|
msgid "Make ``.`` match any character, including newlines"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:534
|
||
|
msgid ":const:`IGNORECASE`, :const:`I`"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:534
|
||
|
msgid "Do case-insensitive matches"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:536
|
||
|
msgid ":const:`LOCALE`, :const:`L`"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:536
|
||
|
msgid "Do a locale-aware match"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:538
|
||
|
msgid ":const:`MULTILINE`, :const:`M`"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:538
|
||
|
msgid "Multi-line matching, affecting ``^`` and ``$``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:541
|
||
|
msgid ":const:`VERBOSE`, :const:`X` (for 'extended')"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:541
|
||
|
msgid ""
|
||
|
"Enable verbose REs, which can be organized more cleanly and understandably."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:550
|
||
|
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, and ``Spam`` will match ``Spam``, ``spam``, or ``spAM``. This "
|
||
|
"lowercasing doesn't take the current locale into account; it will if you "
|
||
|
"also set the :const:`LOCALE` flag."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:561
|
||
|
msgid ""
|
||
|
"Make ``\\w``, ``\\W``, ``\\b``, and ``\\B``, dependent on the current locale "
|
||
|
"instead of the Unicode database."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:564
|
||
|
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 French text, you'd want to be able to write ``\\w+`` to match "
|
||
|
"words, but ``\\w`` only matches the character class ``[A-Za-z]``; it won't "
|
||
|
"match ``'é'`` or ``'ç'``. If your system is configured properly and a "
|
||
|
"French locale is selected, certain C functions will tell the program that "
|
||
|
"``'é'`` 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."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:579
|
||
|
msgid ""
|
||
|
"(``^`` and ``$`` haven't been explained yet; they'll be introduced in "
|
||
|
"section :ref:`more-metacharacters`.)"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:582
|
||
|
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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:595
|
||
|
msgid ""
|
||
|
"Makes the ``'.'`` special character match any character at all, including a "
|
||
|
"newline; without this flag, ``'.'`` will match anything *except* a newline."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:603
|
||
|
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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:612
|
||
|
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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:621
|
||
|
msgid ""
|
||
|
"For example, here's a RE that uses :const:`re.VERBOSE`; see how much easier "
|
||
|
"it is to read? ::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:634
|
||
|
msgid "Without the verbose setting, the RE would look like this::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:640
|
||
|
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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:646
|
||
|
msgid "More Pattern Power"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:648
|
||
|
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 ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:656
|
||
|
msgid "More Metacharacters"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:658
|
||
|
msgid ""
|
||
|
"There are some metacharacters that we haven't covered yet. Most of them "
|
||
|
"will be covered in this section."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:661
|
||
|
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 "
|
||
|
"example, ``\\b`` is an assertion that the current position is located at a "
|
||
|
"word boundary; the position isn't changed by the ``\\b`` at all. This means "
|
||
|
"that zero-width assertions should never be repeated, because if they match "
|
||
|
"once at a given location, they can obviously be matched an infinite number "
|
||
|
"of times."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:677
|
||
|
msgid "``|``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:670
|
||
|
msgid ""
|
||
|
"Alternation, or the \"or\" operator. If A and B are regular expressions, "
|
||
|
"``A|B`` will match any string that matches either ``A`` or ``B``. ``|`` has "
|
||
|
"very low precedence in order to make it work reasonably when you're "
|
||
|
"alternating multi-character strings. ``Crow|Servo`` will match either "
|
||
|
"``Crow`` or ``Servo``, not ``Cro``, a ``'w'`` or an ``'S'``, and ``ervo``."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:676
|
||
|
msgid ""
|
||
|
"To match a literal ``'|'``, use ``\\|``, or enclose it inside a character "
|
||
|
"class, as in ``[|]``."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:693
|
||
|
msgid "``^``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:680
|
||
|
msgid ""
|
||
|
"Matches at the beginning of lines. Unless the :const:`MULTILINE` flag has "
|
||
|
"been set, this will only match at the beginning of the string. In :const:"
|
||
|
"`MULTILINE` mode, this also matches immediately after each newline within "
|
||
|
"the string."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:684
|
||
|
msgid ""
|
||
|
"For example, if you wish to match the word ``From`` only at the beginning of "
|
||
|
"a line, the RE to use is ``^From``. ::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:707
|
||
|
msgid "``$``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:696
|
||
|
msgid ""
|
||
|
"Matches at the end of a line, which is defined as either the end of the "
|
||
|
"string, or any location followed by a newline character. ::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:706
|
||
|
msgid ""
|
||
|
"To match a literal ``'$'``, use ``\\$`` or enclose it inside a character "
|
||
|
"class, as in ``[$]``."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:713
|
||
|
msgid "``\\A``"
|
||
|
msgstr "``\\A``"
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:710
|
||
|
msgid ""
|
||
|
"Matches only at the start of the string. When not in :const:`MULTILINE` "
|
||
|
"mode, ``\\A`` and ``^`` are effectively the same. In :const:`MULTILINE` "
|
||
|
"mode, they're different: ``\\A`` still matches only at the beginning of the "
|
||
|
"string, but ``^`` may match at any location inside the string that follows a "
|
||
|
"newline character."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:716
|
||
|
msgid "``\\Z``"
|
||
|
msgstr "``\\Z``"
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:716
|
||
|
msgid "Matches only at the end of the string."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:751
|
||
|
msgid "``\\b``"
|
||
|
msgstr "``\\b``"
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:719
|
||
|
msgid ""
|
||
|
"Word boundary. This is a zero-width assertion that matches only at the "
|
||
|
"beginning or end of a word. A word is defined as a sequence of alphanumeric "
|
||
|
"characters, so the end of a word is indicated by whitespace or a non-"
|
||
|
"alphanumeric character."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:724
|
||
|
msgid ""
|
||
|
"The following example matches ``class`` only when it's a complete word; it "
|
||
|
"won't match when it's contained inside another word. ::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:735
|
||
|
msgid ""
|
||
|
"There are two subtleties you should remember when using this special "
|
||
|
"sequence. First, this is the worst collision between Python's string "
|
||
|
"literals and regular expression sequences. In Python's string literals, ``"
|
||
|
"\\b`` is the backspace character, ASCII value 8. If you're not using raw "
|
||
|
"strings, then Python will convert the ``\\b`` to a backspace, and your RE "
|
||
|
"won't match as you expect it to. The following example looks the same as our "
|
||
|
"previous RE, but omits the ``'r'`` in front of the RE string. ::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:749
|
||
|
msgid ""
|
||
|
"Second, inside a character class, where there's no use for this assertion, ``"
|
||
|
"\\b`` represents the backspace character, for compatibility with Python's "
|
||
|
"string literals."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:756
|
||
|
msgid "``\\B``"
|
||
|
msgstr "``\\B``"
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:754
|
||
|
msgid ""
|
||
|
"Another zero-width assertion, this is the opposite of ``\\b``, only matching "
|
||
|
"when the current position is not at a word boundary."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:759
|
||
|
msgid "Grouping"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:761
|
||
|
msgid ""
|
||
|
"Frequently you need to obtain more information than just whether the RE "
|
||
|
"matched or not. Regular expressions are often used to dissect strings by "
|
||
|
"writing a RE divided into several subgroups which match different components "
|
||
|
"of interest. For example, an RFC-822 header line is divided into a header "
|
||
|
"name and a value, separated by a ``':'``, like this::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:772
|
||
|
msgid ""
|
||
|
"This can be handled by writing a regular expression which matches an entire "
|
||
|
"header line, and has one group which matches the header name, and another "
|
||
|
"group which matches the header's value."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:776
|
||
|
msgid ""
|
||
|
"Groups are marked by the ``'('``, ``')'`` metacharacters. ``'('`` and "
|
||
|
"``')'`` have much the same meaning as they do in mathematical expressions; "
|
||
|
"they group together the expressions contained inside them, and you can "
|
||
|
"repeat the contents of a group with a repeating qualifier, such as ``*``, ``"
|
||
|
"+``, ``?``, or ``{m,n}``. For example, ``(ab)*`` will match zero or more "
|
||
|
"repetitions of ``ab``. ::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:787
|
||
|
msgid ""
|
||
|
"Groups indicated with ``'('``, ``')'`` also capture the starting and ending "
|
||
|
"index of the text that they match; this can be retrieved by passing an "
|
||
|
"argument to :meth:`group`, :meth:`start`, :meth:`end`, and :meth:`span`. "
|
||
|
"Groups are numbered starting with 0. Group 0 is always present; it's the "
|
||
|
"whole RE, so :ref:`match object <match-objects>` methods all have group 0 as "
|
||
|
"their default argument. Later we'll see how to express groups that don't "
|
||
|
"capture the span of text that they match. ::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:802
|
||
|
msgid ""
|
||
|
"Subgroups are numbered from left to right, from 1 upward. Groups can be "
|
||
|
"nested; to determine the number, just count the opening parenthesis "
|
||
|
"characters, going from left to right. ::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:815
|
||
|
msgid ""
|
||
|
":meth:`group` can be passed multiple group numbers at a time, in which case "
|
||
|
"it will return a tuple containing the corresponding values for those "
|
||
|
"groups. ::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:821
|
||
|
msgid ""
|
||
|
"The :meth:`groups` method returns a tuple containing the strings for all the "
|
||
|
"subgroups, from 1 up to however many there are. ::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:827
|
||
|
msgid ""
|
||
|
"Backreferences in a pattern allow you to specify that the contents of an "
|
||
|
"earlier capturing group must also be found at the current location in the "
|
||
|
"string. For example, ``\\1`` will succeed if the exact contents of group 1 "
|
||
|
"can be found at the current position, and fails otherwise. Remember that "
|
||
|
"Python's string literals also use a backslash followed by numbers to allow "
|
||
|
"including arbitrary characters in a string, so be sure to use a raw string "
|
||
|
"when incorporating backreferences in a RE."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:835
|
||
|
msgid "For example, the following RE detects doubled words in a string. ::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:841
|
||
|
msgid ""
|
||
|
"Backreferences like this aren't often useful for just searching through a "
|
||
|
"string --- there are few text formats which repeat data in this way --- but "
|
||
|
"you'll soon find out that they're *very* useful when performing string "
|
||
|
"substitutions."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:847
|
||
|
msgid "Non-capturing and Named Groups"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:849
|
||
|
msgid ""
|
||
|
"Elaborate REs may use many groups, both to capture substrings of interest, "
|
||
|
"and to group and structure the RE itself. In complex REs, it becomes "
|
||
|
"difficult to keep track of the group numbers. There are two features which "
|
||
|
"help with this problem. Both of them use a common syntax for regular "
|
||
|
"expression extensions, so we'll look at that first."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:855
|
||
|
msgid ""
|
||
|
"Perl 5 is well known for its powerful additions to standard regular "
|
||
|
"expressions. For these new features the Perl developers couldn't choose new "
|
||
|
"single-keystroke metacharacters or new special sequences beginning with ``"
|
||
|
"\\`` without making Perl's regular expressions confusingly different from "
|
||
|
"standard REs. If they chose ``&`` as a new metacharacter, for example, old "
|
||
|
"expressions would be assuming that ``&`` was a regular character and "
|
||
|
"wouldn't have escaped it by writing ``\\&`` or ``[&]``."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:862
|
||
|
msgid ""
|
||
|
"The solution chosen by the Perl developers was to use ``(?...)`` as the "
|
||
|
"extension syntax. ``?`` immediately after a parenthesis was a syntax error "
|
||
|
"because the ``?`` would have nothing to repeat, so this didn't introduce any "
|
||
|
"compatibility problems. The characters immediately after the ``?`` "
|
||
|
"indicate what extension is being used, so ``(?=foo)`` is one thing (a "
|
||
|
"positive lookahead assertion) and ``(?:foo)`` is something else (a non-"
|
||
|
"capturing group containing the subexpression ``foo``)."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:870
|
||
|
msgid ""
|
||
|
"Python supports several of Perl's extensions and adds an extension syntax to "
|
||
|
"Perl's extension syntax. If the first character after the question mark is "
|
||
|
"a ``P``, you know that it's an extension that's specific to Python."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:875
|
||
|
msgid ""
|
||
|
"Now that we've looked at the general extension syntax, we can return to the "
|
||
|
"features that simplify working with groups in complex REs."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:878
|
||
|
msgid ""
|
||
|
"Sometimes you'll want to use a group to denote a part of a regular "
|
||
|
"expression, but aren't interested in retrieving the group's contents. You "
|
||
|
"can make this fact explicit by using a non-capturing group: ``(?:...)``, "
|
||
|
"where you can replace the ``...`` with any other regular expression. ::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:890
|
||
|
msgid ""
|
||
|
"Except for the fact that you can't retrieve the contents of what the group "
|
||
|
"matched, a non-capturing group behaves exactly the same as a capturing "
|
||
|
"group; you can put anything inside it, repeat it with a repetition "
|
||
|
"metacharacter such as ``*``, and nest it within other groups (capturing or "
|
||
|
"non-capturing). ``(?:...)`` is particularly useful when modifying an "
|
||
|
"existing pattern, since you can add new groups without changing how all the "
|
||
|
"other groups are numbered. It should be mentioned that there's no "
|
||
|
"performance difference in searching between capturing and non-capturing "
|
||
|
"groups; neither form is any faster than the other."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:899
|
||
|
msgid ""
|
||
|
"A more significant feature is named groups: instead of referring to them by "
|
||
|
"numbers, groups can be referenced by a name."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:902
|
||
|
msgid ""
|
||
|
"The syntax for a named group is one of the Python-specific extensions: ``(?"
|
||
|
"P<name>...)``. *name* is, obviously, the name of the group. Named groups "
|
||
|
"behave exactly like capturing groups, and additionally associate a name with "
|
||
|
"a group. The :ref:`match object <match-objects>` methods that deal with "
|
||
|
"capturing groups all accept either integers that refer to the group by "
|
||
|
"number or strings that contain the desired group's name. Named groups are "
|
||
|
"still given numbers, so you can retrieve information about a group in two "
|
||
|
"ways::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:917
|
||
|
msgid ""
|
||
|
"Named groups are handy because they let you use easily-remembered names, "
|
||
|
"instead of having to remember numbers. Here's an example RE from the :mod:"
|
||
|
"`imaplib` module::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:928
|
||
|
msgid ""
|
||
|
"It's obviously much easier to retrieve ``m.group('zonem')``, instead of "
|
||
|
"having to remember to retrieve group 9."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:931
|
||
|
msgid ""
|
||
|
"The syntax for backreferences in an expression such as ``(...)\\1`` refers "
|
||
|
"to the number of the group. There's naturally a variant that uses the group "
|
||
|
"name instead of the number. This is another Python extension: ``(?P=name)`` "
|
||
|
"indicates that the contents of the group called *name* should again be "
|
||
|
"matched at the current point. The regular expression for finding doubled "
|
||
|
"words, ``(\\b\\w+)\\s+\\1`` can also be written as ``(?P<word>\\b\\w+)\\s+(?"
|
||
|
"P=word)``::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:944
|
||
|
msgid "Lookahead Assertions"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:946
|
||
|
msgid ""
|
||
|
"Another zero-width assertion is the lookahead assertion. Lookahead "
|
||
|
"assertions are available in both positive and negative form, and look like "
|
||
|
"this:"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:954
|
||
|
msgid "``(?=...)``"
|
||
|
msgstr "``(?=...)``"
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:950
|
||
|
msgid ""
|
||
|
"Positive lookahead assertion. This succeeds if the contained regular "
|
||
|
"expression, represented here by ``...``, successfully matches at the current "
|
||
|
"location, and fails otherwise. But, once the contained expression has been "
|
||
|
"tried, the matching engine doesn't advance at all; the rest of the pattern "
|
||
|
"is tried right where the assertion started."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:959
|
||
|
msgid "``(?!...)``"
|
||
|
msgstr "``(?!...)``"
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:957
|
||
|
msgid ""
|
||
|
"Negative lookahead assertion. This is the opposite of the positive "
|
||
|
"assertion; it succeeds if the contained expression *doesn't* match at the "
|
||
|
"current position in the string."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:961
|
||
|
msgid ""
|
||
|
"To make this concrete, let's look at a case where a lookahead is useful. "
|
||
|
"Consider a simple pattern to match a filename and split it apart into a base "
|
||
|
"name and an extension, separated by a ``.``. For example, in ``news.rc``, "
|
||
|
"``news`` is the base name, and ``rc`` is the filename's extension."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:966
|
||
|
msgid "The pattern to match this is quite simple:"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:968
|
||
|
msgid "``.*[.].*$``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:970
|
||
|
msgid ""
|
||
|
"Notice that the ``.`` needs to be treated specially because it's a "
|
||
|
"metacharacter, so it's inside a character class to only match that specific "
|
||
|
"character. Also notice the trailing ``$``; this is added to ensure that all "
|
||
|
"the rest of the string must be included in the extension. This regular "
|
||
|
"expression matches ``foo.bar`` and ``autoexec.bat`` and ``sendmail.cf`` and "
|
||
|
"``printers.conf``."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:977
|
||
|
msgid ""
|
||
|
"Now, consider complicating the problem a bit; what if you want to match "
|
||
|
"filenames where the extension is not ``bat``? Some incorrect attempts:"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:980
|
||
|
msgid ""
|
||
|
"``.*[.][^b].*$`` The first attempt above tries to exclude ``bat`` by "
|
||
|
"requiring that the first character of the extension is not a ``b``. This is "
|
||
|
"wrong, because the pattern also doesn't match ``foo.bar``."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:984
|
||
|
msgid "``.*[.]([^b]..|.[^a].|..[^t])$``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:986
|
||
|
msgid ""
|
||
|
"The expression gets messier when you try to patch up the first solution by "
|
||
|
"requiring one of the following cases to match: the first character of the "
|
||
|
"extension isn't ``b``; the second character isn't ``a``; or the third "
|
||
|
"character isn't ``t``. This accepts ``foo.bar`` and rejects ``autoexec."
|
||
|
"bat``, but it requires a three-letter extension and won't accept a filename "
|
||
|
"with a two-letter extension such as ``sendmail.cf``. We'll complicate the "
|
||
|
"pattern again in an effort to fix it."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:994
|
||
|
msgid "``.*[.]([^b].?.?|.[^a]?.?|..?[^t]?)$``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:996
|
||
|
msgid ""
|
||
|
"In the third attempt, the second and third letters are all made optional in "
|
||
|
"order to allow matching extensions shorter than three characters, such as "
|
||
|
"``sendmail.cf``."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1000
|
||
|
msgid ""
|
||
|
"The pattern's getting really complicated now, which makes it hard to read "
|
||
|
"and understand. Worse, if the problem changes and you want to exclude both "
|
||
|
"``bat`` and ``exe`` as extensions, the pattern would get even more "
|
||
|
"complicated and confusing."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1005
|
||
|
msgid "A negative lookahead cuts through all this confusion:"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1007
|
||
|
msgid ""
|
||
|
"``.*[.](?!bat$)[^.]*$`` The negative lookahead means: if the expression "
|
||
|
"``bat`` doesn't match at this point, try the rest of the pattern; if ``bat"
|
||
|
"$`` does match, the whole pattern will fail. The trailing ``$`` is required "
|
||
|
"to ensure that something like ``sample.batch``, where the extension only "
|
||
|
"starts with ``bat``, will be allowed. The ``[^.]*`` makes sure that the "
|
||
|
"pattern works when there are multiple dots in the filename."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1014
|
||
|
msgid ""
|
||
|
"Excluding another filename extension is now easy; simply add it as an "
|
||
|
"alternative inside the assertion. The following pattern excludes filenames "
|
||
|
"that end in either ``bat`` or ``exe``:"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1018
|
||
|
msgid "``.*[.](?!bat$|exe$)[^.]*$``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1022
|
||
|
msgid "Modifying Strings"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1024
|
||
|
msgid ""
|
||
|
"Up to this point, we've simply performed searches against a static string. "
|
||
|
"Regular expressions are also commonly used to modify strings in various "
|
||
|
"ways, using the following pattern methods:"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1031
|
||
|
msgid "``split()``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1031
|
||
|
msgid "Split the string into a list, splitting it wherever the RE matches"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1034
|
||
|
msgid "``sub()``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1034
|
||
|
msgid ""
|
||
|
"Find all substrings where the RE matches, and replace them with a different "
|
||
|
"string"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1037
|
||
|
msgid "``subn()``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1037
|
||
|
msgid ""
|
||
|
"Does the same thing as :meth:`sub`, but returns the new string and the "
|
||
|
"number of replacements"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1044
|
||
|
msgid "Splitting Strings"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1046
|
||
|
msgid ""
|
||
|
"The :meth:`split` method of a pattern splits a string apart wherever the RE "
|
||
|
"matches, returning a list of the pieces. It's similar to the :meth:`split` "
|
||
|
"method of strings but provides much more generality in the delimiters that "
|
||
|
"you can split by; string :meth:`split` only supports splitting by whitespace "
|
||
|
"or by a fixed string. As you'd expect, there's a module-level :func:`re."
|
||
|
"split` function, too."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1057
|
||
|
msgid ""
|
||
|
"Split *string* by the matches of the regular expression. If capturing "
|
||
|
"parentheses are used in the RE, then their contents will also be returned as "
|
||
|
"part of the resulting list. If *maxsplit* is nonzero, at most *maxsplit* "
|
||
|
"splits are performed."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1062
|
||
|
msgid ""
|
||
|
"You can limit the number of splits made, by passing a value for *maxsplit*. "
|
||
|
"When *maxsplit* is nonzero, at most *maxsplit* splits will be made, and the "
|
||
|
"remainder of the string is returned as the final element of the list. In "
|
||
|
"the following example, the delimiter is any sequence of non-alphanumeric "
|
||
|
"characters. ::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1074
|
||
|
msgid ""
|
||
|
"Sometimes you're not only interested in what the text between delimiters is, "
|
||
|
"but also need to know what the delimiter was. If capturing parentheses are "
|
||
|
"used in the RE, then their values are also returned as part of the list. "
|
||
|
"Compare the following calls::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1086
|
||
|
msgid ""
|
||
|
"The module-level function :func:`re.split` adds the RE to be used as the "
|
||
|
"first argument, but is otherwise the same. ::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1098
|
||
|
msgid "Search and Replace"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1100
|
||
|
msgid ""
|
||
|
"Another common task is to find all the matches for a pattern, and replace "
|
||
|
"them with a different string. The :meth:`sub` method takes a replacement "
|
||
|
"value, which can be either a string or a function, and the string to be "
|
||
|
"processed."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1107
|
||
|
msgid ""
|
||
|
"Returns the string obtained by replacing the leftmost non-overlapping "
|
||
|
"occurrences of the RE in *string* by the replacement *replacement*. If the "
|
||
|
"pattern isn't found, *string* is returned unchanged."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1111
|
||
|
msgid ""
|
||
|
"The optional argument *count* is the maximum number of pattern occurrences "
|
||
|
"to be replaced; *count* must be a non-negative integer. The default value "
|
||
|
"of 0 means to replace all occurrences."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1115
|
||
|
msgid ""
|
||
|
"Here's a simple example of using the :meth:`sub` method. It replaces colour "
|
||
|
"names with the word ``colour``::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1124
|
||
|
msgid ""
|
||
|
"The :meth:`subn` method does the same work, but returns a 2-tuple containing "
|
||
|
"the new string value and the number of replacements that were performed::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1133
|
||
|
msgid ""
|
||
|
"Empty matches are replaced only when they're not adjacent to a previous "
|
||
|
"match. ::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1140
|
||
|
msgid ""
|
||
|
"If *replacement* 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 the corresponding group in the RE. This lets you "
|
||
|
"incorporate portions of the original text in the resulting replacement "
|
||
|
"string."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1147
|
||
|
msgid ""
|
||
|
"This example matches the word ``section`` followed by a string enclosed in "
|
||
|
"``{``, ``}``, and changes ``section`` to ``subsection``::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1154
|
||
|
msgid ""
|
||
|
"There's also a syntax for referring to named groups as defined by the ``(?"
|
||
|
"P<name>...)`` syntax. ``\\g<name>`` will use the substring matched by the "
|
||
|
"group named ``name``, and ``\\g<number>`` uses the corresponding group "
|
||
|
"number. ``\\g<2>`` is therefore equivalent to ``\\2``, but isn't ambiguous "
|
||
|
"in a replacement string 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 following substitutions are all equivalent, "
|
||
|
"but use all three variations of the replacement string. ::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1171
|
||
|
msgid ""
|
||
|
"*replacement* can also be a function, which gives you even more control. If "
|
||
|
"*replacement* is a function, the function is called for every non-"
|
||
|
"overlapping occurrence of *pattern*. On each call, the function is passed "
|
||
|
"a :ref:`match object <match-objects>` argument for the match and can use "
|
||
|
"this information to compute the desired replacement string and return it."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1177
|
||
|
msgid ""
|
||
|
"In the following example, the replacement function translates decimals into "
|
||
|
"hexadecimal::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1189
|
||
|
msgid ""
|
||
|
"When using the module-level :func:`re.sub` function, the pattern is passed "
|
||
|
"as the first argument. The pattern may be provided as an object or as a "
|
||
|
"string; if you need to specify regular expression flags, you must either use "
|
||
|
"a pattern object as the first parameter, or use embedded modifiers in the "
|
||
|
"pattern string, e.g. ``sub(\"(?i)b+\", \"x\", \"bbbb BBBB\")`` returns ``'x "
|
||
|
"x'``."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1197
|
||
|
msgid "Common Problems"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1199
|
||
|
msgid ""
|
||
|
"Regular expressions are a powerful tool for some applications, but in some "
|
||
|
"ways their behaviour isn't intuitive and at times they don't behave the way "
|
||
|
"you may expect them to. This section will point out some of the most common "
|
||
|
"pitfalls."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1205
|
||
|
msgid "Use String Methods"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1207
|
||
|
msgid ""
|
||
|
"Sometimes using the :mod:`re` module is a mistake. If you're matching a "
|
||
|
"fixed string, or a single character class, and you're not using any :mod:"
|
||
|
"`re` features such as the :const:`IGNORECASE` flag, then the full power of "
|
||
|
"regular expressions may not be required. Strings have several methods for "
|
||
|
"performing operations with fixed strings and they're usually much faster, "
|
||
|
"because the implementation is a single small C loop that's been optimized "
|
||
|
"for the purpose, instead of the large, more generalized regular expression "
|
||
|
"engine."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1215
|
||
|
msgid ""
|
||
|
"One example might be replacing a single fixed string with another one; for "
|
||
|
"example, you might replace ``word`` with ``deed``. ``re.sub()`` seems like "
|
||
|
"the function to use for this, but consider the :meth:`replace` method. Note "
|
||
|
"that :func:`replace` will also replace ``word`` inside words, turning "
|
||
|
"``swordfish`` into ``sdeedfish``, but the naive RE ``word`` would have done "
|
||
|
"that, too. (To avoid performing the substitution on parts of words, the "
|
||
|
"pattern would have to be ``\\bword\\b``, in order to require that ``word`` "
|
||
|
"have a word boundary on either side. This takes the job beyond :meth:"
|
||
|
"`replace`'s abilities.)"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1224
|
||
|
msgid ""
|
||
|
"Another common task is deleting every occurrence of a single character from "
|
||
|
"a string or replacing it with another single character. You might do this "
|
||
|
"with something like ``re.sub('\\n', ' ', S)``, but :meth:`translate` is "
|
||
|
"capable of doing both tasks and will be faster than any regular expression "
|
||
|
"operation can be."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1230
|
||
|
msgid ""
|
||
|
"In short, before turning to the :mod:`re` module, consider whether your "
|
||
|
"problem can be solved with a faster and simpler string method."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1235
|
||
|
msgid "match() versus search()"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1237
|
||
|
msgid ""
|
||
|
"The :func:`match` function only checks if the RE matches at the beginning of "
|
||
|
"the string while :func:`search` will scan forward through the string for a "
|
||
|
"match. It's important to keep this distinction in mind. Remember, :func:"
|
||
|
"`match` will only report a successful match which will start at 0; if the "
|
||
|
"match wouldn't start at zero, :func:`match` will *not* report it. ::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1248
|
||
|
msgid ""
|
||
|
"On the other hand, :func:`search` will scan forward through the string, "
|
||
|
"reporting the first match it finds. ::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1256
|
||
|
msgid ""
|
||
|
"Sometimes you'll be tempted to keep using :func:`re.match`, and just add ``."
|
||
|
"*`` to the front of your RE. Resist this temptation and use :func:`re."
|
||
|
"search` instead. The regular expression compiler does some analysis of REs "
|
||
|
"in order to speed up the process of looking for a match. One such analysis "
|
||
|
"figures out what the first character of a match must be; for example, a "
|
||
|
"pattern starting with ``Crow`` must match starting with a ``'C'``. The "
|
||
|
"analysis lets the engine quickly scan through the string looking for the "
|
||
|
"starting character, only trying the full match if a ``'C'`` is found."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1265
|
||
|
msgid ""
|
||
|
"Adding ``.*`` defeats this optimization, requiring scanning to the end of "
|
||
|
"the string and then backtracking to find a match for the rest of the RE. "
|
||
|
"Use :func:`re.search` instead."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1271
|
||
|
msgid "Greedy versus Non-Greedy"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1273
|
||
|
msgid ""
|
||
|
"When repeating a regular expression, as in ``a*``, the resulting action is "
|
||
|
"to consume as much of the pattern as possible. This fact often bites you "
|
||
|
"when you're trying to match a pair of balanced delimiters, such as the angle "
|
||
|
"brackets surrounding an HTML tag. The naive pattern for matching a single "
|
||
|
"HTML tag doesn't work because of the greedy nature of ``.*``. ::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1287
|
||
|
msgid ""
|
||
|
"The RE matches the ``'<'`` in ``<html>``, and the ``.*`` consumes the rest "
|
||
|
"of the string. There's still more left in the RE, though, and the ``>`` "
|
||
|
"can't match at the end of the string, so the regular expression engine has "
|
||
|
"to backtrack character by character until it finds a match for the ``>``. "
|
||
|
"The final match extends from the ``'<'`` in ``<html>`` to the ``'>'`` in ``</"
|
||
|
"title>``, which isn't what you want."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1294
|
||
|
msgid ""
|
||
|
"In this case, the solution is to use the non-greedy qualifiers ``*?``, ``+?"
|
||
|
"``, ``??``, or ``{m,n}?``, which match as *little* text as possible. In the "
|
||
|
"above example, the ``'>'`` is tried immediately after the first ``'<'`` "
|
||
|
"matches, and when it fails, the engine advances a character at a time, "
|
||
|
"retrying the ``'>'`` at every step. This produces just the right result::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1303
|
||
|
msgid ""
|
||
|
"(Note that parsing HTML or XML with regular expressions is painful. Quick-"
|
||
|
"and-dirty patterns will handle common cases, but HTML and XML have special "
|
||
|
"cases that will break the obvious regular expression; by the time you've "
|
||
|
"written a regular expression that handles all of the possible cases, the "
|
||
|
"patterns will be *very* complicated. Use an HTML or XML parser module for "
|
||
|
"such tasks.)"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1311
|
||
|
msgid "Using re.VERBOSE"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1313
|
||
|
msgid ""
|
||
|
"By now you've probably noticed that regular expressions are a very compact "
|
||
|
"notation, but they're not terribly readable. REs of moderate complexity can "
|
||
|
"become lengthy collections of backslashes, parentheses, and metacharacters, "
|
||
|
"making them difficult to read and understand."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1318
|
||
|
msgid ""
|
||
|
"For such REs, specifying the ``re.VERBOSE`` flag when compiling the regular "
|
||
|
"expression can be helpful, because it allows you to format the regular "
|
||
|
"expression more clearly."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1322
|
||
|
msgid ""
|
||
|
"The ``re.VERBOSE`` flag has several effects. Whitespace in the regular "
|
||
|
"expression that *isn't* inside a character class is ignored. This means "
|
||
|
"that an expression such as ``dog | cat`` is equivalent to the less readable "
|
||
|
"``dog|cat``, but ``[a b]`` will still match the characters ``'a'``, ``'b'``, "
|
||
|
"or a space. In addition, you can also put comments inside a RE; comments "
|
||
|
"extend from a ``#`` character to the next newline. When used with triple-"
|
||
|
"quoted strings, this enables REs to be formatted more neatly::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1339
|
||
|
msgid "This is far more readable than::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1345
|
||
|
msgid "Feedback"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1347
|
||
|
msgid ""
|
||
|
"Regular expressions are a complicated topic. Did this document help you "
|
||
|
"understand them? Were there parts that were unclear, or Problems you "
|
||
|
"encountered that weren't covered here? If so, please send suggestions for "
|
||
|
"improvements to the author."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/howto/regex.rst:1352
|
||
|
msgid ""
|
||
|
"The most complete book on regular expressions is almost certainly Jeffrey "
|
||
|
"Friedl's Mastering Regular Expressions, published by O'Reilly. "
|
||
|
"Unfortunately, it exclusively concentrates on Perl and Java's flavours of "
|
||
|
"regular expressions, and doesn't contain any Python material at all, so it "
|
||
|
"won't be useful as a reference for programming in Python. (The first "
|
||
|
"edition covered Python's now-removed :mod:`regex` module, which won't help "
|
||
|
"you much.) Consider checking it out from your library."
|
||
|
msgstr ""
|