Vega strike Python Modules doc: RegexObject Class Reference

All Data Structures Namespaces Files Functions Variables

Public Member Functions
def	__init__

def	search

def	match

def	sub

def	subn

def	split

def	findall

def	__getinitargs__

def	__getstate__

def	__setstate__

Data Fields
	code

	flags

	pattern

	groupindex

Detailed Description

Holds a compiled regular expression pattern.

Methods:
match    Match the pattern to the beginning of a string.
search   Search a string for the presence of the pattern.
sub      Substitute occurrences of the pattern found in a string.
subn     Same as sub, but also return the number of substitutions made.
split    Split a string by the occurrences of the pattern.
findall  Find all occurrences of the pattern in a string.

Definition at line 253 of file pre.py.

Constructor & Destructor Documentation

def __init__	(	self,
		pattern,
		flags,
		code,
		groupindex
	)

Definition at line 266 of file pre.py.

 
     def __init__(self, pattern, flags, code, groupindex):
         self.code = code
         self.flags = flags
         self.pattern = pattern
         self.groupindex = groupindex

Member Function Documentation

def __getinitargs__ ( self)

Definition at line 489 of file pre.py.

 
     def __getinitargs__(self):
         return (None,None,None,None) # any 4 elements, to work around
                                      # problems with the
                                      # pickle/cPickle modules not yet
# ignoring the __init__ function

def __getstate__ ( self)

Definition at line 494 of file pre.py.

References Compile.flags, RegexObject.flags, RegexObject.groupindex, and RegexObject.pattern.

494

495 def __getstate__(self):

return self.pattern, self.flags, self.groupindex

def __setstate__	(	self,
		statetuple
	)

Definition at line 496 of file pre.py.

References RegexObject.code, Compile.flags, RegexObject.flags, RegexObject.groupindex, and RegexObject.pattern.

 
     def __setstate__(self, statetuple):
         self.pattern = statetuple[0]
         self.flags = statetuple[1]
         self.groupindex = statetuple[2]
         self.code = apply(pcre_compile, statetuple)

def findall	(	self,
		source
	)

findall(source) -> list

Return a list of all non-overlapping matches of the compiled
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 452 of file pre.py.

References reconvert.append, RegexObject.match(), sre_parse.max, and log_faction_ships.tuple.

 
     def findall(self, source):
         """findall(source) -> list
 
         Return a list of all non-overlapping matches of the compiled
         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.
 
         """
         pos = 0
         end = len(source)
         results = []
         match = self.code.match
         append = results.append
         while pos <= end:
             regs = match(source, pos, end, 0)
             if not regs:
                 break
             i, j = regs[0]
             rest = regs[1:]
             if not rest:
                 gr = source[i:j]
             elif len(rest) == 1:
                 a, b = rest[0]
                 gr = source[a:b]
             else:
                 gr = []
                 for (a, b) in rest:
                     gr.append(source[a:b])
                 gr = tuple(gr)
             append(gr)
             pos = max(j, pos+1)
         return results

def match	(	self,
		string,
		pos = `0`,
		endpos = `None`
	)

match(string[, pos][, endpos]) -> MatchObject or None

If zero or more characters at the beginning of string match
this regular expression, 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.

The optional second parameter pos gives an index in the string
where the search is to start; it defaults to 0.  This is not
completely equivalent to slicing the string; the '' pattern
character matches at the real beginning of the string and at
positions just after a newline, but not necessarily at the
index where the search is to start.

The optional parameter endpos limits how far the string will
be searched; it will be as if the string is endpos characters
long, so only the characters from pos to endpos will be
searched for a match.

Definition at line 297 of file pre.py.

References RegexObject._num_regs.

 
     def match(self, string, pos=0, endpos=None):
         """match(string[, pos][, endpos]) -> MatchObject or None
 
         If zero or more characters at the beginning of string match
         this regular expression, 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.
 
         The optional second parameter pos gives an index in the string
         where the search is to start; it defaults to 0.  This is not
         completely equivalent to slicing the string; the '' pattern
         character matches at the real beginning of the string and at
         positions just after a newline, but not necessarily at the
         index where the search is to start.
 
         The optional parameter endpos limits how far the string will
         be searched; it will be as if the string is endpos characters
         long, so only the characters from pos to endpos will be
         searched for a match.
 
         """
         if endpos is None or endpos>len(string):
             endpos=len(string)
         if endpos<pos: endpos=pos
         regs = self.code.match(string, pos, endpos, ANCHORED)
         if regs is None:
             return None
         self._num_regs=len(regs)
         return MatchObject(self,
                            string,
                            pos, endpos,
                            regs)

def search	(	self,
		string,
		pos = `0`,
		endpos = `None`
	)

search(string[, pos][, endpos]) -> MatchObject or None

Scan through string looking for a location where this regular
expression 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. The optional
pos and endpos parameters have the same meaning as for the
match() method.

Definition at line 272 of file pre.py.

References RegexObject._num_regs.

 
     def search(self, string, pos=0, endpos=None):
         """search(string[, pos][, endpos]) -> MatchObject or None
 
         Scan through string looking for a location where this regular
         expression 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. The optional
         pos and endpos parameters have the same meaning as for the
         match() method.
 
         """
         if endpos is None or endpos>len(string):
             endpos=len(string)
         if endpos<pos: endpos=pos
         regs = self.code.match(string, pos, endpos, 0)
         if regs is None:
             return None
         self._num_regs=len(regs)
 
         return MatchObject(self,
                            string,
                            pos, endpos,
                            regs)

def split	(	self,
		source,
		maxsplit = `0`
	)

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

Split string by the occurrences of the compiled pattern. If
capturing parentheses are used in the 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 405 of file pre.py.

References reconvert.append, and RegexObject.match().

 
     def split(self, source, maxsplit=0):
         """split(source[, maxsplit=0]) -> list of strings
 
         Split string by the occurrences of the compiled pattern. If
         capturing parentheses are used in the 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 maxsplit < 0:
             raise error, "negative split count"
         if maxsplit == 0:
             maxsplit = sys.maxint
         n = 0
         pos = 0
         lastmatch = 0
         results = []
         end = len(source)
         match = self.code.match
         append = results.append
         while n < maxsplit:
             regs = match(source, pos, end, 0)
             if not regs:
                 break
             i, j = regs[0]
             if i == j:
                 # Empty match
                 if pos >= end:
                     break
                 pos = pos+1
                 continue
             append(source[lastmatch:i])
             rest = regs[1:]
             if rest:
                 for a, b in rest:
                     if a == -1 or b == -1:
                         group = None
                     else:
                         group = source[a:b]
                     append(group)
             pos = lastmatch = j
             n = n + 1
         append(source[lastmatch:])
         return results

def sub	(	self,
		repl,
		string,
		count = `0`
	)

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

Return the string obtained by replacing the leftmost
non-overlapping occurrences of the compiled pattern in string
by the replacement repl. If the pattern isn't found, string is
returned unchanged.

Identical to the sub() function, using the compiled pattern.

Definition at line 333 of file pre.py.

References RegexObject.subn().

 
     def sub(self, repl, string, count=0):
         """sub(repl, string[, count=0]) -> string
 
         Return the string obtained by replacing the leftmost
         non-overlapping occurrences of the compiled pattern in string
         by the replacement repl. If the pattern isn't found, string is
         returned unchanged.
 
         Identical to the sub() function, using the compiled pattern.
 
         """
         return self.subn(repl, string, count)[0]

def subn	(	self,
		repl,
		source,
		count = `0`
	)

subn(repl, string[, count=0]) -> tuple

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

Definition at line 346 of file pre.py.

References RegexObject._num_regs, reconvert.append, regsub.expand(), dospath.join(), and RegexObject.match().

 
     def subn(self, repl, source, count=0):
         """subn(repl, string[, count=0]) -> tuple
 
         Perform the same operation as sub(), but return a tuple
         (new_string, number_of_subs_made).
 
         """
         if count < 0:
             raise error, "negative substitution count"
         if count == 0:
             count = sys.maxint
         n = 0           # Number of matches
         pos = 0         # Where to start searching
         lastmatch = -1  # End of last match
         results = []    # Substrings making up the result
         end = len(source)
 
         if type(repl) is type(''):
             # See if repl contains group references
             try:
                 repl = pcre_expand(_Dummy, repl)
             except error:
                 m = MatchObject(self, source, 0, end, [])
                 repl = lambda m, repl=repl, expand=pcre_expand: expand(m, repl)
             else:
                 m = None
         else:
             m = MatchObject(self, source, 0, end, [])
 
         match = self.code.match
         append = results.append
         while n < count and pos <= end:
             regs = match(source, pos, end, 0)
             if not regs:
                 break
             self._num_regs = len(regs)
             i, j = regs[0]
             if i == j == lastmatch:
                 # Empty match adjacent to previous match
                 pos = pos + 1
                 append(source[lastmatch:pos])
                 continue
             if pos < i:
                 append(source[pos:i])
             if m:
                 m.pos = pos
                 m.regs = regs
                 append(repl(m))
             else:
                 append(repl)
             pos = lastmatch = j
             if i == j:
                 # Last match was empty; don't try here again
                 pos = pos + 1
                 append(source[lastmatch:pos])
             n = n + 1
         append(source[pos:])
         return (''.join(results), n)

Public Member Functions

Data Fields

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation