Programming Python (187 page)

.


Matches any character
(including newline if
DOTALL
flag is specified or
(?s)
at pattern
front)

^


Matches start of the
string (of every line in
MULTILINE
mode)

$


Matches end of the
string (of every line in
MULTILINE
mode)

C


Any nonspecial (or
backslash-escaped) character matches itself

R*


Zero or more of
preceding regular expression
R
(as many as
possible)

R+


One or more of
preceding regular expression
R
(as many as
possible)

R?


Zero or one occurrence
of preceding regular expression
R
(optional)

R{m}


Matches exactly
m
copies preceding
R
:
a{5}
matches
'aaaaa'


R{m,n}


Matches from
m
to
n
repetitions of preceding regular
expression
R


R*?, R+?, R??,
R{m,n}?


Same as
*
,
+
, and
?
but matches as few
characters/times as possible; these are known as
nongreedy
match operators (unlike others,
they match and consume as few characters as
possible)

[...]


Defines character set:
e.g.,
[a-zA-Z]
to match all
letters (alternatives, with
-
for ranges)

[^...]


Defines complemented
character set: matches if
char
is not in set

\


Escapes special
char
s (e.g.,
*?+|()
) and introduces special
sequences in
Table 19-2

\\


Matches a literal
\
(write as
\\\\
in pattern, or use
r'\\'
)

\N


Matches the contents of
the group of the same number N:
'(.+)
\1'
matches “42 42”

R|R


Alternative: matches
left or right
R


RR


Concatenation: match
both
R
s

(R)


Matches any regular
expression inside
()
, and
delimits a group (retains matched substring)

(?:R)


Same as
(R)
but simply delimits part R and
does not denote a saved group

(?=R)


Look-ahead assertion:
matches if
R
matches next,
but doesn’t consume any of the string (e.g.,
X (?=Y)
matches
X
only if followed by
Y
)

(?!R)


Matches if
R
doesn’t match next; negative of
(?=R)


(?PR)


Matches any regular
expression inside
()
, and
delimits a named group

(?P=name)


Matches whatever text
was matched by the earlier group named
name


(?#...)


A comment;
ignored

(?letter)


Set mode flag;
letter
is one of
aiLmsux
(see the library
manual)

(?<=R)


Look-behind assertion:
matches if the current position in the string is preceded by a
match of
R
that ends at the
current position

(?

Matches if the current
position in the string is not preceded by a match for
R
; negative of
(?<= R)


(?(id/name)
yespattern
|
nopattern
)


Will try to match with
yespattern
if the group
with given
id
or
name
exists, else with optional
nopattern


\
number


Matches text of group
number
(numbered from
1)

\A


Matches only at the
start of the string

\b


Empty string at word
boundaries

\B


Empty string not at
word boundaries

\d


Any decimal digit
character (
[0-9]
for
ASCII)

\D


Any nondecimal digit
character (
[^O-9]
for
ASCII)

\s


Any whitespace
character (
[ \t\n\r\f\v]
for ASCII)

\S


Any nonwhitespace
character (
[^ \t\n\r\f\v]
for ASCII)

\w


Any alphanumeric
character (
[a-zA-Z0-9_]
for
ASCII)

\W


Any nonalphanumeric
character (
[^a-zA-Z0-9_]
for ASCII )

\Z


Matches only at the end
of the string