1998-08-10 19:42:37 +00:00
|
|
|
\section{\module{re} ---
|
1999-01-19 20:00:08 +00:00
|
|
|
Perl-style regular expression operations.}
|
1998-08-07 18:57:18 +00:00
|
|
|
\declaremodule{standard}{re}
|
2000-06-27 03:16:04 +00:00
|
|
|
\moduleauthor{Andrew M. Kuchling}{amk1@bigfoot.com}
|
|
|
|
\sectionauthor{Andrew M. Kuchling}{amk1@bigfoot.com}
|
1998-07-23 17:59:49 +00:00
|
|
|
|
|
|
|
|
1999-01-19 20:00:08 +00:00
|
|
|
\modulesynopsis{Perl-style regular expression search and match
|
1998-08-07 18:57:18 +00:00
|
|
|
operations.}
|
1997-08-14 23:12:18 +00:00
|
|
|
|
|
|
|
|
|
|
|
This module provides regular expression matching operations similar to
|
1998-04-09 14:56:04 +00:00
|
|
|
those found in Perl. It's 8-bit clean: the strings being processed
|
|
|
|
may contain both null bytes and characters whose high bit is set. Regular
|
1999-01-19 20:00:08 +00:00
|
|
|
expression pattern strings may not contain null bytes, but can specify
|
|
|
|
the null byte using the \code{\e\var{number}} notation.
|
|
|
|
Characters with the high bit set may be included. The \module{re}
|
|
|
|
module is always available.
|
1997-08-14 23:12:18 +00:00
|
|
|
|
1998-04-09 14:56:04 +00:00
|
|
|
Regular expressions use the backslash character (\character{\e}) to
|
1997-08-14 23:12:18 +00:00
|
|
|
indicate special forms or to allow special characters to be used
|
|
|
|
without invoking their special meaning. This collides with Python's
|
|
|
|
usage of the same character for the same purpose in string literals;
|
|
|
|
for example, to match a literal backslash, one might have to write
|
1998-04-09 14:56:04 +00:00
|
|
|
\code{'\e\e\e\e'} as the pattern string, because the regular expression
|
1998-02-19 15:09:35 +00:00
|
|
|
must be \samp{\e\e}, and each backslash must be expressed as
|
|
|
|
\samp{\e\e} inside a regular Python string literal.
|
1997-08-14 23:12:18 +00:00
|
|
|
|
|
|
|
The solution is to use Python's raw string notation for regular
|
|
|
|
expression patterns; backslashes are not handled in any special way in
|
1998-04-09 14:56:04 +00:00
|
|
|
a string literal prefixed with \character{r}. So \code{r"\e n"} is a
|
|
|
|
two-character string containing \character{\e} and \character{n},
|
|
|
|
while \code{"\e n"} is a one-character string containing a newline.
|
|
|
|
Usually patterns will be expressed in Python code using this raw
|
|
|
|
string notation.
|
1997-08-14 23:12:18 +00:00
|
|
|
|
1998-09-10 20:21:00 +00:00
|
|
|
\subsection{Regular Expression Syntax \label{re-syntax}}
|
1997-08-14 23:12:18 +00:00
|
|
|
|
|
|
|
A regular expression (or RE) specifies a set of strings that matches
|
|
|
|
it; the functions in this module let you check if a particular string
|
|
|
|
matches a given regular expression (or if a given regular expression
|
|
|
|
matches a particular string, which comes down to the same thing).
|
|
|
|
|
|
|
|
Regular expressions can be concatenated to form new regular
|
|
|
|
expressions; if \emph{A} and \emph{B} are both regular expressions,
|
|
|
|
then \emph{AB} is also an regular expression. If a string \emph{p}
|
|
|
|
matches A and another string \emph{q} matches B, the string \emph{pq}
|
|
|
|
will match AB. Thus, complex expressions can easily be constructed
|
|
|
|
from simpler primitive expressions like the ones described here. For
|
|
|
|
details of the theory and implementation of regular expressions,
|
|
|
|
consult the Friedl book referenced below, or almost any textbook about
|
|
|
|
compiler construction.
|
|
|
|
|
1998-10-28 15:44:14 +00:00
|
|
|
A brief explanation of the format of regular expressions follows. For
|
|
|
|
further information and a gentler presentation, consult the Regular
|
|
|
|
Expression HOWTO, accessible from \url{http://www.python.org/doc/howto/}.
|
1997-08-14 23:12:18 +00:00
|
|
|
|
|
|
|
Regular expressions can contain both special and ordinary characters.
|
1998-04-09 14:56:04 +00:00
|
|
|
Most ordinary characters, like \character{A}, \character{a}, or \character{0},
|
1997-08-14 23:12:18 +00:00
|
|
|
are the simplest regular expressions; they simply match themselves.
|
1998-04-09 14:56:04 +00:00
|
|
|
You can concatenate ordinary characters, so \regexp{last} matches the
|
|
|
|
string \code{'last'}. (In the rest of this section, we'll write RE's in
|
|
|
|
\regexp{this special style}, usually without quotes, and strings to be
|
|
|
|
matched \code{'in single quotes'}.)
|
1997-08-14 23:12:18 +00:00
|
|
|
|
1998-04-09 14:56:04 +00:00
|
|
|
Some characters, like \character{|} or \character{(}, are special. Special
|
1997-08-14 23:12:18 +00:00
|
|
|
characters either stand for classes of ordinary characters, or affect
|
|
|
|
how the regular expressions around them are interpreted.
|
|
|
|
|
|
|
|
The special characters are:
|
1998-09-10 20:21:00 +00:00
|
|
|
|
1998-11-30 22:58:12 +00:00
|
|
|
\begin{list}{}{\leftmargin 0.7in \labelwidth 0.65in}
|
1998-09-10 20:21:00 +00:00
|
|
|
|
1998-04-09 14:56:04 +00:00
|
|
|
\item[\character{.}] (Dot.) In the default mode, this matches any
|
1998-02-19 15:09:35 +00:00
|
|
|
character except a newline. If the \constant{DOTALL} flag has been
|
1997-08-14 23:12:18 +00:00
|
|
|
specified, this matches any character including a newline.
|
1998-09-10 20:21:00 +00:00
|
|
|
|
1998-04-09 14:56:04 +00:00
|
|
|
\item[\character{\^}] (Caret.) Matches the start of the string, and in
|
|
|
|
\constant{MULTILINE} mode also matches immediately after each newline.
|
1998-09-10 20:21:00 +00:00
|
|
|
|
1998-04-09 14:56:04 +00:00
|
|
|
\item[\character{\$}] Matches the end of the string, and in
|
1998-02-19 15:09:35 +00:00
|
|
|
\constant{MULTILINE} mode also matches before a newline.
|
1998-04-09 14:56:04 +00:00
|
|
|
\regexp{foo} matches both 'foo' and 'foobar', while the regular
|
|
|
|
expression \regexp{foo\$} matches only 'foo'.
|
1998-09-10 20:21:00 +00:00
|
|
|
|
1998-04-09 14:56:04 +00:00
|
|
|
\item[\character{*}] Causes the resulting RE to
|
1997-08-14 23:12:18 +00:00
|
|
|
match 0 or more repetitions of the preceding RE, as many repetitions
|
1998-04-09 14:56:04 +00:00
|
|
|
as are possible. \regexp{ab*} will
|
1997-08-14 23:12:18 +00:00
|
|
|
match 'a', 'ab', or 'a' followed by any number of 'b's.
|
1998-09-10 20:21:00 +00:00
|
|
|
|
1998-04-09 14:56:04 +00:00
|
|
|
\item[\character{+}] Causes the
|
1997-08-14 23:12:18 +00:00
|
|
|
resulting RE to match 1 or more repetitions of the preceding RE.
|
1998-04-09 14:56:04 +00:00
|
|
|
\regexp{ab+} will match 'a' followed by any non-zero number of 'b's; it
|
1997-08-14 23:12:18 +00:00
|
|
|
will not match just 'a'.
|
1998-09-10 20:21:00 +00:00
|
|
|
|
1998-04-09 14:56:04 +00:00
|
|
|
\item[\character{?}] Causes the resulting RE to
|
|
|
|
match 0 or 1 repetitions of the preceding RE. \regexp{ab?} will
|
1997-08-14 23:12:18 +00:00
|
|
|
match either 'a' or 'ab'.
|
1998-04-09 14:56:04 +00:00
|
|
|
\item[\code{*?}, \code{+?}, \code{??}] The \character{*}, \character{+}, and
|
|
|
|
\character{?} qualifiers are all \dfn{greedy}; they match as much text as
|
1997-08-14 23:12:18 +00:00
|
|
|
possible. Sometimes this behaviour isn't desired; if the RE
|
1998-04-09 14:56:04 +00:00
|
|
|
\regexp{<.*>} is matched against \code{'<H1>title</H1>'}, it will match the
|
|
|
|
entire string, and not just \code{'<H1>'}.
|
|
|
|
Adding \character{?} after the qualifier makes it perform the match in
|
|
|
|
\dfn{non-greedy} or \dfn{minimal} fashion; as \emph{few} characters as
|
|
|
|
possible will be matched. Using \regexp{.*?} in the previous
|
|
|
|
expression will match only \code{'<H1>'}.
|
1998-09-10 20:21:00 +00:00
|
|
|
|
1997-12-22 22:41:40 +00:00
|
|
|
\item[\code{\{\var{m},\var{n}\}}] Causes the resulting RE to match from
|
|
|
|
\var{m} to \var{n} repetitions of the preceding RE, attempting to
|
1998-10-28 15:44:14 +00:00
|
|
|
match as many repetitions as possible. For example, \regexp{a\{3,5\}}
|
|
|
|
will match from 3 to 5 \character{a} characters. Omitting \var{n}
|
|
|
|
specifies an infinite upper bound; you can't omit \var{m}.
|
1998-09-10 20:21:00 +00:00
|
|
|
|
1997-12-22 22:41:40 +00:00
|
|
|
\item[\code{\{\var{m},\var{n}\}?}] Causes the resulting RE to
|
|
|
|
match from \var{m} to \var{n} repetitions of the preceding RE,
|
|
|
|
attempting to match as \emph{few} repetitions as possible. This is
|
|
|
|
the non-greedy version of the previous qualifier. For example, on the
|
1998-09-10 20:21:00 +00:00
|
|
|
6-character string \code{'aaaaaa'}, \regexp{a\{3,5\}} will match 5
|
|
|
|
\character{a} characters, while \regexp{a\{3,5\}?} will only match 3
|
|
|
|
characters.
|
|
|
|
|
|
|
|
\item[\character{\e}] Either escapes special characters (permitting
|
|
|
|
you to match characters like \character{*}, \character{?}, and so
|
|
|
|
forth), or signals a special sequence; special sequences are discussed
|
|
|
|
below.
|
1997-08-14 23:12:18 +00:00
|
|
|
|
|
|
|
If you're not using a raw string to
|
|
|
|
express the pattern, remember that Python also uses the
|
|
|
|
backslash as an escape sequence in string literals; if the escape
|
|
|
|
sequence isn't recognized by Python's parser, the backslash and
|
|
|
|
subsequent character are included in the resulting string. However,
|
|
|
|
if Python would recognize the resulting sequence, the backslash should
|
1998-01-12 19:16:24 +00:00
|
|
|
be repeated twice. This is complicated and hard to understand, so
|
|
|
|
it's highly recommended that you use raw strings for all but the
|
|
|
|
simplest expressions.
|
1998-09-10 20:21:00 +00:00
|
|
|
|
1997-08-14 23:12:18 +00:00
|
|
|
\item[\code{[]}] Used to indicate a set of characters. Characters can
|
1997-12-11 20:19:08 +00:00
|
|
|
be listed individually, or a range of characters can be indicated by
|
1998-04-09 14:56:04 +00:00
|
|
|
giving two characters and separating them by a \character{-}. Special
|
|
|
|
characters are not active inside sets. For example, \regexp{[akm\$]}
|
1998-04-03 05:59:05 +00:00
|
|
|
will match any of the characters \character{a}, \character{k},
|
1998-04-09 14:56:04 +00:00
|
|
|
\character{m}, or \character{\$}; \regexp{[a-z]}
|
|
|
|
will match any lowercase letter, and \code{[a-zA-Z0-9]} matches any
|
1998-11-30 22:58:12 +00:00
|
|
|
letter or digit. Character classes such as \code{\e w} or \code{\e S}
|
|
|
|
(defined below) are also acceptable inside a range. If you want to
|
1998-04-09 14:56:04 +00:00
|
|
|
include a \character{]} or a \character{-} inside a set, precede it with a
|
|
|
|
backslash, or place it as the first character. The
|
|
|
|
pattern \regexp{[]]} will match \code{']'}, for example.
|
|
|
|
|
|
|
|
You can match the characters not within a range by \dfn{complementing}
|
|
|
|
the set. This is indicated by including a
|
|
|
|
\character{\^} as the first character of the set; \character{\^} elsewhere will
|
1998-12-28 19:03:24 +00:00
|
|
|
simply match the \character{\^} character. For example, \regexp{[{\^}5]}
|
1998-04-09 14:56:04 +00:00
|
|
|
will match any character except \character{5}.
|
1997-08-14 23:12:18 +00:00
|
|
|
|
1998-04-09 14:56:04 +00:00
|
|
|
\item[\character{|}]\code{A|B}, where A and B can be arbitrary REs,
|
1997-08-14 23:12:18 +00:00
|
|
|
creates a regular expression that will match either A or B. This can
|
1998-04-09 14:56:04 +00:00
|
|
|
be used inside groups (see below) as well. To match a literal \character{|},
|
|
|
|
use \regexp{\e|}, or enclose it inside a character class, as in \regexp{[|]}.
|
1998-09-10 20:21:00 +00:00
|
|
|
|
1997-12-11 20:19:08 +00:00
|
|
|
\item[\code{(...)}] Matches whatever regular expression is inside the
|
|
|
|
parentheses, and indicates the start and end of a group; the contents
|
|
|
|
of a group can be retrieved after a match has been performed, and can
|
1998-04-09 14:56:04 +00:00
|
|
|
be matched later in the string with the \regexp{\e \var{number}} special
|
1998-09-10 20:21:00 +00:00
|
|
|
sequence, described below. To match the literals \character{(} or
|
|
|
|
\character{')}, use \regexp{\e(} or \regexp{\e)}, or enclose them
|
|
|
|
inside a character class: \regexp{[(] [)]}.
|
|
|
|
|
|
|
|
\item[\code{(?...)}] This is an extension notation (a \character{?}
|
|
|
|
following a \character{(} is not meaningful otherwise). The first
|
|
|
|
character after the \character{?}
|
1997-12-08 17:33:40 +00:00
|
|
|
determines what the meaning and further syntax of the construct is.
|
1998-04-02 01:32:24 +00:00
|
|
|
Extensions usually do not create a new group;
|
1998-04-09 14:56:04 +00:00
|
|
|
\regexp{(?P<\var{name}>...)} is the only exception to this rule.
|
1997-12-08 17:33:40 +00:00
|
|
|
Following are the currently supported extensions.
|
1998-09-10 20:21:00 +00:00
|
|
|
|
2000-09-25 17:52:40 +00:00
|
|
|
\item[\code{(?iLmsux)}] (One or more letters from the set \character{i},
|
|
|
|
\character{L}, \character{m}, \character{s}, \character{u},
|
|
|
|
\character{x}.) The group matches the empty string; the letters set
|
|
|
|
the corresponding flags (\constant{re.I}, \constant{re.L},
|
|
|
|
\constant{re.M}, \constant{re.S}, \constant{re.U}, \constant{re.X})
|
|
|
|
for the entire regular expression. This is useful if you wish to
|
|
|
|
include the flags as part of the regular expression, instead of
|
|
|
|
passing a \var{flag} argument to the \function{compile()} function.
|
1998-09-10 20:21:00 +00:00
|
|
|
|
1997-08-14 23:12:18 +00:00
|
|
|
\item[\code{(?:...)}] A non-grouping version of regular parentheses.
|
1998-04-09 14:56:04 +00:00
|
|
|
Matches whatever regular expression is inside the parentheses, but the
|
|
|
|
substring matched by the
|
1997-08-14 23:12:18 +00:00
|
|
|
group \emph{cannot} be retrieved after performing a match or
|
|
|
|
referenced later in the pattern.
|
1998-09-10 20:21:00 +00:00
|
|
|
|
1997-08-14 23:12:18 +00:00
|
|
|
\item[\code{(?P<\var{name}>...)}] Similar to regular parentheses, but
|
1998-04-02 01:32:24 +00:00
|
|
|
the substring matched by the group is accessible via the symbolic group
|
1997-08-14 23:12:18 +00:00
|
|
|
name \var{name}. Group names must be valid Python identifiers. A
|
|
|
|
symbolic group is also a numbered group, just as if the group were not
|
|
|
|
named. So the group named 'id' in the example above can also be
|
|
|
|
referenced as the numbered group 1.
|
|
|
|
|
1997-12-11 20:19:08 +00:00
|
|
|
For example, if the pattern is
|
1998-04-09 14:56:04 +00:00
|
|
|
\regexp{(?P<id>[a-zA-Z_]\e w*)}, the group can be referenced by its
|
1997-08-14 23:12:18 +00:00
|
|
|
name in arguments to methods of match objects, such as \code{m.group('id')}
|
1998-01-12 19:16:24 +00:00
|
|
|
or \code{m.end('id')}, and also by name in pattern text
|
1998-04-09 14:56:04 +00:00
|
|
|
(e.g. \regexp{(?P=id)}) and replacement text (e.g. \code{\e g<id>}).
|
1998-09-10 20:21:00 +00:00
|
|
|
|
1998-01-12 19:16:24 +00:00
|
|
|
\item[\code{(?P=\var{name})}] Matches whatever text was matched by the
|
|
|
|
earlier group named \var{name}.
|
1998-09-10 20:21:00 +00:00
|
|
|
|
1998-01-12 19:16:24 +00:00
|
|
|
\item[\code{(?\#...)}] A comment; the contents of the parentheses are
|
|
|
|
simply ignored.
|
1998-09-10 20:21:00 +00:00
|
|
|
|
1998-04-09 14:56:04 +00:00
|
|
|
\item[\code{(?=...)}] Matches if \regexp{...} matches next, but doesn't
|
1998-01-12 19:16:24 +00:00
|
|
|
consume any of the string. This is called a lookahead assertion. For
|
1998-04-09 14:56:04 +00:00
|
|
|
example, \regexp{Isaac (?=Asimov)} will match \code{'Isaac~'} only if it's
|
|
|
|
followed by \code{'Asimov'}.
|
1998-09-10 20:21:00 +00:00
|
|
|
|
1998-04-09 14:56:04 +00:00
|
|
|
\item[\code{(?!...)}] Matches if \regexp{...} doesn't match next. This
|
1998-01-12 19:16:24 +00:00
|
|
|
is a negative lookahead assertion. For example,
|
1998-04-09 14:56:04 +00:00
|
|
|
\regexp{Isaac (?!Asimov)} will match \code{'Isaac~'} only if it's \emph{not}
|
|
|
|
followed by \code{'Asimov'}.
|
1997-12-08 17:33:40 +00:00
|
|
|
|
1998-02-16 21:21:13 +00:00
|
|
|
\end{list}
|
1997-08-14 23:12:18 +00:00
|
|
|
|
1998-04-09 14:56:04 +00:00
|
|
|
The special sequences consist of \character{\e} and a character from the
|
1997-08-14 23:12:18 +00:00
|
|
|
list below. If the ordinary character is not on the list, then the
|
|
|
|
resulting RE will match the second character. For example,
|
1998-04-09 14:56:04 +00:00
|
|
|
\regexp{\e\$} matches the character \character{\$}.
|
1997-08-14 23:12:18 +00:00
|
|
|
|
1998-11-30 22:58:12 +00:00
|
|
|
\begin{list}{}{\leftmargin 0.7in \labelwidth 0.65in}
|
1997-08-14 23:12:18 +00:00
|
|
|
|
|
|
|
\item[\code{\e \var{number}}] Matches the contents of the group of the
|
1997-12-08 17:33:40 +00:00
|
|
|
same number. Groups are numbered starting from 1. For example,
|
1998-04-09 14:56:04 +00:00
|
|
|
\regexp{(.+) \e 1} matches \code{'the the'} or \code{'55 55'}, but not
|
|
|
|
\code{'the end'} (note
|
1997-12-08 17:33:40 +00:00
|
|
|
the space after the group). This special sequence can only be used to
|
|
|
|
match one of the first 99 groups. If the first digit of \var{number}
|
|
|
|
is 0, or \var{number} is 3 octal digits long, it will not be interpreted
|
|
|
|
as a group match, but as the character with octal value \var{number}.
|
1998-04-09 14:56:04 +00:00
|
|
|
Inside the \character{[} and \character{]} of a character class, all numeric
|
1998-04-02 01:32:24 +00:00
|
|
|
escapes are treated as characters.
|
2000-09-25 17:52:40 +00:00
|
|
|
|
1997-08-14 23:12:18 +00:00
|
|
|
\item[\code{\e A}] Matches only at the start of the string.
|
2000-09-25 17:52:40 +00:00
|
|
|
|
1997-08-14 23:12:18 +00:00
|
|
|
\item[\code{\e b}] Matches the empty string, but 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
|
1997-12-11 20:19:08 +00:00
|
|
|
whitespace or a non-alphanumeric character. Inside a character range,
|
1998-04-09 14:56:04 +00:00
|
|
|
\regexp{\e b} represents the backspace character, for compatibility with
|
1997-12-11 20:19:08 +00:00
|
|
|
Python's string literals.
|
2000-09-25 17:52:40 +00:00
|
|
|
|
1997-12-08 17:33:40 +00:00
|
|
|
\item[\code{\e B}] Matches the empty string, but only when it is
|
|
|
|
\emph{not} at the beginning or end of a word.
|
2000-09-25 17:52:40 +00:00
|
|
|
|
1997-08-14 23:12:18 +00:00
|
|
|
\item[\code{\e d}]Matches any decimal digit; this is
|
1998-04-09 14:56:04 +00:00
|
|
|
equivalent to the set \regexp{[0-9]}.
|
2000-09-25 17:52:40 +00:00
|
|
|
|
1997-08-14 23:12:18 +00:00
|
|
|
\item[\code{\e D}]Matches any non-digit character; this is
|
1998-12-28 19:03:24 +00:00
|
|
|
equivalent to the set \regexp{[{\^}0-9]}.
|
2000-09-25 17:52:40 +00:00
|
|
|
|
1997-08-14 23:12:18 +00:00
|
|
|
\item[\code{\e s}]Matches any whitespace character; this is
|
1998-04-09 14:56:04 +00:00
|
|
|
equivalent to the set \regexp{[ \e t\e n\e r\e f\e v]}.
|
2000-09-25 17:52:40 +00:00
|
|
|
|
1997-08-14 23:12:18 +00:00
|
|
|
\item[\code{\e S}]Matches any non-whitespace character; this is
|
1998-04-09 14:56:04 +00:00
|
|
|
equivalent to the set \regexp{[\^\ \e t\e n\e r\e f\e v]}.
|
2000-09-25 17:52:40 +00:00
|
|
|
|
|
|
|
\item[\code{\e w}]When the \constant{LOCALE} and \constant{UNICODE}
|
|
|
|
flags are not specified,
|
1998-01-12 19:16:24 +00:00
|
|
|
matches any alphanumeric character; this is equivalent to the set
|
1998-04-09 14:56:04 +00:00
|
|
|
\regexp{[a-zA-Z0-9_]}. With \constant{LOCALE}, it will match the set
|
2000-09-25 17:52:40 +00:00
|
|
|
\regexp{[0-9_]} plus whatever characters are defined as letters for
|
|
|
|
the current locale. If \constant{UNICODE} is set, this will match the
|
|
|
|
characters \regexp{[0-9_]} plus whatever is classified as alphanumeric
|
|
|
|
in the Unicode character properties database.
|
|
|
|
|
|
|
|
\item[\code{\e W}]When the \constant{LOCALE} and \constant{UNICODE}
|
|
|
|
flags are not specified, matches any non-alphanumeric character; this
|
|
|
|
is equivalent to the set \regexp{[{\^}a-zA-Z0-9_]}. With
|
|
|
|
\constant{LOCALE}, it will match any character not in the set
|
|
|
|
\regexp{[0-9_]}, and not defined as a letter for the current locale.
|
|
|
|
If \constant{UNICODE} is set, this will match anything other than
|
|
|
|
\regexp{[0-9_]} and characters marked at alphanumeric in the Unicode
|
|
|
|
character properties database.
|
1997-08-14 23:12:18 +00:00
|
|
|
|
|
|
|
\item[\code{\e Z}]Matches only at the end of the string.
|
|
|
|
|
|
|
|
\item[\code{\e \e}] Matches a literal backslash.
|
|
|
|
|
1998-02-16 21:21:13 +00:00
|
|
|
\end{list}
|
1997-08-14 23:12:18 +00:00
|
|
|
|
1998-04-20 16:28:44 +00:00
|
|
|
|
1998-12-22 18:19:45 +00:00
|
|
|
\subsection{Matching vs. Searching \label{matching-searching}}
|
|
|
|
\sectionauthor{Fred L. Drake, Jr.}{fdrake@acm.org}
|
|
|
|
|
|
|
|
Python offers two different primitive operations based on regular
|
|
|
|
expressions: match and search. If you are accustomed to Perl's
|
|
|
|
semantics, the search operation is what you're looking for. See the
|
|
|
|
\function{search()} function and corresponding method of compiled
|
|
|
|
regular expression objects.
|
|
|
|
|
|
|
|
Note that match may differ from search using a regular expression
|
1999-06-29 21:21:19 +00:00
|
|
|
beginning with \character{\^}: \character{\^} matches only at the
|
|
|
|
start of the string, or in \constant{MULTILINE} mode also immediately
|
|
|
|
following a newline. The ``match'' operation succeeds only if the
|
|
|
|
pattern matches at the start of the string regardless of mode, or at
|
|
|
|
the starting position given by the optional \var{pos} argument
|
|
|
|
regardless of whether a newline precedes it.
|
1998-12-22 18:19:45 +00:00
|
|
|
|
|
|
|
% Examples from Tim Peters:
|
|
|
|
\begin{verbatim}
|
|
|
|
re.compile("a").match("ba", 1) # succeeds
|
|
|
|
re.compile("^a").search("ba", 1) # fails; 'a' not at start
|
|
|
|
re.compile("^a").search("\na", 1) # fails; 'a' not at start
|
|
|
|
re.compile("^a", re.M).search("\na", 1) # succeeds
|
|
|
|
re.compile("^a", re.M).search("ba", 1) # fails; no preceding \n
|
|
|
|
\end{verbatim}
|
|
|
|
|
|
|
|
|
1997-08-14 23:12:18 +00:00
|
|
|
\subsection{Module Contents}
|
1997-12-29 21:39:39 +00:00
|
|
|
\nodename{Contents of Module re}
|
1997-08-14 23:12:18 +00:00
|
|
|
|
|
|
|
The module defines the following functions and constants, and an exception:
|
|
|
|
|
|
|
|
|
1998-03-08 07:38:27 +00:00
|
|
|
\begin{funcdesc}{compile}{pattern\optional{, flags}}
|
1997-08-14 23:12:18 +00:00
|
|
|
Compile a regular expression pattern into a regular expression
|
1998-02-19 15:09:35 +00:00
|
|
|
object, which can be used for matching using its \function{match()} and
|
|
|
|
\function{search()} methods, described below.
|
1997-08-14 23:12:18 +00:00
|
|
|
|
1997-12-08 17:33:40 +00:00
|
|
|
The expression's behaviour can be modified by specifying a
|
|
|
|
\var{flags} value. Values can be any of the following variables,
|
|
|
|
combined using bitwise OR (the \code{|} operator).
|
|
|
|
|
1998-04-03 05:59:05 +00:00
|
|
|
The sequence
|
|
|
|
|
|
|
|
\begin{verbatim}
|
|
|
|
prog = re.compile(pat)
|
|
|
|
result = prog.match(str)
|
|
|
|
\end{verbatim}
|
|
|
|
|
|
|
|
is equivalent to
|
|
|
|
|
|
|
|
\begin{verbatim}
|
|
|
|
result = re.match(pat, str)
|
|
|
|
\end{verbatim}
|
|
|
|
|
|
|
|
but the version using \function{compile()} is more efficient when the
|
|
|
|
expression will be used several times in a single program.
|
|
|
|
%(The compiled version of the last pattern passed to
|
|
|
|
%\function{regex.match()} or \function{regex.search()} is cached, so
|
|
|
|
%programs that use only a single regular expression at a time needn't
|
|
|
|
%worry about compiling regular expressions.)
|
|
|
|
\end{funcdesc}
|
|
|
|
|
1998-03-08 07:38:27 +00:00
|
|
|
\begin{datadesc}{I}
|
|
|
|
\dataline{IGNORECASE}
|
1998-04-09 14:56:04 +00:00
|
|
|
Perform case-insensitive matching; expressions like \regexp{[A-Z]} will match
|
1997-12-11 20:19:08 +00:00
|
|
|
lowercase letters, too. This is not affected by the current locale.
|
1998-03-08 07:38:27 +00:00
|
|
|
\end{datadesc}
|
1997-12-08 17:33:40 +00:00
|
|
|
|
1998-03-08 07:38:27 +00:00
|
|
|
\begin{datadesc}{L}
|
|
|
|
\dataline{LOCALE}
|
2000-09-25 17:52:40 +00:00
|
|
|
Make \regexp{\e w}, \regexp{\e W}, \regexp{\e b}, and
|
|
|
|
\regexp{\e B} dependent on the current locale.
|
1998-03-08 07:38:27 +00:00
|
|
|
\end{datadesc}
|
1997-12-08 17:33:40 +00:00
|
|
|
|
1998-03-08 07:38:27 +00:00
|
|
|
\begin{datadesc}{M}
|
|
|
|
\dataline{MULTILINE}
|
1998-04-09 14:56:04 +00:00
|
|
|
When specified, the pattern character \character{\^} matches at the
|
1998-01-12 19:16:24 +00:00
|
|
|
beginning of the string and at the beginning of each line
|
|
|
|
(immediately following each newline); and the pattern character
|
1998-04-09 14:56:04 +00:00
|
|
|
\character{\$} matches at the end of the string and at the end of each line
|
1997-12-11 20:19:08 +00:00
|
|
|
(immediately preceding each newline).
|
1998-04-09 14:56:04 +00:00
|
|
|
By default, \character{\^} matches only at the beginning of the string, and
|
|
|
|
\character{\$} only at the end of the string and immediately before the
|
1997-12-08 17:33:40 +00:00
|
|
|
newline (if any) at the end of the string.
|
1998-03-08 07:38:27 +00:00
|
|
|
\end{datadesc}
|
1997-12-11 20:19:08 +00:00
|
|
|
|
1998-03-08 07:38:27 +00:00
|
|
|
\begin{datadesc}{S}
|
|
|
|
\dataline{DOTALL}
|
2000-09-25 17:52:40 +00:00
|
|
|
Make the \character{.} special character match any character at all,
|
|
|
|
including a newline; without this flag, \character{.} will match
|
|
|
|
anything \emph{except} a newline.
|
|
|
|
\end{datadesc}
|
|
|
|
|
|
|
|
\begin{datadesc}{U}
|
|
|
|
\dataline{UNICODE}
|
|
|
|
Make \regexp{\e w}, \regexp{\e W}, \regexp{\e b}, and
|
|
|
|
\regexp{\e B} dependent on the Unicode character properties database.
|
|
|
|
\versionadded{2.0}
|
1998-03-08 07:38:27 +00:00
|
|
|
\end{datadesc}
|
1997-12-08 17:33:40 +00:00
|
|
|
|
1998-03-08 07:38:27 +00:00
|
|
|
\begin{datadesc}{X}
|
|
|
|
\dataline{VERBOSE}
|
1998-04-09 14:56:04 +00:00
|
|
|
This flag allows you to write regular expressions that look nicer.
|
|
|
|
Whitespace within the pattern is ignored,
|
1997-12-11 20:19:08 +00:00
|
|
|
except when in a character class or preceded by an unescaped
|
1998-04-09 14:56:04 +00:00
|
|
|
backslash, and, when a line contains a \character{\#} neither in a character
|
1997-12-11 20:19:08 +00:00
|
|
|
class or preceded by an unescaped backslash, all characters from the
|
1998-04-09 14:56:04 +00:00
|
|
|
leftmost such \character{\#} through the end of the line are ignored.
|
|
|
|
% XXX should add an example here
|
1998-03-08 07:38:27 +00:00
|
|
|
\end{datadesc}
|
1997-12-08 17:33:40 +00:00
|
|
|
|
|
|
|
|
1998-10-13 16:03:52 +00:00
|
|
|
\begin{funcdesc}{search}{pattern, string\optional{, flags}}
|
|
|
|
Scan through \var{string} looking for a location where the regular
|
|
|
|
expression \var{pattern} produces a match, and return a
|
|
|
|
corresponding \class{MatchObject} instance.
|
|
|
|
Return \code{None} if no
|
|
|
|
position in the string matches the pattern; note that this is
|
|
|
|
different from finding a zero-length match at some point in the string.
|
1997-08-14 23:12:18 +00:00
|
|
|
\end{funcdesc}
|
|
|
|
|
1998-03-08 07:38:27 +00:00
|
|
|
\begin{funcdesc}{match}{pattern, string\optional{, flags}}
|
1997-08-14 23:12:18 +00:00
|
|
|
If zero or more characters at the beginning of \var{string} match
|
|
|
|
the regular expression \var{pattern}, return a corresponding
|
1998-02-19 15:09:35 +00:00
|
|
|
\class{MatchObject} instance. Return \code{None} if the string does not
|
1997-08-14 23:12:18 +00:00
|
|
|
match the pattern; note that this is different from a zero-length
|
|
|
|
match.
|
1998-12-22 18:19:45 +00:00
|
|
|
|
|
|
|
\strong{Note:} If you want to locate a match anywhere in
|
|
|
|
\var{string}, use \method{search()} instead.
|
1997-08-14 23:12:18 +00:00
|
|
|
\end{funcdesc}
|
|
|
|
|
2000-09-07 14:00:51 +00:00
|
|
|
\begin{funcdesc}{split}{pattern, string\optional{, maxsplit\code{ = 0}}}
|
1997-08-14 23:12:18 +00:00
|
|
|
Split \var{string} by the occurrences of \var{pattern}. If
|
1998-08-14 14:49:20 +00:00
|
|
|
capturing parentheses are used in \var{pattern}, then the text of all
|
|
|
|
groups in the pattern are also returned as part of the resulting list.
|
1998-01-12 18:58:53 +00:00
|
|
|
If \var{maxsplit} is nonzero, at most \var{maxsplit} splits
|
|
|
|
occur, and the remainder of the string is returned as the final
|
|
|
|
element of the list. (Incompatibility note: in the original Python
|
|
|
|
1.5 release, \var{maxsplit} was ignored. This has been fixed in
|
|
|
|
later releases.)
|
1998-12-22 18:19:45 +00:00
|
|
|
|
1998-02-13 06:58:54 +00:00
|
|
|
\begin{verbatim}
|
1998-08-14 14:49:20 +00:00
|
|
|
>>> re.split('\W+', 'Words, words, words.')
|
1997-08-14 23:12:18 +00:00
|
|
|
['Words', 'words', 'words', '']
|
1998-08-14 14:49:20 +00:00
|
|
|
>>> re.split('(\W+)', 'Words, words, words.')
|
1997-08-14 23:12:18 +00:00
|
|
|
['Words', ', ', 'words', ', ', 'words', '.', '']
|
1998-08-14 14:49:20 +00:00
|
|
|
>>> re.split('\W+', 'Words, words, words.', 1)
|
1998-01-12 18:58:53 +00:00
|
|
|
['Words', 'words, words.']
|
1998-02-13 06:58:54 +00:00
|
|
|
\end{verbatim}
|
1998-12-22 18:19:45 +00:00
|
|
|
|
1997-08-14 23:12:18 +00:00
|
|
|
This function combines and extends the functionality of
|
1998-02-19 15:09:35 +00:00
|
|
|
the old \function{regsub.split()} and \function{regsub.splitx()}.
|
1997-08-14 23:12:18 +00:00
|
|
|
\end{funcdesc}
|
|
|
|
|
1998-06-29 22:48:01 +00:00
|
|
|
\begin{funcdesc}{findall}{pattern, string}
|
|
|
|
Return a list of all non-overlapping matches of \var{pattern} in
|
|
|
|
\var{string}. If one or more groups are present in the pattern,
|
|
|
|
return a list of groups; this will be a list of tuples if the pattern
|
|
|
|
has more than one group. Empty matches are included in the result.
|
1999-02-02 19:01:37 +00:00
|
|
|
\versionadded{1.5.2}
|
1998-06-29 22:48:01 +00:00
|
|
|
\end{funcdesc}
|
|
|
|
|
1998-03-08 07:38:27 +00:00
|
|
|
\begin{funcdesc}{sub}{pattern, repl, string\optional{, count\code{ = 0}}}
|
1997-08-14 23:12:18 +00:00
|
|
|
Return the string obtained by replacing the leftmost non-overlapping
|
|
|
|
occurrences of \var{pattern} in \var{string} by the replacement
|
1997-11-20 00:15:13 +00:00
|
|
|
\var{repl}. If the pattern isn't found, \var{string} is returned
|
|
|
|
unchanged. \var{repl} can be a string or a function; if a function,
|
1999-04-09 19:57:09 +00:00
|
|
|
it is called for every non-overlapping occurrence of \var{pattern}.
|
1997-12-08 17:33:40 +00:00
|
|
|
The function takes a single match object argument, and returns the
|
|
|
|
replacement string. For example:
|
1998-12-22 18:19:45 +00:00
|
|
|
|
1998-02-13 06:58:54 +00:00
|
|
|
\begin{verbatim}
|
1997-11-20 00:15:13 +00:00
|
|
|
>>> def dashrepl(matchobj):
|
1998-04-02 01:32:24 +00:00
|
|
|
.... if matchobj.group(0) == '-': return ' '
|
|
|
|
.... else: return '-'
|
1997-11-20 00:15:13 +00:00
|
|
|
>>> re.sub('-{1,2}', dashrepl, 'pro----gram-files')
|
|
|
|
'pro--gram files'
|
1998-02-13 06:58:54 +00:00
|
|
|
\end{verbatim}
|
1998-12-22 18:19:45 +00:00
|
|
|
|
1997-12-08 17:33:40 +00:00
|
|
|
The pattern may be a string or a
|
1997-12-11 20:19:08 +00:00
|
|
|
regex object; if you need to specify
|
|
|
|
regular expression flags, you must use a regex object, or use
|
|
|
|
embedded modifiers in a pattern; e.g.
|
1998-03-08 07:38:27 +00:00
|
|
|
\samp{sub("(?i)b+", "x", "bbbb BBBB")} returns \code{'x x'}.
|
1998-01-12 19:16:24 +00:00
|
|
|
|
1997-08-14 23:12:18 +00:00
|
|
|
The optional argument \var{count} is the maximum number of pattern
|
1998-04-09 14:56:04 +00:00
|
|
|
occurrences to be replaced; \var{count} must be a non-negative integer, and
|
1997-08-14 23:12:18 +00:00
|
|
|
the default value of 0 means to replace all occurrences.
|
|
|
|
|
|
|
|
Empty matches for the pattern are replaced only when not adjacent to a
|
1998-03-08 07:38:27 +00:00
|
|
|
previous match, so \samp{sub('x*', '-', 'abc')} returns \code{'-a-b-c-'}.
|
1998-04-02 01:32:24 +00:00
|
|
|
|
|
|
|
If \var{repl} is a string, any backslash escapes in it are processed.
|
|
|
|
That is, \samp{\e n} is converted to a single newline character,
|
|
|
|
\samp{\e r} is converted to a linefeed, and so forth. Unknown escapes
|
1998-04-09 14:56:04 +00:00
|
|
|
such as \samp{\e j} are left alone. Backreferences, such as \samp{\e 6}, are
|
1998-04-02 01:32:24 +00:00
|
|
|
replaced with the substring matched by group 6 in the pattern.
|
|
|
|
|
|
|
|
In addition to character escapes and backreferences as described
|
|
|
|
above, \samp{\e g<name>} will use the substring matched by the group
|
1998-04-09 14:56:04 +00:00
|
|
|
named \samp{name}, as defined by the \regexp{(?P<name>...)} syntax.
|
1998-04-02 01:32:24 +00:00
|
|
|
\samp{\e g<number>} uses the corresponding group number; \samp{\e
|
|
|
|
g<2>} is therefore equivalent to \samp{\e 2}, but isn't ambiguous in a
|
|
|
|
replacement such as \samp{\e g<2>0}. \samp{\e 20} would be
|
|
|
|
interpreted as a reference to group 20, not a reference to group 2
|
1998-04-09 14:56:04 +00:00
|
|
|
followed by the literal character \character{0}.
|
1997-08-14 23:12:18 +00:00
|
|
|
\end{funcdesc}
|
|
|
|
|
1998-03-08 07:38:27 +00:00
|
|
|
\begin{funcdesc}{subn}{pattern, repl, string\optional{, count\code{ = 0}}}
|
1998-02-19 15:09:35 +00:00
|
|
|
Perform the same operation as \function{sub()}, but return a tuple
|
1998-01-12 19:16:24 +00:00
|
|
|
\code{(\var{new_string}, \var{number_of_subs_made})}.
|
1997-08-14 23:12:18 +00:00
|
|
|
\end{funcdesc}
|
|
|
|
|
1998-10-13 16:03:52 +00:00
|
|
|
\begin{funcdesc}{escape}{string}
|
|
|
|
Return \var{string} with all non-alphanumerics backslashed; this is
|
|
|
|
useful if you want to match an arbitrary literal string that may have
|
|
|
|
regular expression metacharacters in it.
|
|
|
|
\end{funcdesc}
|
|
|
|
|
1997-08-14 23:12:18 +00:00
|
|
|
\begin{excdesc}{error}
|
|
|
|
Exception raised when a string passed to one of the functions here
|
|
|
|
is not a valid regular expression (e.g., unmatched parentheses) or
|
1998-03-08 07:38:27 +00:00
|
|
|
when some other error occurs during compilation or matching. It is
|
|
|
|
never an error if a string contains no match for a pattern.
|
1997-08-14 23:12:18 +00:00
|
|
|
\end{excdesc}
|
|
|
|
|
1998-04-20 16:28:44 +00:00
|
|
|
|
1998-09-10 20:21:00 +00:00
|
|
|
\subsection{Regular Expression Objects \label{re-objects}}
|
1998-04-20 16:28:44 +00:00
|
|
|
|
1997-08-14 23:12:18 +00:00
|
|
|
Compiled regular expression objects support the following methods and
|
|
|
|
attributes:
|
|
|
|
|
2000-09-07 14:00:51 +00:00
|
|
|
\begin{methoddesc}[RegexObject]{search}{string\optional{, pos\optional{,
|
|
|
|
endpos}}}
|
1998-10-13 16:03:52 +00:00
|
|
|
Scan through \var{string} looking for a location where this regular
|
|
|
|
expression produces a match, and return a
|
|
|
|
corresponding \class{MatchObject} instance. Return \code{None} if no
|
|
|
|
position in the string matches the pattern; note that this is
|
|
|
|
different from finding a zero-length match at some point in the string.
|
|
|
|
|
|
|
|
The optional \var{pos} and \var{endpos} parameters have the same
|
|
|
|
meaning as for the \method{match()} method.
|
|
|
|
\end{methoddesc}
|
|
|
|
|
2000-09-07 14:00:51 +00:00
|
|
|
\begin{methoddesc}[RegexObject]{match}{string\optional{, pos\optional{,
|
|
|
|
endpos}}}
|
1997-10-05 18:54:07 +00:00
|
|
|
If zero or more characters at the beginning of \var{string} match
|
|
|
|
this regular expression, return a corresponding
|
1998-02-19 15:09:35 +00:00
|
|
|
\class{MatchObject} instance. Return \code{None} if the string does not
|
1997-10-05 18:54:07 +00:00
|
|
|
match the pattern; note that this is different from a zero-length
|
|
|
|
match.
|
1998-12-22 18:19:45 +00:00
|
|
|
|
|
|
|
\strong{Note:} If you want to locate a match anywhere in
|
|
|
|
\var{string}, use \method{search()} instead.
|
|
|
|
|
1997-08-14 23:12:18 +00:00
|
|
|
The optional second parameter \var{pos} gives an index in the string
|
1998-06-22 15:02:42 +00:00
|
|
|
where the search is to start; it defaults to \code{0}. This is not
|
|
|
|
completely equivalent to slicing the string; the \code{'\^'} pattern
|
|
|
|
character matches at the real beginning of the string and at positions
|
|
|
|
just after a newline, but not necessarily at the index where the search
|
|
|
|
is to start.
|
1997-12-08 17:33:40 +00:00
|
|
|
|
|
|
|
The optional parameter \var{endpos} limits how far the string will
|
|
|
|
be searched; it will be as if the string is \var{endpos} characters
|
|
|
|
long, so only the characters from \var{pos} to \var{endpos} will be
|
|
|
|
searched for a match.
|
1998-04-03 05:59:05 +00:00
|
|
|
\end{methoddesc}
|
1997-08-14 23:12:18 +00:00
|
|
|
|
2000-09-07 14:00:51 +00:00
|
|
|
\begin{methoddesc}[RegexObject]{split}{string\optional{,
|
1998-04-03 05:59:05 +00:00
|
|
|
maxsplit\code{ = 0}}}
|
1998-02-19 15:09:35 +00:00
|
|
|
Identical to the \function{split()} function, using the compiled pattern.
|
1998-04-03 05:59:05 +00:00
|
|
|
\end{methoddesc}
|
1997-08-14 23:12:18 +00:00
|
|
|
|
1998-06-29 22:48:01 +00:00
|
|
|
\begin{methoddesc}[RegexObject]{findall}{string}
|
|
|
|
Identical to the \function{findall()} function, using the compiled pattern.
|
|
|
|
\end{methoddesc}
|
|
|
|
|
1998-04-03 05:59:05 +00:00
|
|
|
\begin{methoddesc}[RegexObject]{sub}{repl, string\optional{, count\code{ = 0}}}
|
1998-02-19 15:09:35 +00:00
|
|
|
Identical to the \function{sub()} function, using the compiled pattern.
|
1998-04-03 05:59:05 +00:00
|
|
|
\end{methoddesc}
|
1997-08-14 23:12:18 +00:00
|
|
|
|
1998-04-03 05:59:05 +00:00
|
|
|
\begin{methoddesc}[RegexObject]{subn}{repl, string\optional{,
|
|
|
|
count\code{ = 0}}}
|
1998-02-19 15:09:35 +00:00
|
|
|
Identical to the \function{subn()} function, using the compiled pattern.
|
1998-04-03 05:59:05 +00:00
|
|
|
\end{methoddesc}
|
1997-08-14 23:12:18 +00:00
|
|
|
|
|
|
|
|
1998-04-03 05:59:05 +00:00
|
|
|
\begin{memberdesc}[RegexObject]{flags}
|
1998-03-08 07:38:27 +00:00
|
|
|
The flags argument used when the regex object was compiled, or
|
|
|
|
\code{0} if no flags were provided.
|
1998-04-03 05:59:05 +00:00
|
|
|
\end{memberdesc}
|
1997-08-14 23:12:18 +00:00
|
|
|
|
1998-04-03 05:59:05 +00:00
|
|
|
\begin{memberdesc}[RegexObject]{groupindex}
|
1998-03-08 07:38:27 +00:00
|
|
|
A dictionary mapping any symbolic group names defined by
|
1998-04-09 14:56:04 +00:00
|
|
|
\regexp{(?P<\var{id}>)} to group numbers. The dictionary is empty if no
|
1997-08-14 23:12:18 +00:00
|
|
|
symbolic groups were used in the pattern.
|
1998-04-03 05:59:05 +00:00
|
|
|
\end{memberdesc}
|
1997-08-14 23:12:18 +00:00
|
|
|
|
1998-04-03 05:59:05 +00:00
|
|
|
\begin{memberdesc}[RegexObject]{pattern}
|
1997-08-14 23:12:18 +00:00
|
|
|
The pattern string from which the regex object was compiled.
|
1998-04-03 05:59:05 +00:00
|
|
|
\end{memberdesc}
|
1997-08-14 23:12:18 +00:00
|
|
|
|
1998-04-20 16:28:44 +00:00
|
|
|
|
1998-09-10 20:21:00 +00:00
|
|
|
\subsection{Match Objects \label{match-objects}}
|
1998-01-12 19:16:24 +00:00
|
|
|
|
1998-02-19 15:09:35 +00:00
|
|
|
\class{MatchObject} instances support the following methods and attributes:
|
1997-08-14 23:12:18 +00:00
|
|
|
|
2000-09-07 14:00:51 +00:00
|
|
|
\begin{methoddesc}[MatchObject]{group}{\optional{group1, \moreargs}}
|
1998-01-19 23:14:17 +00:00
|
|
|
Returns one or more subgroups of the match. If there is a single
|
|
|
|
argument, the result is a single string; if there are
|
1997-12-11 20:19:08 +00:00
|
|
|
multiple arguments, the result is a tuple with one item per argument.
|
1998-01-19 23:14:17 +00:00
|
|
|
Without arguments, \var{group1} defaults to zero (i.e. the whole match
|
|
|
|
is returned).
|
|
|
|
If a \var{groupN} argument is zero, the corresponding return value is the
|
1997-12-11 20:19:08 +00:00
|
|
|
entire matching string; if it is in the inclusive range [1..99], it is
|
1998-04-03 20:07:37 +00:00
|
|
|
the string matching the the corresponding parenthesized group. If a
|
|
|
|
group number is negative or larger than the number of groups defined
|
|
|
|
in the pattern, an \exception{IndexError} exception is raised.
|
|
|
|
If a group is contained in a part of the pattern that did not match,
|
2000-09-07 14:00:51 +00:00
|
|
|
the corresponding result is \code{-1}. If a group is contained in a
|
1998-04-03 20:07:37 +00:00
|
|
|
part of the pattern that matched multiple times, the last match is
|
|
|
|
returned.
|
1997-08-14 23:12:18 +00:00
|
|
|
|
1998-04-09 14:56:04 +00:00
|
|
|
If the regular expression uses the \regexp{(?P<\var{name}>...)} syntax,
|
1998-01-19 23:14:17 +00:00
|
|
|
the \var{groupN} arguments may also be strings identifying groups by
|
1998-04-03 20:07:37 +00:00
|
|
|
their group name. If a string argument is not used as a group name in
|
|
|
|
the pattern, an \exception{IndexError} exception is raised.
|
1997-12-17 00:23:39 +00:00
|
|
|
|
|
|
|
A moderately complicated example:
|
1998-01-12 19:16:24 +00:00
|
|
|
|
|
|
|
\begin{verbatim}
|
1997-12-17 00:23:39 +00:00
|
|
|
m = re.match(r"(?P<int>\d+)\.(\d*)", '3.14')
|
1998-01-12 19:16:24 +00:00
|
|
|
\end{verbatim}
|
|
|
|
|
|
|
|
After performing this match, \code{m.group(1)} is \code{'3'}, as is
|
1998-01-19 23:14:17 +00:00
|
|
|
\code{m.group('int')}, and \code{m.group(2)} is \code{'14'}.
|
1998-04-03 05:59:05 +00:00
|
|
|
\end{methoddesc}
|
1997-08-14 23:12:18 +00:00
|
|
|
|
1998-06-29 22:48:01 +00:00
|
|
|
\begin{methoddesc}[MatchObject]{groups}{\optional{default}}
|
1997-12-11 20:19:08 +00:00
|
|
|
Return a tuple containing all the subgroups of the match, from 1 up to
|
1998-06-29 22:48:01 +00:00
|
|
|
however many groups are in the pattern. The \var{default} argument is
|
|
|
|
used for groups that did not participate in the match; it defaults to
|
|
|
|
\code{None}. (Incompatibility note: in the original Python 1.5
|
|
|
|
release, if the tuple was one element long, a string would be returned
|
|
|
|
instead. In later versions (from 1.5.1 on), a singleton tuple is
|
|
|
|
returned in such cases.)
|
|
|
|
\end{methoddesc}
|
|
|
|
|
|
|
|
\begin{methoddesc}[MatchObject]{groupdict}{\optional{default}}
|
|
|
|
Return a dictionary containing all the \emph{named} subgroups of the
|
|
|
|
match, keyed by the subgroup name. The \var{default} argument is
|
|
|
|
used for groups that did not participate in the match; it defaults to
|
|
|
|
\code{None}.
|
1998-04-03 05:59:05 +00:00
|
|
|
\end{methoddesc}
|
1997-12-11 20:19:08 +00:00
|
|
|
|
1998-04-03 05:59:05 +00:00
|
|
|
\begin{methoddesc}[MatchObject]{start}{\optional{group}}
|
1998-03-08 07:38:27 +00:00
|
|
|
\funcline{end}{\optional{group}}
|
1997-12-17 00:23:39 +00:00
|
|
|
Return the indices of the start and end of the substring
|
1998-01-19 23:14:17 +00:00
|
|
|
matched by \var{group}; \var{group} defaults to zero (meaning the whole
|
|
|
|
matched substring).
|
2000-09-07 14:00:51 +00:00
|
|
|
Return \code{-1} if \var{group} exists but
|
1997-12-17 00:23:39 +00:00
|
|
|
did not contribute to the match. For a match object
|
1998-01-12 19:16:24 +00:00
|
|
|
\var{m}, and a group \var{g} that did contribute to the match, the
|
|
|
|
substring matched by group \var{g} (equivalent to
|
|
|
|
\code{\var{m}.group(\var{g})}) is
|
|
|
|
|
|
|
|
\begin{verbatim}
|
|
|
|
m.string[m.start(g):m.end(g)]
|
|
|
|
\end{verbatim}
|
|
|
|
|
1997-12-17 00:23:39 +00:00
|
|
|
Note that
|
|
|
|
\code{m.start(\var{group})} will equal \code{m.end(\var{group})} if
|
1998-01-12 19:16:24 +00:00
|
|
|
\var{group} matched a null string. For example, after \code{\var{m} =
|
|
|
|
re.search('b(c?)', 'cba')}, \code{\var{m}.start(0)} is 1,
|
|
|
|
\code{\var{m}.end(0)} is 2, \code{\var{m}.start(1)} and
|
|
|
|
\code{\var{m}.end(1)} are both 2, and \code{\var{m}.start(2)} raises
|
1998-02-19 15:09:35 +00:00
|
|
|
an \exception{IndexError} exception.
|
1998-04-03 05:59:05 +00:00
|
|
|
\end{methoddesc}
|
1997-12-17 00:23:39 +00:00
|
|
|
|
1998-04-03 05:59:05 +00:00
|
|
|
\begin{methoddesc}[MatchObject]{span}{\optional{group}}
|
1998-02-19 15:09:35 +00:00
|
|
|
For \class{MatchObject} \var{m}, return the 2-tuple
|
1998-01-12 19:16:24 +00:00
|
|
|
\code{(\var{m}.start(\var{group}), \var{m}.end(\var{group}))}.
|
1997-12-17 00:23:39 +00:00
|
|
|
Note that if \var{group} did not contribute to the match, this is
|
2000-09-07 14:00:51 +00:00
|
|
|
\code{(-1, -1)}. Again, \var{group} defaults to zero.
|
1998-04-03 05:59:05 +00:00
|
|
|
\end{methoddesc}
|
1997-12-17 00:23:39 +00:00
|
|
|
|
1998-04-03 05:59:05 +00:00
|
|
|
\begin{memberdesc}[MatchObject]{pos}
|
1997-12-08 17:33:40 +00:00
|
|
|
The value of \var{pos} which was passed to the
|
1998-02-19 15:09:35 +00:00
|
|
|
\function{search()} or \function{match()} function. This is the index into
|
1998-01-12 19:16:24 +00:00
|
|
|
the string at which the regex engine started looking for a match.
|
1998-04-03 05:59:05 +00:00
|
|
|
\end{memberdesc}
|
1997-12-08 17:33:40 +00:00
|
|
|
|
1998-04-03 05:59:05 +00:00
|
|
|
\begin{memberdesc}[MatchObject]{endpos}
|
1997-12-08 17:33:40 +00:00
|
|
|
The value of \var{endpos} which was passed to the
|
1998-02-19 15:09:35 +00:00
|
|
|
\function{search()} or \function{match()} function. This is the index into
|
1998-01-12 19:16:24 +00:00
|
|
|
the string beyond which the regex engine will not go.
|
1998-04-03 05:59:05 +00:00
|
|
|
\end{memberdesc}
|
1997-08-14 23:12:18 +00:00
|
|
|
|
1998-04-03 05:59:05 +00:00
|
|
|
\begin{memberdesc}[MatchObject]{re}
|
1998-02-19 15:09:35 +00:00
|
|
|
The regular expression object whose \method{match()} or
|
|
|
|
\method{search()} method produced this \class{MatchObject} instance.
|
1998-04-03 05:59:05 +00:00
|
|
|
\end{memberdesc}
|
1997-08-14 23:12:18 +00:00
|
|
|
|
1998-04-03 05:59:05 +00:00
|
|
|
\begin{memberdesc}[MatchObject]{string}
|
1998-02-19 15:09:35 +00:00
|
|
|
The string passed to \function{match()} or \function{search()}.
|
1998-04-03 05:59:05 +00:00
|
|
|
\end{memberdesc}
|
1997-08-14 23:12:18 +00:00
|
|
|
|
|
|
|
\begin{seealso}
|
1999-11-09 20:10:01 +00:00
|
|
|
\seetext{Jeffrey Friedl, \citetitle{Mastering Regular Expressions},
|
1998-01-12 19:16:24 +00:00
|
|
|
O'Reilly. The Python material in this book dates from before the
|
1998-02-19 15:09:35 +00:00
|
|
|
\module{re} module, but it covers writing good regular expression
|
1998-01-12 19:16:24 +00:00
|
|
|
patterns in great detail.}
|
1997-08-14 23:12:18 +00:00
|
|
|
\end{seealso}
|
1998-04-09 14:56:04 +00:00
|
|
|
|