re Namespace Reference

Classes
class	Scanner

Functions
def	match
def	search
def	sub
def	subn
def	split
def	findall
def	finditer
def	compile
def	purge
def	template
def	escape
def	_compile
def	_compile_repl
def	_expand
def	_subx
def	_pickle

Variables
list	__all__
string	__version__ = "2.2.1"
	I = sre_compile.SRE_FLAG_IGNORECASE
	L = sre_compile.SRE_FLAG_LOCALE
	U = sre_compile.SRE_FLAG_UNICODE
	M = sre_compile.SRE_FLAG_MULTILINE
	S = sre_compile.SRE_FLAG_DOTALL
	X = sre_compile.SRE_FLAG_VERBOSE
	T = sre_compile.SRE_FLAG_TEMPLATE
	DEBUG = sre_compile.SRE_FLAG_DEBUG
	error = sre_compile.error
tuple	_alphanum
dictionary	_cache = {}
dictionary	_cache_repl = {}
tuple	_pattern_type = type(sre_compile.compile("", 0))
int	_MAXCACHE = 100

Function Documentation

def re._compile (   key )

private

def re._compile_repl (   key )

private

def re._expand (   pattern,   match,   template  )

private

def re._pickle (   p )

private

def re._subx (   pattern,   template  )

private

def re.compile	(		pattern,
			flags = 0
	)

def re.escape

(

pattern

)

def re.findall	(		pattern,
			string,
			flags = 0
	)

Return a list of all non-overlapping matches in the 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.

def re.finditer	(		pattern,
			string,
			flags = 0
	)

Return an iterator over all non-overlapping matches in the
string.  For each match, the iterator returns a match object.

Empty matches are included in the result.

def re.match	(		pattern,
			string,
			flags = 0
	)

Try to apply the pattern at the start of the string, returning
a match object, or None if no match was found.

def re.purge

(

)

def re.search	(		pattern,
			string,
			flags = 0
	)

Scan through string looking for a match to the pattern, returning
a match object, or None if no match was found.

def re.split	(		pattern,
			string,
			maxsplit = 0,
			flags = 0
	)

Split the source string by the occurrences of the pattern,
returning a list containing the resulting substrings.

def re.sub	(		pattern,
			repl,
			string,
			count = 0,
			flags = 0
	)

Return the string obtained by replacing the leftmost
non-overlapping occurrences of the pattern in string by the
replacement repl.  repl can be either a string or a callable;
if a string, backslash escapes in it are processed.  If it is
a callable, it's passed the match object and must return
a replacement string to be used.

def re.subn	(		pattern,
			repl,
			string,
			count = 0,
			flags = 0
	)

Return a 2-tuple containing (new_string, number).
new_string is the string obtained by replacing the leftmost
non-overlapping occurrences of the pattern in the source
string by the replacement repl.  number is the number of
substitutions that were made. repl can be either a string or a
callable; if a string, backslash escapes in it are processed.
If it is a callable, it's passed the match object and must
return a replacement string to be used.

def re.template	(		pattern,
			flags = 0
	)

Variable Documentation

list re.__all__

Initial value:

= [ "match", "search", "sub", "subn", "split", "findall",
    "compile", "purge", "template", "escape", "I", "L", "M", "S", "X",
    "U", "IGNORECASE", "LOCALE", "MULTILINE", "DOTALL", "VERBOSE",
    "UNICODE", "error" ]

string re.__version__ = "2.2.1"

tuple re._alphanum

Initial value:

= frozenset(
    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")

dictionary re._cache = {}

dictionary re._cache_repl = {}

int re._MAXCACHE = 100

tuple re._pattern_type = type(sre_compile.compile("", 0))

re.DEBUG = sre_compile.SRE_FLAG_DEBUG

re.error = sre_compile.error

re.I = sre_compile.SRE_FLAG_IGNORECASE

re.L = sre_compile.SRE_FLAG_LOCALE

re.M = sre_compile.SRE_FLAG_MULTILINE

re.S = sre_compile.SRE_FLAG_DOTALL

re.T = sre_compile.SRE_FLAG_TEMPLATE

re.U = sre_compile.SRE_FLAG_UNICODE

re.X = sre_compile.SRE_FLAG_VERBOSE