Python Regular Expression (RegEx) Cheatsheet

.

Matches any character except the newline character

^

Matches the beginning of the string provided

$

Matches the end of the string provided

*

Matches 0 or more repetitions of the provided character

+

Matches 1 or more repetitions of the provided character

?

Matches either 0 or 1 repetition of a character

*?

Matches 0 or more repetitions of the provided character in a non-greedy manner

+?

Matches 1 or more repetitions of the provided character in a non-greedy manner

??

Matches either 0 or 1 repetition of a character in a non-greedy manner

Escapes a special character

[]

Matches a set of characters provided within the square brackets

[a-z]

Matches any lower cased ASCII letters

[lower-upper]

Matches a set of characters from lower to upper cased ASCII letters

[^]

Matches a set of characters that are not in a set

A|B

Matches either regular expressions A or B in a non-greedy manner

{m}

Matches exactly m copies of the character specified

{m,n}

Matches from m to n repetitions of the character specified

{,n}

Matches from 0 to n repetitions of the character specified

{m,}

Matches from m to infinite repetitions of the character specified

{m,n}?

Matches from m to n repetitions in a non-greedy manner (as few as possible)

(?)

Extension notation used to set flags

a

Flag to denote to match only ASCII characters

i

Flag to denote to ignore the case

L

Flag to denote that it is Locale dependent

m

Multi-line flag

s

Dot matches all flag

x

Verbose flag

u

Matches Unicode character classes

A

Matches only at the beginning of the string

b

Matches an empty string, only at the beginning or end of a word

B

Matches an empty string, only when it is NOT at the beginning or end of a word

d

Matches digits same as [0-9]

D

Matches anything that is not a digit, same as [^0-9]

s

Matches white space characters, similar to [tnrfv]

S

Matches non-white space characters, similar to [^tnrfv]

w

Matches Unicode word characters, similar to [a-zA-Z0-9_]

W

Matches any character that is not a Unicode word character, similar to [^a-zA-Z0-9_]

Z

Matches only at the end of the given string

re.compile(pattern, flags)

Compiles a regular expression with a pattern along with flags

re.match(pattern, string)

Matches the pattern only at the beginning of the string

re.search(pattern, string)

Matches the pattern anywhere in the provided string

re.split(pattern, string)

Splits the string by the occurrences of the provided pattern

re.sub(pattern, str2, string)

Replaces the left-most non-overlapping occurrences of the provided pattern in the string with str2

re.fullmatch(pattern, string)

Matches the provided pattern only if the whole string matches the regular expression

re.findall(pattern, string)

Returns all non-overlapping matches of the provided pattern in string as a list of strings

re.finditer(pattern, string)

Returns an iterator that yields matched objects over non-overlapping matches of the provided pattern in string

re.subn(pattern, str2, string)

Replaces the left most occurrences of the given pattern in string with str2 and returns a tuple of (newsubstring, subs made)

re.purge()

Clears the regular expression cache of Python

(match)

This is used to specify a group on which a match can be retrieved later

(?:match)

Non capturing version parenthesis, that is the match cannot be retrieved later

(?P)

Capture the group with name “name”

(?P=name)

Backtrack group named “name” in same pattern

(?#comment)

Denotes a comment

match.group(“name”)

Returns the subgroup “name” of match

match.groups()

Returns tuples containing all subgroups of match

match.groupdict()

Returns dict containing all named subgroups of match

match.start(group)

Returns the start index of substring matched by group

match.end(group)

Returns the end index of substring matched by group

match.span(group)

Returns 2 tuple start and end indices of group in match

match.pos

Value of pos which was passed either to search() or match()

match.endpos

Value of endpos which was passed either to search() or match()

match.lastindex

Integer index of last matched capturing group

match.lastgroup

Name of the last matched capturing group

match.re

The regular expression who match() or search() created the match

match.string

The string that was passed to either match() or search()

(?=match)

Denotes a lookahead assertion – matches if contents matches next, but does not consume any of the string

(?!match)

This denotes a negative lookahead assertion – match if contents does not match next

(?<=match)

Positive lookbehind assertion – matches if the current position in the string is preceded by the match

(?

Negative lookbehind assertion – matches if the current position is not preceded by the match

(?(id/name)yes|no)

Matches a “yes” pattern if “id” or “name” exists or else, matches “no” pattern