Fred Drake | 295da24 | 1998-08-10 19:42:37 +0000 | [diff] [blame] | 1 | \section{\module{re} --- |
| 2 | New Perl-style regular expression search and match operations.} |
Fred Drake | 66da9d6 | 1998-08-07 18:57:18 +0000 | [diff] [blame] | 3 | \declaremodule{standard}{re} |
| 4 | \moduleauthor{Andrew M. Kuchling}{akuchling@acm.org} |
| 5 | \sectionauthor{Andrew M. Kuchling}{akuchling@acm.org} |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 6 | |
Fred Drake | b91e934 | 1998-07-23 17:59:49 +0000 | [diff] [blame] | 7 | |
Fred Drake | 66da9d6 | 1998-08-07 18:57:18 +0000 | [diff] [blame] | 8 | \modulesynopsis{New Perl-style regular expression search and match |
| 9 | operations.} |
Fred Drake | b91e934 | 1998-07-23 17:59:49 +0000 | [diff] [blame] | 10 | |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 11 | |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 12 | This module provides regular expression matching operations similar to |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 13 | those found in Perl. It's 8-bit clean: the strings being processed |
| 14 | may contain both null bytes and characters whose high bit is set. Regular |
| 15 | expression patterns may not contain null bytes, but they may contain |
| 16 | characters with the high bit set. The \module{re} module is always |
Guido van Rossum | 0b33410 | 1997-12-08 17:33:40 +0000 | [diff] [blame] | 17 | available. |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 18 | |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 19 | Regular expressions use the backslash character (\character{\e}) to |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 20 | indicate special forms or to allow special characters to be used |
| 21 | without invoking their special meaning. This collides with Python's |
| 22 | usage of the same character for the same purpose in string literals; |
| 23 | for example, to match a literal backslash, one might have to write |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 24 | \code{'\e\e\e\e'} as the pattern string, because the regular expression |
Fred Drake | 20e0196 | 1998-02-19 15:09:35 +0000 | [diff] [blame] | 25 | must be \samp{\e\e}, and each backslash must be expressed as |
| 26 | \samp{\e\e} inside a regular Python string literal. |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 27 | |
| 28 | The solution is to use Python's raw string notation for regular |
| 29 | expression patterns; backslashes are not handled in any special way in |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 30 | a string literal prefixed with \character{r}. So \code{r"\e n"} is a |
| 31 | two-character string containing \character{\e} and \character{n}, |
| 32 | while \code{"\e n"} is a one-character string containing a newline. |
| 33 | Usually patterns will be expressed in Python code using this raw |
| 34 | string notation. |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 35 | |
Fred Drake | d16d498 | 1998-09-10 20:21:00 +0000 | [diff] [blame] | 36 | \subsection{Regular Expression Syntax \label{re-syntax}} |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 37 | |
| 38 | A regular expression (or RE) specifies a set of strings that matches |
| 39 | it; the functions in this module let you check if a particular string |
| 40 | matches a given regular expression (or if a given regular expression |
| 41 | matches a particular string, which comes down to the same thing). |
| 42 | |
| 43 | Regular expressions can be concatenated to form new regular |
| 44 | expressions; if \emph{A} and \emph{B} are both regular expressions, |
| 45 | then \emph{AB} is also an regular expression. If a string \emph{p} |
| 46 | matches A and another string \emph{q} matches B, the string \emph{pq} |
| 47 | will match AB. Thus, complex expressions can easily be constructed |
| 48 | from simpler primitive expressions like the ones described here. For |
| 49 | details of the theory and implementation of regular expressions, |
| 50 | consult the Friedl book referenced below, or almost any textbook about |
| 51 | compiler construction. |
| 52 | |
Andrew M. Kuchling | c1cea20 | 1998-10-28 15:44:14 +0000 | [diff] [blame^] | 53 | A brief explanation of the format of regular expressions follows. For |
| 54 | further information and a gentler presentation, consult the Regular |
| 55 | Expression HOWTO, accessible from \url{http://www.python.org/doc/howto/}. |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 56 | |
| 57 | Regular expressions can contain both special and ordinary characters. |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 58 | Most ordinary characters, like \character{A}, \character{a}, or \character{0}, |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 59 | are the simplest regular expressions; they simply match themselves. |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 60 | You can concatenate ordinary characters, so \regexp{last} matches the |
| 61 | string \code{'last'}. (In the rest of this section, we'll write RE's in |
| 62 | \regexp{this special style}, usually without quotes, and strings to be |
| 63 | matched \code{'in single quotes'}.) |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 64 | |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 65 | Some characters, like \character{|} or \character{(}, are special. Special |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 66 | characters either stand for classes of ordinary characters, or affect |
| 67 | how the regular expressions around them are interpreted. |
| 68 | |
| 69 | The special characters are: |
Fred Drake | 2705e80 | 1998-02-16 21:21:13 +0000 | [diff] [blame] | 70 | % define these since they're used twice: |
| 71 | \newcommand{\MyLeftMargin}{0.7in} |
| 72 | \newcommand{\MyLabelWidth}{0.65in} |
Fred Drake | d16d498 | 1998-09-10 20:21:00 +0000 | [diff] [blame] | 73 | |
Fred Drake | 2705e80 | 1998-02-16 21:21:13 +0000 | [diff] [blame] | 74 | \begin{list}{}{\leftmargin \MyLeftMargin \labelwidth \MyLabelWidth} |
Fred Drake | d16d498 | 1998-09-10 20:21:00 +0000 | [diff] [blame] | 75 | |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 76 | \item[\character{.}] (Dot.) In the default mode, this matches any |
Fred Drake | 20e0196 | 1998-02-19 15:09:35 +0000 | [diff] [blame] | 77 | character except a newline. If the \constant{DOTALL} flag has been |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 78 | specified, this matches any character including a newline. |
Fred Drake | d16d498 | 1998-09-10 20:21:00 +0000 | [diff] [blame] | 79 | |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 80 | \item[\character{\^}] (Caret.) Matches the start of the string, and in |
| 81 | \constant{MULTILINE} mode also matches immediately after each newline. |
Fred Drake | d16d498 | 1998-09-10 20:21:00 +0000 | [diff] [blame] | 82 | |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 83 | \item[\character{\$}] Matches the end of the string, and in |
Fred Drake | 20e0196 | 1998-02-19 15:09:35 +0000 | [diff] [blame] | 84 | \constant{MULTILINE} mode also matches before a newline. |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 85 | \regexp{foo} matches both 'foo' and 'foobar', while the regular |
| 86 | expression \regexp{foo\$} matches only 'foo'. |
Fred Drake | d16d498 | 1998-09-10 20:21:00 +0000 | [diff] [blame] | 87 | |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 88 | \item[\character{*}] Causes the resulting RE to |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 89 | match 0 or more repetitions of the preceding RE, as many repetitions |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 90 | as are possible. \regexp{ab*} will |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 91 | match 'a', 'ab', or 'a' followed by any number of 'b's. |
Fred Drake | d16d498 | 1998-09-10 20:21:00 +0000 | [diff] [blame] | 92 | |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 93 | \item[\character{+}] Causes the |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 94 | resulting RE to match 1 or more repetitions of the preceding RE. |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 95 | \regexp{ab+} will match 'a' followed by any non-zero number of 'b's; it |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 96 | will not match just 'a'. |
Fred Drake | d16d498 | 1998-09-10 20:21:00 +0000 | [diff] [blame] | 97 | |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 98 | \item[\character{?}] Causes the resulting RE to |
| 99 | match 0 or 1 repetitions of the preceding RE. \regexp{ab?} will |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 100 | match either 'a' or 'ab'. |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 101 | \item[\code{*?}, \code{+?}, \code{??}] The \character{*}, \character{+}, and |
| 102 | \character{?} qualifiers are all \dfn{greedy}; they match as much text as |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 103 | possible. Sometimes this behaviour isn't desired; if the RE |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 104 | \regexp{<.*>} is matched against \code{'<H1>title</H1>'}, it will match the |
| 105 | entire string, and not just \code{'<H1>'}. |
| 106 | Adding \character{?} after the qualifier makes it perform the match in |
| 107 | \dfn{non-greedy} or \dfn{minimal} fashion; as \emph{few} characters as |
| 108 | possible will be matched. Using \regexp{.*?} in the previous |
| 109 | expression will match only \code{'<H1>'}. |
Fred Drake | d16d498 | 1998-09-10 20:21:00 +0000 | [diff] [blame] | 110 | |
Guido van Rossum | 0148bbf | 1997-12-22 22:41:40 +0000 | [diff] [blame] | 111 | \item[\code{\{\var{m},\var{n}\}}] Causes the resulting RE to match from |
| 112 | \var{m} to \var{n} repetitions of the preceding RE, attempting to |
Andrew M. Kuchling | c1cea20 | 1998-10-28 15:44:14 +0000 | [diff] [blame^] | 113 | match as many repetitions as possible. For example, \regexp{a\{3,5\}} |
| 114 | will match from 3 to 5 \character{a} characters. Omitting \var{n} |
| 115 | specifies an infinite upper bound; you can't omit \var{m}. |
Fred Drake | d16d498 | 1998-09-10 20:21:00 +0000 | [diff] [blame] | 116 | |
Guido van Rossum | 0148bbf | 1997-12-22 22:41:40 +0000 | [diff] [blame] | 117 | \item[\code{\{\var{m},\var{n}\}?}] Causes the resulting RE to |
| 118 | match from \var{m} to \var{n} repetitions of the preceding RE, |
| 119 | attempting to match as \emph{few} repetitions as possible. This is |
| 120 | the non-greedy version of the previous qualifier. For example, on the |
Fred Drake | d16d498 | 1998-09-10 20:21:00 +0000 | [diff] [blame] | 121 | 6-character string \code{'aaaaaa'}, \regexp{a\{3,5\}} will match 5 |
| 122 | \character{a} characters, while \regexp{a\{3,5\}?} will only match 3 |
| 123 | characters. |
| 124 | |
| 125 | \item[\character{\e}] Either escapes special characters (permitting |
| 126 | you to match characters like \character{*}, \character{?}, and so |
| 127 | forth), or signals a special sequence; special sequences are discussed |
| 128 | below. |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 129 | |
| 130 | If you're not using a raw string to |
| 131 | express the pattern, remember that Python also uses the |
| 132 | backslash as an escape sequence in string literals; if the escape |
| 133 | sequence isn't recognized by Python's parser, the backslash and |
| 134 | subsequent character are included in the resulting string. However, |
| 135 | if Python would recognize the resulting sequence, the backslash should |
Fred Drake | 023f87f | 1998-01-12 19:16:24 +0000 | [diff] [blame] | 136 | be repeated twice. This is complicated and hard to understand, so |
| 137 | it's highly recommended that you use raw strings for all but the |
| 138 | simplest expressions. |
Fred Drake | d16d498 | 1998-09-10 20:21:00 +0000 | [diff] [blame] | 139 | |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 140 | \item[\code{[]}] Used to indicate a set of characters. Characters can |
Guido van Rossum | 48d0437 | 1997-12-11 20:19:08 +0000 | [diff] [blame] | 141 | be listed individually, or a range of characters can be indicated by |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 142 | giving two characters and separating them by a \character{-}. Special |
| 143 | characters are not active inside sets. For example, \regexp{[akm\$]} |
Fred Drake | 76547c5 | 1998-04-03 05:59:05 +0000 | [diff] [blame] | 144 | will match any of the characters \character{a}, \character{k}, |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 145 | \character{m}, or \character{\$}; \regexp{[a-z]} |
| 146 | will match any lowercase letter, and \code{[a-zA-Z0-9]} matches any |
Guido van Rossum | 48d0437 | 1997-12-11 20:19:08 +0000 | [diff] [blame] | 147 | letter or digit. Character classes such as \code{\e w} or \code {\e |
| 148 | S} (defined below) are also acceptable inside a range. If you want to |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 149 | include a \character{]} or a \character{-} inside a set, precede it with a |
| 150 | backslash, or place it as the first character. The |
| 151 | pattern \regexp{[]]} will match \code{']'}, for example. |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 152 | |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 153 | You can match the characters not within a range by \dfn{complementing} |
| 154 | the set. This is indicated by including a |
| 155 | \character{\^} as the first character of the set; \character{\^} elsewhere will |
| 156 | simply match the \character{\^} character. For example, \regexp{[\^5]} |
| 157 | will match any character except \character{5}. |
| 158 | |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 159 | \item[\character{|}]\code{A|B}, where A and B can be arbitrary REs, |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 160 | creates a regular expression that will match either A or B. This can |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 161 | be used inside groups (see below) as well. To match a literal \character{|}, |
| 162 | use \regexp{\e|}, or enclose it inside a character class, as in \regexp{[|]}. |
Fred Drake | d16d498 | 1998-09-10 20:21:00 +0000 | [diff] [blame] | 163 | |
Guido van Rossum | 48d0437 | 1997-12-11 20:19:08 +0000 | [diff] [blame] | 164 | \item[\code{(...)}] Matches whatever regular expression is inside the |
| 165 | parentheses, and indicates the start and end of a group; the contents |
| 166 | of a group can be retrieved after a match has been performed, and can |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 167 | be matched later in the string with the \regexp{\e \var{number}} special |
Fred Drake | d16d498 | 1998-09-10 20:21:00 +0000 | [diff] [blame] | 168 | sequence, described below. To match the literals \character{(} or |
| 169 | \character{')}, use \regexp{\e(} or \regexp{\e)}, or enclose them |
| 170 | inside a character class: \regexp{[(] [)]}. |
| 171 | |
| 172 | \item[\code{(?...)}] This is an extension notation (a \character{?} |
| 173 | following a \character{(} is not meaningful otherwise). The first |
| 174 | character after the \character{?} |
Guido van Rossum | 0b33410 | 1997-12-08 17:33:40 +0000 | [diff] [blame] | 175 | determines what the meaning and further syntax of the construct is. |
Guido van Rossum | e9625e8 | 1998-04-02 01:32:24 +0000 | [diff] [blame] | 176 | Extensions usually do not create a new group; |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 177 | \regexp{(?P<\var{name}>...)} is the only exception to this rule. |
Guido van Rossum | 0b33410 | 1997-12-08 17:33:40 +0000 | [diff] [blame] | 178 | Following are the currently supported extensions. |
Fred Drake | d16d498 | 1998-09-10 20:21:00 +0000 | [diff] [blame] | 179 | |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 180 | \item[\code{(?iLmsx)}] (One or more letters from the set \character{i}, |
| 181 | \character{L}, \character{m}, \character{s}, \character{x}.) The group matches |
Fred Drake | 023f87f | 1998-01-12 19:16:24 +0000 | [diff] [blame] | 182 | the empty string; the letters set the corresponding flags |
Fred Drake | 20e0196 | 1998-02-19 15:09:35 +0000 | [diff] [blame] | 183 | (\constant{re.I}, \constant{re.L}, \constant{re.M}, \constant{re.S}, |
| 184 | \constant{re.X}) for the entire regular expression. This is useful if |
Guido van Rossum | e9625e8 | 1998-04-02 01:32:24 +0000 | [diff] [blame] | 185 | you wish to include the flags as part of the regular expression, instead |
Fred Drake | 20e0196 | 1998-02-19 15:09:35 +0000 | [diff] [blame] | 186 | of passing a \var{flag} argument to the \function{compile()} function. |
Fred Drake | d16d498 | 1998-09-10 20:21:00 +0000 | [diff] [blame] | 187 | |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 188 | \item[\code{(?:...)}] A non-grouping version of regular parentheses. |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 189 | Matches whatever regular expression is inside the parentheses, but the |
| 190 | substring matched by the |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 191 | group \emph{cannot} be retrieved after performing a match or |
| 192 | referenced later in the pattern. |
Fred Drake | d16d498 | 1998-09-10 20:21:00 +0000 | [diff] [blame] | 193 | |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 194 | \item[\code{(?P<\var{name}>...)}] Similar to regular parentheses, but |
Guido van Rossum | e9625e8 | 1998-04-02 01:32:24 +0000 | [diff] [blame] | 195 | the substring matched by the group is accessible via the symbolic group |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 196 | name \var{name}. Group names must be valid Python identifiers. A |
| 197 | symbolic group is also a numbered group, just as if the group were not |
| 198 | named. So the group named 'id' in the example above can also be |
| 199 | referenced as the numbered group 1. |
| 200 | |
Guido van Rossum | 48d0437 | 1997-12-11 20:19:08 +0000 | [diff] [blame] | 201 | For example, if the pattern is |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 202 | \regexp{(?P<id>[a-zA-Z_]\e w*)}, the group can be referenced by its |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 203 | name in arguments to methods of match objects, such as \code{m.group('id')} |
Fred Drake | 023f87f | 1998-01-12 19:16:24 +0000 | [diff] [blame] | 204 | or \code{m.end('id')}, and also by name in pattern text |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 205 | (e.g. \regexp{(?P=id)}) and replacement text (e.g. \code{\e g<id>}). |
Fred Drake | d16d498 | 1998-09-10 20:21:00 +0000 | [diff] [blame] | 206 | |
Fred Drake | 023f87f | 1998-01-12 19:16:24 +0000 | [diff] [blame] | 207 | \item[\code{(?P=\var{name})}] Matches whatever text was matched by the |
| 208 | earlier group named \var{name}. |
Fred Drake | d16d498 | 1998-09-10 20:21:00 +0000 | [diff] [blame] | 209 | |
Fred Drake | 023f87f | 1998-01-12 19:16:24 +0000 | [diff] [blame] | 210 | \item[\code{(?\#...)}] A comment; the contents of the parentheses are |
| 211 | simply ignored. |
Fred Drake | d16d498 | 1998-09-10 20:21:00 +0000 | [diff] [blame] | 212 | |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 213 | \item[\code{(?=...)}] Matches if \regexp{...} matches next, but doesn't |
Fred Drake | 023f87f | 1998-01-12 19:16:24 +0000 | [diff] [blame] | 214 | consume any of the string. This is called a lookahead assertion. For |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 215 | example, \regexp{Isaac (?=Asimov)} will match \code{'Isaac~'} only if it's |
| 216 | followed by \code{'Asimov'}. |
Fred Drake | d16d498 | 1998-09-10 20:21:00 +0000 | [diff] [blame] | 217 | |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 218 | \item[\code{(?!...)}] Matches if \regexp{...} doesn't match next. This |
Fred Drake | 023f87f | 1998-01-12 19:16:24 +0000 | [diff] [blame] | 219 | is a negative lookahead assertion. For example, |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 220 | \regexp{Isaac (?!Asimov)} will match \code{'Isaac~'} only if it's \emph{not} |
| 221 | followed by \code{'Asimov'}. |
Guido van Rossum | 0b33410 | 1997-12-08 17:33:40 +0000 | [diff] [blame] | 222 | |
Fred Drake | 2705e80 | 1998-02-16 21:21:13 +0000 | [diff] [blame] | 223 | \end{list} |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 224 | |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 225 | The special sequences consist of \character{\e} and a character from the |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 226 | list below. If the ordinary character is not on the list, then the |
| 227 | resulting RE will match the second character. For example, |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 228 | \regexp{\e\$} matches the character \character{\$}. |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 229 | |
Fred Drake | 2705e80 | 1998-02-16 21:21:13 +0000 | [diff] [blame] | 230 | \begin{list}{}{\leftmargin \MyLeftMargin \labelwidth \MyLabelWidth} |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 231 | |
| 232 | % |
| 233 | \item[\code{\e \var{number}}] Matches the contents of the group of the |
Guido van Rossum | 0b33410 | 1997-12-08 17:33:40 +0000 | [diff] [blame] | 234 | same number. Groups are numbered starting from 1. For example, |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 235 | \regexp{(.+) \e 1} matches \code{'the the'} or \code{'55 55'}, but not |
| 236 | \code{'the end'} (note |
Guido van Rossum | 0b33410 | 1997-12-08 17:33:40 +0000 | [diff] [blame] | 237 | the space after the group). This special sequence can only be used to |
| 238 | match one of the first 99 groups. If the first digit of \var{number} |
| 239 | is 0, or \var{number} is 3 octal digits long, it will not be interpreted |
| 240 | as a group match, but as the character with octal value \var{number}. |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 241 | Inside the \character{[} and \character{]} of a character class, all numeric |
Guido van Rossum | e9625e8 | 1998-04-02 01:32:24 +0000 | [diff] [blame] | 242 | escapes are treated as characters. |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 243 | % |
| 244 | \item[\code{\e A}] Matches only at the start of the string. |
| 245 | % |
| 246 | \item[\code{\e b}] Matches the empty string, but only at the |
| 247 | beginning or end of a word. A word is defined as a sequence of |
| 248 | alphanumeric characters, so the end of a word is indicated by |
Guido van Rossum | 48d0437 | 1997-12-11 20:19:08 +0000 | [diff] [blame] | 249 | whitespace or a non-alphanumeric character. Inside a character range, |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 250 | \regexp{\e b} represents the backspace character, for compatibility with |
Guido van Rossum | 48d0437 | 1997-12-11 20:19:08 +0000 | [diff] [blame] | 251 | Python's string literals. |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 252 | % |
Guido van Rossum | 0b33410 | 1997-12-08 17:33:40 +0000 | [diff] [blame] | 253 | \item[\code{\e B}] Matches the empty string, but only when it is |
| 254 | \emph{not} at the beginning or end of a word. |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 255 | % |
| 256 | \item[\code{\e d}]Matches any decimal digit; this is |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 257 | equivalent to the set \regexp{[0-9]}. |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 258 | % |
| 259 | \item[\code{\e D}]Matches any non-digit character; this is |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 260 | equivalent to the set \regexp{[\^0-9]}. |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 261 | % |
| 262 | \item[\code{\e s}]Matches any whitespace character; this is |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 263 | equivalent to the set \regexp{[ \e t\e n\e r\e f\e v]}. |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 264 | % |
| 265 | \item[\code{\e S}]Matches any non-whitespace character; this is |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 266 | equivalent to the set \regexp{[\^\ \e t\e n\e r\e f\e v]}. |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 267 | % |
Fred Drake | 20e0196 | 1998-02-19 15:09:35 +0000 | [diff] [blame] | 268 | \item[\code{\e w}]When the \constant{LOCALE} flag is not specified, |
Fred Drake | 023f87f | 1998-01-12 19:16:24 +0000 | [diff] [blame] | 269 | matches any alphanumeric character; this is equivalent to the set |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 270 | \regexp{[a-zA-Z0-9_]}. With \constant{LOCALE}, it will match the set |
| 271 | \regexp{[0-9_]} plus whatever characters are defined as letters for the |
Fred Drake | 023f87f | 1998-01-12 19:16:24 +0000 | [diff] [blame] | 272 | current locale. |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 273 | % |
Fred Drake | 20e0196 | 1998-02-19 15:09:35 +0000 | [diff] [blame] | 274 | \item[\code{\e W}]When the \constant{LOCALE} flag is not specified, |
Fred Drake | 023f87f | 1998-01-12 19:16:24 +0000 | [diff] [blame] | 275 | matches any non-alphanumeric character; this is equivalent to the set |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 276 | \regexp{[\^a-zA-Z0-9_]}. With \constant{LOCALE}, it will match any |
| 277 | character not in the set \regexp{[0-9_]}, and not defined as a letter |
Guido van Rossum | 0b33410 | 1997-12-08 17:33:40 +0000 | [diff] [blame] | 278 | for the current locale. |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 279 | |
| 280 | \item[\code{\e Z}]Matches only at the end of the string. |
| 281 | % |
| 282 | |
| 283 | \item[\code{\e \e}] Matches a literal backslash. |
| 284 | |
Fred Drake | 2705e80 | 1998-02-16 21:21:13 +0000 | [diff] [blame] | 285 | \end{list} |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 286 | |
Fred Drake | 42de185 | 1998-04-20 16:28:44 +0000 | [diff] [blame] | 287 | |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 288 | \subsection{Module Contents} |
Fred Drake | 78f8e98 | 1997-12-29 21:39:39 +0000 | [diff] [blame] | 289 | \nodename{Contents of Module re} |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 290 | |
| 291 | The module defines the following functions and constants, and an exception: |
| 292 | |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 293 | |
Fred Drake | 013ad98 | 1998-03-08 07:38:27 +0000 | [diff] [blame] | 294 | \begin{funcdesc}{compile}{pattern\optional{, flags}} |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 295 | Compile a regular expression pattern into a regular expression |
Fred Drake | 20e0196 | 1998-02-19 15:09:35 +0000 | [diff] [blame] | 296 | object, which can be used for matching using its \function{match()} and |
| 297 | \function{search()} methods, described below. |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 298 | |
Guido van Rossum | 0b33410 | 1997-12-08 17:33:40 +0000 | [diff] [blame] | 299 | The expression's behaviour can be modified by specifying a |
| 300 | \var{flags} value. Values can be any of the following variables, |
| 301 | combined using bitwise OR (the \code{|} operator). |
| 302 | |
Fred Drake | 76547c5 | 1998-04-03 05:59:05 +0000 | [diff] [blame] | 303 | The sequence |
| 304 | |
| 305 | \begin{verbatim} |
| 306 | prog = re.compile(pat) |
| 307 | result = prog.match(str) |
| 308 | \end{verbatim} |
| 309 | |
| 310 | is equivalent to |
| 311 | |
| 312 | \begin{verbatim} |
| 313 | result = re.match(pat, str) |
| 314 | \end{verbatim} |
| 315 | |
| 316 | but the version using \function{compile()} is more efficient when the |
| 317 | expression will be used several times in a single program. |
| 318 | %(The compiled version of the last pattern passed to |
| 319 | %\function{regex.match()} or \function{regex.search()} is cached, so |
| 320 | %programs that use only a single regular expression at a time needn't |
| 321 | %worry about compiling regular expressions.) |
| 322 | \end{funcdesc} |
| 323 | |
Fred Drake | 013ad98 | 1998-03-08 07:38:27 +0000 | [diff] [blame] | 324 | \begin{datadesc}{I} |
| 325 | \dataline{IGNORECASE} |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 326 | Perform case-insensitive matching; expressions like \regexp{[A-Z]} will match |
Guido van Rossum | 48d0437 | 1997-12-11 20:19:08 +0000 | [diff] [blame] | 327 | lowercase letters, too. This is not affected by the current locale. |
Fred Drake | 013ad98 | 1998-03-08 07:38:27 +0000 | [diff] [blame] | 328 | \end{datadesc} |
Guido van Rossum | 0b33410 | 1997-12-08 17:33:40 +0000 | [diff] [blame] | 329 | |
Fred Drake | 013ad98 | 1998-03-08 07:38:27 +0000 | [diff] [blame] | 330 | \begin{datadesc}{L} |
| 331 | \dataline{LOCALE} |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 332 | Make \regexp{\e w}, \regexp{\e W}, \regexp{\e b}, |
| 333 | \regexp{\e B}, dependent on the current locale. |
Fred Drake | 013ad98 | 1998-03-08 07:38:27 +0000 | [diff] [blame] | 334 | \end{datadesc} |
Guido van Rossum | a42c178 | 1997-12-09 20:41:47 +0000 | [diff] [blame] | 335 | |
Fred Drake | 013ad98 | 1998-03-08 07:38:27 +0000 | [diff] [blame] | 336 | \begin{datadesc}{M} |
| 337 | \dataline{MULTILINE} |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 338 | When specified, the pattern character \character{\^} matches at the |
Fred Drake | 023f87f | 1998-01-12 19:16:24 +0000 | [diff] [blame] | 339 | beginning of the string and at the beginning of each line |
| 340 | (immediately following each newline); and the pattern character |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 341 | \character{\$} matches at the end of the string and at the end of each line |
Guido van Rossum | 48d0437 | 1997-12-11 20:19:08 +0000 | [diff] [blame] | 342 | (immediately preceding each newline). |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 343 | By default, \character{\^} matches only at the beginning of the string, and |
| 344 | \character{\$} only at the end of the string and immediately before the |
Guido van Rossum | 0b33410 | 1997-12-08 17:33:40 +0000 | [diff] [blame] | 345 | newline (if any) at the end of the string. |
Fred Drake | 013ad98 | 1998-03-08 07:38:27 +0000 | [diff] [blame] | 346 | \end{datadesc} |
Guido van Rossum | 0b33410 | 1997-12-08 17:33:40 +0000 | [diff] [blame] | 347 | |
Fred Drake | 013ad98 | 1998-03-08 07:38:27 +0000 | [diff] [blame] | 348 | \begin{datadesc}{S} |
| 349 | \dataline{DOTALL} |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 350 | Make the \character{.} special character match any character at all, including a |
| 351 | newline; without this flag, \character{.} will match anything \emph{except} |
Fred Drake | 78f8e98 | 1997-12-29 21:39:39 +0000 | [diff] [blame] | 352 | a newline. |
Fred Drake | 013ad98 | 1998-03-08 07:38:27 +0000 | [diff] [blame] | 353 | \end{datadesc} |
Guido van Rossum | 48d0437 | 1997-12-11 20:19:08 +0000 | [diff] [blame] | 354 | |
Fred Drake | 013ad98 | 1998-03-08 07:38:27 +0000 | [diff] [blame] | 355 | \begin{datadesc}{X} |
| 356 | \dataline{VERBOSE} |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 357 | This flag allows you to write regular expressions that look nicer. |
| 358 | Whitespace within the pattern is ignored, |
Guido van Rossum | 48d0437 | 1997-12-11 20:19:08 +0000 | [diff] [blame] | 359 | except when in a character class or preceded by an unescaped |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 360 | backslash, and, when a line contains a \character{\#} neither in a character |
Guido van Rossum | 48d0437 | 1997-12-11 20:19:08 +0000 | [diff] [blame] | 361 | class or preceded by an unescaped backslash, all characters from the |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 362 | leftmost such \character{\#} through the end of the line are ignored. |
| 363 | % XXX should add an example here |
Fred Drake | 013ad98 | 1998-03-08 07:38:27 +0000 | [diff] [blame] | 364 | \end{datadesc} |
Guido van Rossum | 0b33410 | 1997-12-08 17:33:40 +0000 | [diff] [blame] | 365 | |
Guido van Rossum | 0b33410 | 1997-12-08 17:33:40 +0000 | [diff] [blame] | 366 | |
Guido van Rossum | 7d447aa | 1998-10-13 16:03:52 +0000 | [diff] [blame] | 367 | \begin{funcdesc}{search}{pattern, string\optional{, flags}} |
| 368 | Scan through \var{string} looking for a location where the regular |
| 369 | expression \var{pattern} produces a match, and return a |
| 370 | corresponding \class{MatchObject} instance. |
| 371 | Return \code{None} if no |
| 372 | position in the string matches the pattern; note that this is |
| 373 | different from finding a zero-length match at some point in the string. |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 374 | \end{funcdesc} |
| 375 | |
Fred Drake | 013ad98 | 1998-03-08 07:38:27 +0000 | [diff] [blame] | 376 | \begin{funcdesc}{match}{pattern, string\optional{, flags}} |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 377 | If zero or more characters at the beginning of \var{string} match |
| 378 | the regular expression \var{pattern}, return a corresponding |
Fred Drake | 20e0196 | 1998-02-19 15:09:35 +0000 | [diff] [blame] | 379 | \class{MatchObject} instance. Return \code{None} if the string does not |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 380 | match the pattern; note that this is different from a zero-length |
| 381 | match. |
| 382 | \end{funcdesc} |
| 383 | |
Fred Drake | 013ad98 | 1998-03-08 07:38:27 +0000 | [diff] [blame] | 384 | \begin{funcdesc}{split}{pattern, string, \optional{, maxsplit\code{ = 0}}} |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 385 | Split \var{string} by the occurrences of \var{pattern}. If |
Andrew M. Kuchling | d22e250 | 1998-08-14 14:49:20 +0000 | [diff] [blame] | 386 | capturing parentheses are used in \var{pattern}, then the text of all |
| 387 | groups in the pattern are also returned as part of the resulting list. |
Guido van Rossum | 9754639 | 1998-01-12 18:58:53 +0000 | [diff] [blame] | 388 | If \var{maxsplit} is nonzero, at most \var{maxsplit} splits |
| 389 | occur, and the remainder of the string is returned as the final |
| 390 | element of the list. (Incompatibility note: in the original Python |
| 391 | 1.5 release, \var{maxsplit} was ignored. This has been fixed in |
| 392 | later releases.) |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 393 | % |
Fred Drake | 1947991 | 1998-02-13 06:58:54 +0000 | [diff] [blame] | 394 | \begin{verbatim} |
Andrew M. Kuchling | d22e250 | 1998-08-14 14:49:20 +0000 | [diff] [blame] | 395 | >>> re.split('\W+', 'Words, words, words.') |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 396 | ['Words', 'words', 'words', ''] |
Andrew M. Kuchling | d22e250 | 1998-08-14 14:49:20 +0000 | [diff] [blame] | 397 | >>> re.split('(\W+)', 'Words, words, words.') |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 398 | ['Words', ', ', 'words', ', ', 'words', '.', ''] |
Andrew M. Kuchling | d22e250 | 1998-08-14 14:49:20 +0000 | [diff] [blame] | 399 | >>> re.split('\W+', 'Words, words, words.', 1) |
Guido van Rossum | 9754639 | 1998-01-12 18:58:53 +0000 | [diff] [blame] | 400 | ['Words', 'words, words.'] |
Fred Drake | 1947991 | 1998-02-13 06:58:54 +0000 | [diff] [blame] | 401 | \end{verbatim} |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 402 | % |
| 403 | This function combines and extends the functionality of |
Fred Drake | 20e0196 | 1998-02-19 15:09:35 +0000 | [diff] [blame] | 404 | the old \function{regsub.split()} and \function{regsub.splitx()}. |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 405 | \end{funcdesc} |
| 406 | |
Guido van Rossum | 6c373f7 | 1998-06-29 22:48:01 +0000 | [diff] [blame] | 407 | \begin{funcdesc}{findall}{pattern, string} |
Fred Drake | 10a7985 | 1998-09-18 17:11:49 +0000 | [diff] [blame] | 408 | \versionadded{1.5.2} |
Guido van Rossum | 6c373f7 | 1998-06-29 22:48:01 +0000 | [diff] [blame] | 409 | Return a list of all non-overlapping matches of \var{pattern} in |
| 410 | \var{string}. If one or more groups are present in the pattern, |
| 411 | return a list of groups; this will be a list of tuples if the pattern |
| 412 | has more than one group. Empty matches are included in the result. |
| 413 | \end{funcdesc} |
| 414 | |
Fred Drake | 013ad98 | 1998-03-08 07:38:27 +0000 | [diff] [blame] | 415 | \begin{funcdesc}{sub}{pattern, repl, string\optional{, count\code{ = 0}}} |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 416 | Return the string obtained by replacing the leftmost non-overlapping |
| 417 | occurrences of \var{pattern} in \var{string} by the replacement |
Barry Warsaw | 4552f3d | 1997-11-20 00:15:13 +0000 | [diff] [blame] | 418 | \var{repl}. If the pattern isn't found, \var{string} is returned |
| 419 | unchanged. \var{repl} can be a string or a function; if a function, |
| 420 | it is called for every non-overlapping occurance of \var{pattern}. |
Guido van Rossum | 0b33410 | 1997-12-08 17:33:40 +0000 | [diff] [blame] | 421 | The function takes a single match object argument, and returns the |
| 422 | replacement string. For example: |
Barry Warsaw | 4552f3d | 1997-11-20 00:15:13 +0000 | [diff] [blame] | 423 | % |
Fred Drake | 1947991 | 1998-02-13 06:58:54 +0000 | [diff] [blame] | 424 | \begin{verbatim} |
Barry Warsaw | 4552f3d | 1997-11-20 00:15:13 +0000 | [diff] [blame] | 425 | >>> def dashrepl(matchobj): |
Guido van Rossum | e9625e8 | 1998-04-02 01:32:24 +0000 | [diff] [blame] | 426 | .... if matchobj.group(0) == '-': return ' ' |
| 427 | .... else: return '-' |
Barry Warsaw | 4552f3d | 1997-11-20 00:15:13 +0000 | [diff] [blame] | 428 | >>> re.sub('-{1,2}', dashrepl, 'pro----gram-files') |
| 429 | 'pro--gram files' |
Fred Drake | 1947991 | 1998-02-13 06:58:54 +0000 | [diff] [blame] | 430 | \end{verbatim} |
Barry Warsaw | 4552f3d | 1997-11-20 00:15:13 +0000 | [diff] [blame] | 431 | % |
Guido van Rossum | 0b33410 | 1997-12-08 17:33:40 +0000 | [diff] [blame] | 432 | The pattern may be a string or a |
Guido van Rossum | 48d0437 | 1997-12-11 20:19:08 +0000 | [diff] [blame] | 433 | regex object; if you need to specify |
| 434 | regular expression flags, you must use a regex object, or use |
| 435 | embedded modifiers in a pattern; e.g. |
Fred Drake | 013ad98 | 1998-03-08 07:38:27 +0000 | [diff] [blame] | 436 | \samp{sub("(?i)b+", "x", "bbbb BBBB")} returns \code{'x x'}. |
Fred Drake | 023f87f | 1998-01-12 19:16:24 +0000 | [diff] [blame] | 437 | |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 438 | The optional argument \var{count} is the maximum number of pattern |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 439 | occurrences to be replaced; \var{count} must be a non-negative integer, and |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 440 | the default value of 0 means to replace all occurrences. |
| 441 | |
| 442 | Empty matches for the pattern are replaced only when not adjacent to a |
Fred Drake | 013ad98 | 1998-03-08 07:38:27 +0000 | [diff] [blame] | 443 | previous match, so \samp{sub('x*', '-', 'abc')} returns \code{'-a-b-c-'}. |
Guido van Rossum | e9625e8 | 1998-04-02 01:32:24 +0000 | [diff] [blame] | 444 | |
| 445 | If \var{repl} is a string, any backslash escapes in it are processed. |
| 446 | That is, \samp{\e n} is converted to a single newline character, |
| 447 | \samp{\e r} is converted to a linefeed, and so forth. Unknown escapes |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 448 | such as \samp{\e j} are left alone. Backreferences, such as \samp{\e 6}, are |
Guido van Rossum | e9625e8 | 1998-04-02 01:32:24 +0000 | [diff] [blame] | 449 | replaced with the substring matched by group 6 in the pattern. |
| 450 | |
| 451 | In addition to character escapes and backreferences as described |
| 452 | above, \samp{\e g<name>} will use the substring matched by the group |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 453 | named \samp{name}, as defined by the \regexp{(?P<name>...)} syntax. |
Guido van Rossum | e9625e8 | 1998-04-02 01:32:24 +0000 | [diff] [blame] | 454 | \samp{\e g<number>} uses the corresponding group number; \samp{\e |
| 455 | g<2>} is therefore equivalent to \samp{\e 2}, but isn't ambiguous in a |
| 456 | replacement such as \samp{\e g<2>0}. \samp{\e 20} would be |
| 457 | interpreted as a reference to group 20, not a reference to group 2 |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 458 | followed by the literal character \character{0}. |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 459 | \end{funcdesc} |
| 460 | |
Fred Drake | 013ad98 | 1998-03-08 07:38:27 +0000 | [diff] [blame] | 461 | \begin{funcdesc}{subn}{pattern, repl, string\optional{, count\code{ = 0}}} |
Fred Drake | 20e0196 | 1998-02-19 15:09:35 +0000 | [diff] [blame] | 462 | Perform the same operation as \function{sub()}, but return a tuple |
Fred Drake | 023f87f | 1998-01-12 19:16:24 +0000 | [diff] [blame] | 463 | \code{(\var{new_string}, \var{number_of_subs_made})}. |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 464 | \end{funcdesc} |
| 465 | |
Guido van Rossum | 7d447aa | 1998-10-13 16:03:52 +0000 | [diff] [blame] | 466 | \begin{funcdesc}{escape}{string} |
| 467 | Return \var{string} with all non-alphanumerics backslashed; this is |
| 468 | useful if you want to match an arbitrary literal string that may have |
| 469 | regular expression metacharacters in it. |
| 470 | \end{funcdesc} |
| 471 | |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 472 | \begin{excdesc}{error} |
| 473 | Exception raised when a string passed to one of the functions here |
| 474 | is not a valid regular expression (e.g., unmatched parentheses) or |
Fred Drake | 013ad98 | 1998-03-08 07:38:27 +0000 | [diff] [blame] | 475 | when some other error occurs during compilation or matching. It is |
| 476 | never an error if a string contains no match for a pattern. |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 477 | \end{excdesc} |
| 478 | |
Fred Drake | 42de185 | 1998-04-20 16:28:44 +0000 | [diff] [blame] | 479 | |
Fred Drake | d16d498 | 1998-09-10 20:21:00 +0000 | [diff] [blame] | 480 | \subsection{Regular Expression Objects \label{re-objects}} |
Fred Drake | 42de185 | 1998-04-20 16:28:44 +0000 | [diff] [blame] | 481 | |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 482 | Compiled regular expression objects support the following methods and |
| 483 | attributes: |
| 484 | |
Guido van Rossum | 7d447aa | 1998-10-13 16:03:52 +0000 | [diff] [blame] | 485 | \begin{methoddesc}[RegexObject]{search}{string\optional{, pos}\optional{, |
| 486 | endpos}} |
| 487 | Scan through \var{string} looking for a location where this regular |
| 488 | expression produces a match, and return a |
| 489 | corresponding \class{MatchObject} instance. Return \code{None} if no |
| 490 | position in the string matches the pattern; note that this is |
| 491 | different from finding a zero-length match at some point in the string. |
| 492 | |
| 493 | The optional \var{pos} and \var{endpos} parameters have the same |
| 494 | meaning as for the \method{match()} method. |
| 495 | \end{methoddesc} |
| 496 | |
Fred Drake | 76547c5 | 1998-04-03 05:59:05 +0000 | [diff] [blame] | 497 | \begin{methoddesc}[RegexObject]{match}{string\optional{, pos}\optional{, |
| 498 | endpos}} |
Guido van Rossum | eb53ae4 | 1997-10-05 18:54:07 +0000 | [diff] [blame] | 499 | If zero or more characters at the beginning of \var{string} match |
| 500 | this regular expression, return a corresponding |
Fred Drake | 20e0196 | 1998-02-19 15:09:35 +0000 | [diff] [blame] | 501 | \class{MatchObject} instance. Return \code{None} if the string does not |
Guido van Rossum | eb53ae4 | 1997-10-05 18:54:07 +0000 | [diff] [blame] | 502 | match the pattern; note that this is different from a zero-length |
| 503 | match. |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 504 | |
| 505 | The optional second parameter \var{pos} gives an index in the string |
Andrew M. Kuchling | 65b7863 | 1998-06-22 15:02:42 +0000 | [diff] [blame] | 506 | where the search is to start; it defaults to \code{0}. This is not |
| 507 | completely equivalent to slicing the string; the \code{'\^'} pattern |
| 508 | character matches at the real beginning of the string and at positions |
| 509 | just after a newline, but not necessarily at the index where the search |
| 510 | is to start. |
Guido van Rossum | 0b33410 | 1997-12-08 17:33:40 +0000 | [diff] [blame] | 511 | |
| 512 | The optional parameter \var{endpos} limits how far the string will |
| 513 | be searched; it will be as if the string is \var{endpos} characters |
| 514 | long, so only the characters from \var{pos} to \var{endpos} will be |
| 515 | searched for a match. |
Fred Drake | 76547c5 | 1998-04-03 05:59:05 +0000 | [diff] [blame] | 516 | \end{methoddesc} |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 517 | |
Fred Drake | 76547c5 | 1998-04-03 05:59:05 +0000 | [diff] [blame] | 518 | \begin{methoddesc}[RegexObject]{split}{string, \optional{, |
| 519 | maxsplit\code{ = 0}}} |
Fred Drake | 20e0196 | 1998-02-19 15:09:35 +0000 | [diff] [blame] | 520 | Identical to the \function{split()} function, using the compiled pattern. |
Fred Drake | 76547c5 | 1998-04-03 05:59:05 +0000 | [diff] [blame] | 521 | \end{methoddesc} |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 522 | |
Guido van Rossum | 6c373f7 | 1998-06-29 22:48:01 +0000 | [diff] [blame] | 523 | \begin{methoddesc}[RegexObject]{findall}{string} |
| 524 | Identical to the \function{findall()} function, using the compiled pattern. |
| 525 | \end{methoddesc} |
| 526 | |
Fred Drake | 76547c5 | 1998-04-03 05:59:05 +0000 | [diff] [blame] | 527 | \begin{methoddesc}[RegexObject]{sub}{repl, string\optional{, count\code{ = 0}}} |
Fred Drake | 20e0196 | 1998-02-19 15:09:35 +0000 | [diff] [blame] | 528 | Identical to the \function{sub()} function, using the compiled pattern. |
Fred Drake | 76547c5 | 1998-04-03 05:59:05 +0000 | [diff] [blame] | 529 | \end{methoddesc} |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 530 | |
Fred Drake | 76547c5 | 1998-04-03 05:59:05 +0000 | [diff] [blame] | 531 | \begin{methoddesc}[RegexObject]{subn}{repl, string\optional{, |
| 532 | count\code{ = 0}}} |
Fred Drake | 20e0196 | 1998-02-19 15:09:35 +0000 | [diff] [blame] | 533 | Identical to the \function{subn()} function, using the compiled pattern. |
Fred Drake | 76547c5 | 1998-04-03 05:59:05 +0000 | [diff] [blame] | 534 | \end{methoddesc} |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 535 | |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 536 | |
Fred Drake | 76547c5 | 1998-04-03 05:59:05 +0000 | [diff] [blame] | 537 | \begin{memberdesc}[RegexObject]{flags} |
Fred Drake | 013ad98 | 1998-03-08 07:38:27 +0000 | [diff] [blame] | 538 | The flags argument used when the regex object was compiled, or |
| 539 | \code{0} if no flags were provided. |
Fred Drake | 76547c5 | 1998-04-03 05:59:05 +0000 | [diff] [blame] | 540 | \end{memberdesc} |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 541 | |
Fred Drake | 76547c5 | 1998-04-03 05:59:05 +0000 | [diff] [blame] | 542 | \begin{memberdesc}[RegexObject]{groupindex} |
Fred Drake | 013ad98 | 1998-03-08 07:38:27 +0000 | [diff] [blame] | 543 | A dictionary mapping any symbolic group names defined by |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 544 | \regexp{(?P<\var{id}>)} to group numbers. The dictionary is empty if no |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 545 | symbolic groups were used in the pattern. |
Fred Drake | 76547c5 | 1998-04-03 05:59:05 +0000 | [diff] [blame] | 546 | \end{memberdesc} |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 547 | |
Fred Drake | 76547c5 | 1998-04-03 05:59:05 +0000 | [diff] [blame] | 548 | \begin{memberdesc}[RegexObject]{pattern} |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 549 | The pattern string from which the regex object was compiled. |
Fred Drake | 76547c5 | 1998-04-03 05:59:05 +0000 | [diff] [blame] | 550 | \end{memberdesc} |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 551 | |
Fred Drake | 42de185 | 1998-04-20 16:28:44 +0000 | [diff] [blame] | 552 | |
Fred Drake | d16d498 | 1998-09-10 20:21:00 +0000 | [diff] [blame] | 553 | \subsection{Match Objects \label{match-objects}} |
Fred Drake | 023f87f | 1998-01-12 19:16:24 +0000 | [diff] [blame] | 554 | |
Fred Drake | 20e0196 | 1998-02-19 15:09:35 +0000 | [diff] [blame] | 555 | \class{MatchObject} instances support the following methods and attributes: |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 556 | |
Fred Drake | 76547c5 | 1998-04-03 05:59:05 +0000 | [diff] [blame] | 557 | \begin{methoddesc}[MatchObject]{group}{\optional{group1, group2, ...}} |
Guido van Rossum | 4650392 | 1998-01-19 23:14:17 +0000 | [diff] [blame] | 558 | Returns one or more subgroups of the match. If there is a single |
| 559 | argument, the result is a single string; if there are |
Guido van Rossum | 48d0437 | 1997-12-11 20:19:08 +0000 | [diff] [blame] | 560 | multiple arguments, the result is a tuple with one item per argument. |
Guido van Rossum | 4650392 | 1998-01-19 23:14:17 +0000 | [diff] [blame] | 561 | Without arguments, \var{group1} defaults to zero (i.e. the whole match |
| 562 | is returned). |
| 563 | If a \var{groupN} argument is zero, the corresponding return value is the |
Guido van Rossum | 48d0437 | 1997-12-11 20:19:08 +0000 | [diff] [blame] | 564 | entire matching string; if it is in the inclusive range [1..99], it is |
Guido van Rossum | 791468f | 1998-04-03 20:07:37 +0000 | [diff] [blame] | 565 | the string matching the the corresponding parenthesized group. If a |
| 566 | group number is negative or larger than the number of groups defined |
| 567 | in the pattern, an \exception{IndexError} exception is raised. |
| 568 | If a group is contained in a part of the pattern that did not match, |
| 569 | the corresponding result is \code{None}. If a group is contained in a |
| 570 | part of the pattern that matched multiple times, the last match is |
| 571 | returned. |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 572 | |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 573 | If the regular expression uses the \regexp{(?P<\var{name}>...)} syntax, |
Guido van Rossum | 4650392 | 1998-01-19 23:14:17 +0000 | [diff] [blame] | 574 | the \var{groupN} arguments may also be strings identifying groups by |
Guido van Rossum | 791468f | 1998-04-03 20:07:37 +0000 | [diff] [blame] | 575 | their group name. If a string argument is not used as a group name in |
| 576 | the pattern, an \exception{IndexError} exception is raised. |
Guido van Rossum | e4eb223 | 1997-12-17 00:23:39 +0000 | [diff] [blame] | 577 | |
| 578 | A moderately complicated example: |
Fred Drake | 023f87f | 1998-01-12 19:16:24 +0000 | [diff] [blame] | 579 | |
| 580 | \begin{verbatim} |
Guido van Rossum | e4eb223 | 1997-12-17 00:23:39 +0000 | [diff] [blame] | 581 | m = re.match(r"(?P<int>\d+)\.(\d*)", '3.14') |
Fred Drake | 023f87f | 1998-01-12 19:16:24 +0000 | [diff] [blame] | 582 | \end{verbatim} |
| 583 | |
| 584 | After performing this match, \code{m.group(1)} is \code{'3'}, as is |
Guido van Rossum | 4650392 | 1998-01-19 23:14:17 +0000 | [diff] [blame] | 585 | \code{m.group('int')}, and \code{m.group(2)} is \code{'14'}. |
Fred Drake | 76547c5 | 1998-04-03 05:59:05 +0000 | [diff] [blame] | 586 | \end{methoddesc} |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 587 | |
Guido van Rossum | 6c373f7 | 1998-06-29 22:48:01 +0000 | [diff] [blame] | 588 | \begin{methoddesc}[MatchObject]{groups}{\optional{default}} |
Guido van Rossum | 48d0437 | 1997-12-11 20:19:08 +0000 | [diff] [blame] | 589 | Return a tuple containing all the subgroups of the match, from 1 up to |
Guido van Rossum | 6c373f7 | 1998-06-29 22:48:01 +0000 | [diff] [blame] | 590 | however many groups are in the pattern. The \var{default} argument is |
| 591 | used for groups that did not participate in the match; it defaults to |
| 592 | \code{None}. (Incompatibility note: in the original Python 1.5 |
| 593 | release, if the tuple was one element long, a string would be returned |
| 594 | instead. In later versions (from 1.5.1 on), a singleton tuple is |
| 595 | returned in such cases.) |
| 596 | \end{methoddesc} |
| 597 | |
| 598 | \begin{methoddesc}[MatchObject]{groupdict}{\optional{default}} |
| 599 | Return a dictionary containing all the \emph{named} subgroups of the |
| 600 | match, keyed by the subgroup name. The \var{default} argument is |
| 601 | used for groups that did not participate in the match; it defaults to |
| 602 | \code{None}. |
Fred Drake | 76547c5 | 1998-04-03 05:59:05 +0000 | [diff] [blame] | 603 | \end{methoddesc} |
Guido van Rossum | 48d0437 | 1997-12-11 20:19:08 +0000 | [diff] [blame] | 604 | |
Fred Drake | 76547c5 | 1998-04-03 05:59:05 +0000 | [diff] [blame] | 605 | \begin{methoddesc}[MatchObject]{start}{\optional{group}} |
Fred Drake | 013ad98 | 1998-03-08 07:38:27 +0000 | [diff] [blame] | 606 | \funcline{end}{\optional{group}} |
Guido van Rossum | e4eb223 | 1997-12-17 00:23:39 +0000 | [diff] [blame] | 607 | Return the indices of the start and end of the substring |
Guido van Rossum | 4650392 | 1998-01-19 23:14:17 +0000 | [diff] [blame] | 608 | matched by \var{group}; \var{group} defaults to zero (meaning the whole |
| 609 | matched substring). |
| 610 | Return \code{None} if \var{group} exists but |
Guido van Rossum | e4eb223 | 1997-12-17 00:23:39 +0000 | [diff] [blame] | 611 | did not contribute to the match. For a match object |
Fred Drake | 023f87f | 1998-01-12 19:16:24 +0000 | [diff] [blame] | 612 | \var{m}, and a group \var{g} that did contribute to the match, the |
| 613 | substring matched by group \var{g} (equivalent to |
| 614 | \code{\var{m}.group(\var{g})}) is |
| 615 | |
| 616 | \begin{verbatim} |
| 617 | m.string[m.start(g):m.end(g)] |
| 618 | \end{verbatim} |
| 619 | |
Guido van Rossum | e4eb223 | 1997-12-17 00:23:39 +0000 | [diff] [blame] | 620 | Note that |
| 621 | \code{m.start(\var{group})} will equal \code{m.end(\var{group})} if |
Fred Drake | 023f87f | 1998-01-12 19:16:24 +0000 | [diff] [blame] | 622 | \var{group} matched a null string. For example, after \code{\var{m} = |
| 623 | re.search('b(c?)', 'cba')}, \code{\var{m}.start(0)} is 1, |
| 624 | \code{\var{m}.end(0)} is 2, \code{\var{m}.start(1)} and |
| 625 | \code{\var{m}.end(1)} are both 2, and \code{\var{m}.start(2)} raises |
Fred Drake | 20e0196 | 1998-02-19 15:09:35 +0000 | [diff] [blame] | 626 | an \exception{IndexError} exception. |
Fred Drake | 76547c5 | 1998-04-03 05:59:05 +0000 | [diff] [blame] | 627 | \end{methoddesc} |
Guido van Rossum | e4eb223 | 1997-12-17 00:23:39 +0000 | [diff] [blame] | 628 | |
Fred Drake | 76547c5 | 1998-04-03 05:59:05 +0000 | [diff] [blame] | 629 | \begin{methoddesc}[MatchObject]{span}{\optional{group}} |
Fred Drake | 20e0196 | 1998-02-19 15:09:35 +0000 | [diff] [blame] | 630 | For \class{MatchObject} \var{m}, return the 2-tuple |
Fred Drake | 023f87f | 1998-01-12 19:16:24 +0000 | [diff] [blame] | 631 | \code{(\var{m}.start(\var{group}), \var{m}.end(\var{group}))}. |
Guido van Rossum | e4eb223 | 1997-12-17 00:23:39 +0000 | [diff] [blame] | 632 | Note that if \var{group} did not contribute to the match, this is |
Guido van Rossum | 4650392 | 1998-01-19 23:14:17 +0000 | [diff] [blame] | 633 | \code{(None, None)}. Again, \var{group} defaults to zero. |
Fred Drake | 76547c5 | 1998-04-03 05:59:05 +0000 | [diff] [blame] | 634 | \end{methoddesc} |
Guido van Rossum | e4eb223 | 1997-12-17 00:23:39 +0000 | [diff] [blame] | 635 | |
Fred Drake | 76547c5 | 1998-04-03 05:59:05 +0000 | [diff] [blame] | 636 | \begin{memberdesc}[MatchObject]{pos} |
Guido van Rossum | 0b33410 | 1997-12-08 17:33:40 +0000 | [diff] [blame] | 637 | The value of \var{pos} which was passed to the |
Fred Drake | 20e0196 | 1998-02-19 15:09:35 +0000 | [diff] [blame] | 638 | \function{search()} or \function{match()} function. This is the index into |
Fred Drake | 023f87f | 1998-01-12 19:16:24 +0000 | [diff] [blame] | 639 | the string at which the regex engine started looking for a match. |
Fred Drake | 76547c5 | 1998-04-03 05:59:05 +0000 | [diff] [blame] | 640 | \end{memberdesc} |
Guido van Rossum | 0b33410 | 1997-12-08 17:33:40 +0000 | [diff] [blame] | 641 | |
Fred Drake | 76547c5 | 1998-04-03 05:59:05 +0000 | [diff] [blame] | 642 | \begin{memberdesc}[MatchObject]{endpos} |
Guido van Rossum | 0b33410 | 1997-12-08 17:33:40 +0000 | [diff] [blame] | 643 | The value of \var{endpos} which was passed to the |
Fred Drake | 20e0196 | 1998-02-19 15:09:35 +0000 | [diff] [blame] | 644 | \function{search()} or \function{match()} function. This is the index into |
Fred Drake | 023f87f | 1998-01-12 19:16:24 +0000 | [diff] [blame] | 645 | the string beyond which the regex engine will not go. |
Fred Drake | 76547c5 | 1998-04-03 05:59:05 +0000 | [diff] [blame] | 646 | \end{memberdesc} |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 647 | |
Fred Drake | 76547c5 | 1998-04-03 05:59:05 +0000 | [diff] [blame] | 648 | \begin{memberdesc}[MatchObject]{re} |
Fred Drake | 20e0196 | 1998-02-19 15:09:35 +0000 | [diff] [blame] | 649 | The regular expression object whose \method{match()} or |
| 650 | \method{search()} method produced this \class{MatchObject} instance. |
Fred Drake | 76547c5 | 1998-04-03 05:59:05 +0000 | [diff] [blame] | 651 | \end{memberdesc} |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 652 | |
Fred Drake | 76547c5 | 1998-04-03 05:59:05 +0000 | [diff] [blame] | 653 | \begin{memberdesc}[MatchObject]{string} |
Fred Drake | 20e0196 | 1998-02-19 15:09:35 +0000 | [diff] [blame] | 654 | The string passed to \function{match()} or \function{search()}. |
Fred Drake | 76547c5 | 1998-04-03 05:59:05 +0000 | [diff] [blame] | 655 | \end{memberdesc} |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 656 | |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 657 | \begin{seealso} |
Fred Drake | f995181 | 1997-12-29 16:37:04 +0000 | [diff] [blame] | 658 | \seetext{Jeffrey Friedl, \emph{Mastering Regular Expressions}, |
Fred Drake | 023f87f | 1998-01-12 19:16:24 +0000 | [diff] [blame] | 659 | O'Reilly. The Python material in this book dates from before the |
Fred Drake | 20e0196 | 1998-02-19 15:09:35 +0000 | [diff] [blame] | 660 | \module{re} module, but it covers writing good regular expression |
Fred Drake | 023f87f | 1998-01-12 19:16:24 +0000 | [diff] [blame] | 661 | patterns in great detail.} |
Guido van Rossum | 1acceb0 | 1997-08-14 23:12:18 +0000 | [diff] [blame] | 662 | \end{seealso} |
Andrew M. Kuchling | 2533281 | 1998-04-09 14:56:04 +0000 | [diff] [blame] | 663 | |