Vega strike Python Modules doc: MatchObject Class Reference

All Data Structures Namespaces Files Functions Variables

Public Member Functions
def	__init__

def	start

def	end

def	span

def	groups

def	group

def	groupdict

Data Fields
	re

	string

	pos

	endpos

	regs

Detailed Description

Holds a compiled regular expression pattern.

Methods:
start      Return the index of the start of a matched substring.
end        Return the index of the end of a matched substring.
span       Return a tuple of (start, end) of a matched substring.
groups     Return a tuple of all the subgroups of the match.
group      Return one or more subgroups of the match.
groupdict  Return a dictionary of all the named subgroups of the match.

Definition at line 506 of file pre.py.

Constructor & Destructor Documentation

def __init__	(	self,
		re,
		string,
		pos,
		endpos,
		regs
	)

Definition at line 519 of file pre.py.

 
     def __init__(self, re, string, pos, endpos, regs):
         self.re = re
         self.string = string
         self.pos = pos
         self.endpos = endpos
         self.regs = regs

Member Function Documentation

def end	(	self,
		g = `0`
	)

end([group=0]) -> int or None

Return the indices of the end of the substring matched by
group; group defaults to zero (meaning the whole matched
substring). Return -1 if group exists but did not contribute
to the match.

Definition at line 542 of file pre.py.

References MatchObject.regs.

 
     def end(self, g = 0):
         """end([group=0]) -> int or None
 
         Return the indices of the end of the substring matched by
         group; group defaults to zero (meaning the whole matched
         substring). Return -1 if group exists but did not contribute
         to the match.
 
         """
         if type(g) == type(''):
             try:
                 g = self.re.groupindex[g]
             except (KeyError, TypeError):
                 raise IndexError, 'group %s is undefined' % `g`
         return self.regs[g][1]

def group	(	self,
		groups
	)

group([group1, group2, ...]) -> string or tuple

Return one or more subgroups of the match. If there is a
single argument, the result is a single string; if there are
multiple arguments, the result is a tuple with one item per
argument. Without arguments, group1 defaults to zero (i.e. the
whole match is returned). If a groupN argument is zero, the
corresponding return value is the entire matching string; if
it is in the inclusive range [1..99], it is the string
matching the the corresponding parenthesized group. If a group
number is negative or larger than the number of groups defined
in the pattern, an IndexError exception is raised. If a group
is contained in a part of the pattern that did not match, the
corresponding result is None. If a group is contained in a
part of the pattern that matched multiple times, the last
match is returned.

If the regular expression uses the (?P<name>...) syntax, the
groupN arguments may also be strings identifying groups by
their group name. If a string argument is not used as a group
name in the pattern, an IndexError exception is raised.

Definition at line 592 of file pre.py.

References MatchObject.regs, MatchObject.string, and log_faction_ships.tuple.

 
     def group(self, *groups):
         """group([group1, group2, ...]) -> string or tuple
 
         Return one or more subgroups of the match. If there is a
         single argument, the result is a single string; if there are
         multiple arguments, the result is a tuple with one item per
         argument. Without arguments, group1 defaults to zero (i.e. the
         whole match is returned). If a groupN argument is zero, the
         corresponding return value is the entire matching string; if
         it is in the inclusive range [1..99], it is the string
         matching the the corresponding parenthesized group. If a group
         number is negative or larger than the number of groups defined
         in the pattern, an IndexError exception is raised. If a group
         is contained in a part of the pattern that did not match, the
         corresponding result is None. If a group is contained in a
         part of the pattern that matched multiple times, the last
         match is returned.
 
         If the regular expression uses the (?P<name>...) syntax, the
         groupN arguments may also be strings identifying groups by
         their group name. If a string argument is not used as a group
         name in the pattern, an IndexError exception is raised.
 
         """
         if len(groups) == 0:
             groups = (0,)
         result = []
         for g in groups:
             if type(g) == type(''):
                 try:
                     g = self.re.groupindex[g]
                 except (KeyError, TypeError):
                     raise IndexError, 'group %s is undefined' % `g`
             if g >= len(self.regs):
                 raise IndexError, 'group %s is undefined' % `g`
             a, b = self.regs[g]
             if a == -1 or b == -1:
                 result.append(None)
             else:
                 result.append(self.string[a:b])
         if len(result) > 1:
             return tuple(result)
         elif len(result) == 1:
             return result[0]
         else:
             return ()

def groupdict	(	self,
		default = `None`
	)

groupdict([default=None]) -> dictionary

Return a dictionary containing all the named subgroups of the
match, keyed by the subgroup name. The default argument is
used for groups that did not participate in the match.

Definition at line 639 of file pre.py.

References MatchObject.regs, and MatchObject.string.

 
     def groupdict(self, default=None):
         """groupdict([default=None]) -> dictionary
 
         Return a dictionary containing all the named subgroups of the
         match, keyed by the subgroup name. The default argument is
         used for groups that did not participate in the match.
 
         """
         dict = {}
         for name, index in self.re.groupindex.items():
             a, b = self.regs[index]
             if a == -1 or b == -1:
                 dict[name] = default
             else:
                 dict[name] = self.string[a:b]
         return dict

def groups	(	self,
		default = `None`
	)

groups([default=None]) -> tuple

Return a tuple containing all the subgroups of the match, from
1 up to however many groups are in the pattern. The default
argument is used for groups that did not participate in the
match.

Definition at line 574 of file pre.py.

References MatchObject.regs, MatchObject.string, and log_faction_ships.tuple.

 
     def groups(self, default=None):
         """groups([default=None]) -> tuple
 
         Return a tuple containing all the subgroups of the match, from
         1 up to however many groups are in the pattern. The default
         argument is used for groups that did not participate in the
         match.
 
         """
         result = []
         for g in range(1, self.re._num_regs):
             a, b = self.regs[g]
             if a == -1 or b == -1:
                 result.append(default)
             else:
                 result.append(self.string[a:b])
         return tuple(result)

def span	(	self,
		g = `0`
	)

span([group=0]) -> tuple

Return the 2-tuple (m.start(group), m.end(group)). Note that
if group did not contribute to the match, this is (-1,
-1). Group defaults to zero (meaning the whole matched
substring).

Definition at line 558 of file pre.py.

References MatchObject.regs.

 
     def span(self, g = 0):
         """span([group=0]) -> tuple
 
         Return the 2-tuple (m.start(group), m.end(group)). Note that
         if group did not contribute to the match, this is (-1,
         -1). Group defaults to zero (meaning the whole matched
         substring).
 
         """
         if type(g) == type(''):
             try:
                 g = self.re.groupindex[g]
             except (KeyError, TypeError):
                 raise IndexError, 'group %s is undefined' % `g`
         return self.regs[g]

def start	(	self,
		g = `0`
	)

start([group=0]) -> int or None

Return the index of the start of the substring matched by
group; group defaults to zero (meaning the whole matched
substring). Return -1 if group exists but did not contribute
to the match.

Definition at line 526 of file pre.py.

References MatchObject.regs.

 
     def start(self, g = 0):
         """start([group=0]) -> int or None
 
         Return the index of the start of the substring matched by
         group; group defaults to zero (meaning the whole matched
         substring). Return -1 if group exists but did not contribute
         to the match.
 
         """
         if type(g) == type(''):
             try:
                 g = self.re.groupindex[g]
             except (KeyError, TypeError):
                 raise IndexError, 'group %s is undefined' % `g`
         return self.regs[g][0]

Public Member Functions

Data Fields

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation