Vega strike Python Modules doc: pre Namespace Reference

All Data Structures Namespaces Files Functions Variables

Data Structures
class	RegexObject

class	_Dummy

class	MatchObject

Functions
def	match

def	search

def	sub

def	subn

def	split

def	findall

def	escape

def	compile

Variables
list	__all__

	I = IGNORECASE

	L = LOCALE

	M = MULTILINE

	S = DOTALL

	X = VERBOSE

dictionary	_cache = {}

int	_MAXCACHE = 20

Function Documentation

def pre.compile	(	pattern,
		flags = `0`
	)

compile(pattern[, flags]) -> RegexObject

Compile a regular expression pattern into a regular expression
object, which can be used for matching using its match() and
search() methods.

Definition at line 236 of file pre.py.

 
 def compile(pattern, flags=0):
     """compile(pattern[, flags]) -> RegexObject
 
     Compile a regular expression pattern into a regular expression
     object, which can be used for matching using its match() and
     search() methods.
 
     """
     groupindex={}
     code=pcre_compile(pattern, flags, groupindex)
     return RegexObject(pattern, flags, code, groupindex)
 
 
 #
 #   Class definitions
 #

def pre.escape ( pattern)

escape(string) -> string

Return string with all non-alphanumerics backslashed; this is
useful if you want to match an arbitrary literal string that may
have regular expression metacharacters in it.

Definition at line 220 of file pre.py.

References dospath.join().

 
 def escape(pattern):
     """escape(string) -> string
 
     Return string with all non-alphanumerics backslashed; this is
     useful if you want to match an arbitrary literal string that may
     have regular expression metacharacters in it.
 
     """
     result = list(pattern)
     for i in range(len(pattern)):
         char = pattern[i]
         if not char.isalnum():
             if char=='\000': result[i] = '\\000'
             else: result[i] = '\\'+char
     return ''.join(result)

def pre.findall	(	pattern,
		string
	)

findall(pattern, string) -> list

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

Definition at line 207 of file pre.py.

 
 def findall(pattern, string):
     """findall(pattern, string) -> list
 
     Return a list of all non-overlapping matches of pattern in
     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.
 
     """
     if type(pattern) == type(''):
         pattern = _cachecompile(pattern)
     return pattern.findall(string)

def pre.match	(	pattern,
		string,
		flags = `0`
	)

match (pattern, string[, flags]) -> MatchObject or None

If zero or more characters at the beginning of string match the
regular expression pattern, return a corresponding MatchObject
instance. Return None if the string does not match the pattern;
note that this is different from a zero-length match.

Note: If you want to locate a match anywhere in string, use
search() instead.

Definition at line 129 of file pre.py.

 
 def match(pattern, string, flags=0):
     """match (pattern, string[, flags]) -> MatchObject or None
 
     If zero or more characters at the beginning of string match the
     regular expression pattern, return a corresponding MatchObject
     instance. Return None if the string does not match the pattern;
     note that this is different from a zero-length match.
 
     Note: If you want to locate a match anywhere in string, use
     search() instead.
 
     """
 
     return _cachecompile(pattern, flags).match(string)

def pre.search	(	pattern,
		string,
		flags = `0`
	)

search (pattern, string[, flags]) -> MatchObject or None

Scan through string looking for a location where the regular
expression pattern produces a match, and return a corresponding
MatchObject instance. Return None if no position in the string
matches the pattern; note that this is different from finding a
zero-length match at some point in the string.

Definition at line 144 of file pre.py.

 
 def search(pattern, string, flags=0):
     """search (pattern, string[, flags]) -> MatchObject or None
 
     Scan through string looking for a location where the regular
     expression pattern produces a match, and return a corresponding
     MatchObject instance. Return None if no position in the string
     matches the pattern; note that this is different from finding a
     zero-length match at some point in the string.
 
     """
     return _cachecompile(pattern, flags).search(string)

def pre.split	(	pattern,
		string,
		maxsplit = `0`
	)

split(pattern, string[, maxsplit=0]) -> list of strings

Split string by the occurrences of pattern. If capturing
parentheses are used in pattern, then the text of all groups in
the pattern are also returned as part of the resulting list. If
maxsplit is nonzero, at most maxsplit splits occur, and the
remainder of the string is returned as the final element of the
list.

Definition at line 192 of file pre.py.

 
 def split(pattern, string, maxsplit=0):
     """split(pattern, string[, maxsplit=0]) -> list of strings
 
     Split string by the occurrences of pattern. If capturing
     parentheses are used in pattern, then the text of all groups in
     the pattern are also returned as part of the resulting list. If
     maxsplit is nonzero, at most maxsplit splits occur, and the
     remainder of the string is returned as the final element of the
     list.
 
     """
     if type(pattern) == type(''):
         pattern = _cachecompile(pattern)
     return pattern.split(string, maxsplit)

def pre.sub	(	pattern,
		repl,
		string,
		count = `0`
	)

sub(pattern, repl, string[, count=0]) -> string

Return the string obtained by replacing the leftmost
non-overlapping occurrences of pattern in string by the
replacement repl. If the pattern isn't found, string is returned
unchanged. repl can be a string or a function; if a function, it
is called for every non-overlapping occurrence of pattern. The
function takes a single match object argument, and returns the
replacement string.

The pattern may be a string or a regex object; if you need to
specify regular expression flags, you must use a regex object, or
use embedded modifiers in a pattern; e.g.
sub("(?i)b+", "x", "bbbb BBBB") returns 'x x'.

The optional argument count is the maximum number of pattern
occurrences to be replaced; count must be a non-negative integer,
and the default value of 0 means to replace all occurrences.

Definition at line 156 of file pre.py.

 
 def sub(pattern, repl, string, count=0):
     """sub(pattern, repl, string[, count=0]) -> string
 
     Return the string obtained by replacing the leftmost
     non-overlapping occurrences of pattern in string by the
     replacement repl. If the pattern isn't found, string is returned
     unchanged. repl can be a string or a function; if a function, it
     is called for every non-overlapping occurrence of pattern. The
     function takes a single match object argument, and returns the
     replacement string.
 
     The pattern may be a string or a regex object; if you need to
     specify regular expression flags, you must use a regex object, or
     use embedded modifiers in a pattern; e.g.
     sub("(?i)b+", "x", "bbbb BBBB") returns 'x x'.
 
     The optional argument count is the maximum number of pattern
     occurrences to be replaced; count must be a non-negative integer,
     and the default value of 0 means to replace all occurrences.
 
     """
     if type(pattern) == type(''):
         pattern = _cachecompile(pattern)
     return pattern.sub(repl, string, count)

def pre.subn	(	pattern,
		repl,
		string,
		count = `0`
	)

subn(pattern, repl, string[, count=0]) -> (string, num substitutions)

Perform the same operation as sub(), but return a tuple
(new_string, number_of_subs_made).

Definition at line 181 of file pre.py.

 
 def subn(pattern, repl, string, count=0):
     """subn(pattern, repl, string[, count=0]) -> (string, num substitutions)
 
     Perform the same operation as sub(), but return a tuple
     (new_string, number_of_subs_made).
 
     """
     if type(pattern) == type(''):
         pattern = _cachecompile(pattern)
     return pattern.subn(repl, string, count)

Data Structures

Functions

Variables

Function Documentation

Variable Documentation