Show Menu

python regular expression (regex) Cheat Sheet by

python regular expressions
development     python     regex     regular     programming     expression

Special characters

.
Default: Match any character except newline
.
DOTALL: Match any character including newline
^
Default: Match the start of a string
^
MULTILINE: Match immediatly after each newline
$
Match the end of a string
$
MULTILINE: Also match before a newline
*
Match 0 or more repeti­tions of RE
+
Match 1 or more repeti­tions of RE
?
Match 0 or 1 repeti­tions of RE
*?, *+, ??
Match non-greedy as few characters as possible
{m}
Match exactly m copies of the previous RE
{m,n}
Match from m to n repeti­tions of RE
{m,n}?
Match non-greedy
\
Escape special characters
[]
Match a set of characters
|
RE1RE2: Match either RE1 or RE2 non-greedy
(...)
Match RE inside parant­heses and indicate start and end of a group
With RE is the resulting regular expression.

Special characters must be escaped with \ if it should match the character literally

Methods of 're' module

re.compile(
pattern,
flags=0)
Compile a regular expression pattern into a regular expression object. Can be used with match(), search() and others
re.search(
pattern,
string,
flags=0
Search through string matching the first location of the RE. Returns a match object or None
re.match(
pattern,
string,
flags=0)
If zero or more characters at the beginning of a string match pattern return a match object or None
re.fullmatch(
pattern,
string,
flags=0)
If the whole string matches the pattern return a match object or None
re.split(
pattern,
string,
maxsplit=0,
flags=0)
Split string by the occurr­ences of pattern maxsplit times if non-zero. Returns a list of all groups.
re.findall(
pattern,
string,
flags=0
)
Return all non-ov­erl­apping matches of pattern in string as list of strings.
re.finditer(
pattern,
string,
flags=0
)
Return an iter­ator yielding match objects over all non-ov­erl­apping matches for the pattern in string
re.sub(
pattern,
repl,
string,
count=0,
flags=0
)
Return the string obtained by replacing the leftmost non-ov­erl­apping occurr­ences of pattern in string by the repla­cement repl. repl can be a function.
re.subn(
pattern,
repl,
string,
count=0,
flags=0
)
Like sub but return a tuple (new_string, number_of_subs_made)
re.escape(
pattern)
Escape special characters in pattern
re.p­urg­e()
Clear the regular expression cache

Raw String Notation

In raw string notation r"t­ext­" there is no need to escape the backslash character again.

>>> re.mat­ch(­r"\W­(.)­\1­\W", " ff ")
<r­e.Match object; span=(0, 4), match=' ff '>
>>> re.mat­ch(­"­\\W­(.)­\\1­\\W­", " ff ")
<r­e.Match object; span=(0, 4), match=' ff '>
 

Extensions

(?...)
This is the start of an extension
(?aiLmsux)
The letters set the corres­pondig flags See flags
(?:...)
A non-ca­pturing version of regular parant­heses
(?P<na­me>...)
Like regular paranthes but with a named group
(?P=name)
A backre­ference to a named group
(?#...)
A comment
(?=...)
lookahead assert­ion: Matches if ... matches next without consuming the string
(?!...)
negative lookahead assert­ion: Matches if ... doesn't match next
(?<­=....)
positive lookbehind assert­ion: Match if the current position in the string is preceded by a match for ... that ends the current position
(?<­!...)
negative lookbehind assert­ion: Match if the current position in the string is not preceded by a match for ...
(?(id/name)yes-pattern|no-pattern)
Match with yes-p­attern if the group with gived id or name exists and with no-pa­ttern if not

Match objects

Match.expand(
template)
Return the string obtained by doing backslash substi­tution on templ­ate, as done by the sub() method
Match.group(
[group1,...])
Returns one or more subgroups of the match. 1 Argument returns string and more arguments return a tuple.
Match.__getitem__(
g)
Access groups with m[0], m[1] ...
Match.groups(
default=None)
Return a tuple containing all the subgroups of the match
Match.groupdict(
default=None)
Return a dict­ion­ary containing all the named subgroups of the match, keyed by the subgroup name.
Match.start(
[group]
Match.end(
[group])
Return the indices of the start and end of the substring matched by group
Match.span(
[group])
For a match m, return the 2-tuple (m.start(group) m.end(group))
Match.­pos
The value of pos which was passed to the sear­ch() or matc­h() method of the regex object
Match.­e­ndpos
Likewise but the value of endpos
Match.­l­ast­index
The integer index of the last matched capturing group, or None.
Match.­l­ast­group
The name of the last matched capturing group or None
Match.­re
The regular expression object whose matc­h() or sear­ch() method produced this match instance
Match.­s­tring
The string passed to matc­h() or sear­ch()
 

Special escape characters

\A
Match only at the start of the string
\b
Match the empty string at the beginning or end of a word
\B
Match the empty string when not at the beginning or end of a word
\d
Match any Unic­ode decimal digit this includes [0-9]
\D
Match any character which is not a decimal digit
\s
Match Unic­ode white space characters which includes [ \t\n\r­\f\v]
\S
Matches any character which is not a whitespace character. The opposite of \s
\w
Match Unic­ode word characters including [a-zA-­Z0-9_]
\W
Match the opposite of \w
\Z
Match only at the end of a string

Regular Expression Objects

Pattern.search(
string[,
pos[,
endpos]])
See re.­sea­rch­(). pos gives an index where to start the search. endpos limits how far the string will be searched.
Pattern.match(
string[,
pos[,
endpos]])
Likewise but see re.­mat­ch()
Pattern.fullmatch(
string[,
pos[,
endpos]])
Likewise but see re.­ful­lma­tch­()
Pattern.split(
string,
maxsplit=0
)
Identical to re.­spl­it()
Pattern.findall(
string[,
pos[,
endpos]])
Similar to re.­fin­dal­l() but with additional parameters pos and endpos
Pattern.finditer(
string[,
pos[,
endpos]])
Similar to re.­fin­dit­er() but with additional parameters pos and endpos
Pattern.sub(
repl,
string,
count=0
)
Identical to re.­sub­()
Pattern.subn(
repl,
string,
count=0
)
Identical to re.­sub­n()
Patter­n.­fl­ags
The regex matching flags.
Patter­n.­gr­oups
The number of capturing groups in the pattern
Pattern.groupindex
A dictionary mapping any symbolic group names to group members
Patter­n.­pa­ttern
The pattern string from which the pattern object was compiled
These objects are returned by the re.­com­pil­e() method

Flags

ASCII, A
ASCII-only matching in \w, \b, \s and \d
IGNORECASE, I
ignore case
LOCALE, L
do a local-­aware match
MULTILINE, M
multiline matching, affecting ^ and $
DOTALL, S
dot matches all
u
unicode matching (just in (?aiLm­sux))
VERBOSE, X
verbose
Flags are used in (?aiLmsux-imsx:...) or (?aiLmsux) or can be accessed with re.FLAG. In the first form flags are set or removed.

This is useful if you wish to include the flags as part of the regular expression, instead of passing a flag argument to the re.compile() function

Download the python regular expression (regex) Cheat Sheet

3 Pages
//media.cheatography.com/storage/thumb/mutanclan_python-regular-expression-regex.750.jpg

PDF (recommended)

Alternative Downloads

Share This Cheat Sheet!

 

Comments

No comments yet. Add yours below!

Add a Comment

Your Comment

Please enter your name.

    Please enter your email address

      Please enter your Comment.

          Related Cheat Sheets

          Regular Expressions Cheat Sheet
            .NET Regular Expressions Cheat Sheet by RegExLib.com

          More Cheat Sheets by mutanclan

          vim tpope/vim-surround Cheat Sheet
          vim vixen firefox addon Cheat Sheet
          python string formatting Cheat Sheet