Module pyparsing :: Class ParseResults
[hide private]
[frames] | no frames]

Class ParseResults

source code

object --+
         |
        ParseResults

Structured parse results, to provide multiple means of access to the parsed data:

Example:

   integer = Word(nums)
   date_str = (integer.setResultsName("year") + '/'
                   + integer.setResultsName("month") + '/'
                   + integer.setResultsName("day"))
   # equivalent form:
   # date_str = integer("year") + '/' + integer("month") + '/' + integer("day")

   # parseString returns a ParseResults object
   result = date_str.parseString("1999/12/31")

   def test(s, fn=repr):
       print("%s -> %s" % (s, fn(eval(s))))
   test("list(result)")
   test("result[0]")
   test("result['month']")
   test("result.day")
   test("'month' in result")
   test("'minutes' in result")
   test("result.dump()", str)

prints:

   list(result) -> ['1999', '/', '12', '/', '31']
   result[0] -> '1999'
   result['month'] -> '12'
   result.day -> '31'
   'month' in result -> True
   'minutes' in result -> False
   result.dump() -> ['1999', '/', '12', '/', '31']
   - day: 31
   - month: 12
   - year: 1999
Instance Methods [hide private]
 
__init__(self, toklist=None, name=None, asList=True, modal=True, isinstance=<built-in function isinstance>)
x.__init__(...) initializes x; see help(type(x)) for signature
source code
 
__getitem__(self, i) source code
 
__setitem__(self, k, v, isinstance=<built-in function isinstance>) source code
 
__delitem__(self, i) source code
 
__contains__(self, k) source code
 
__len__(self) source code
 
__bool__(self) source code
 
__nonzero__(self) source code
 
__iter__(self) source code
 
__reversed__(self) source code
 
_iterkeys(self) source code
 
_itervalues(self) source code
 
_iteritems(self) source code
 
iterkeys(self)
Returns an iterator of all named result keys (Python 2.x only).
source code
 
itervalues(self)
Returns an iterator of all named result values (Python 2.x only).
source code
 
iteritems(self)
Returns an iterator of all named result key-value tuples (Python 2.x only).
source code
 
keys(self)
Returns all named result keys (as a list in Python 2.x, as an iterator in Python 3.x).
source code
 
values(self)
Returns all named result values (as a list in Python 2.x, as an iterator in Python 3.x).
source code
 
items(self)
Returns all named result key-values (as a list of tuples in Python 2.x, as an iterator in Python 3.x).
source code
 
haskeys(self)
Since keys() returns an iterator, this method is helpful in bypassing code that looks for the existence of any defined results names.
source code
 
pop(self, *args, **kwargs)
Removes and returns item at specified index (default= ``last``).
source code
 
get(self, key, defaultValue=None)
Returns named result matching the given key, or if there is no such name, then returns the given ``defaultValue`` or ``None`` if no ``defaultValue`` is specified.
source code
 
insert(self, index, insStr)
Inserts new element at location index in the list of parsed tokens.
source code
 
append(self, item)
Add single element to end of ParseResults list of elements.
source code
 
extend(self, itemseq)
Add sequence of elements to end of ParseResults list of elements.
source code
 
clear(self)
Clear all elements and results names.
source code
 
__getattr__(self, name) source code
 
__add__(self, other) source code
 
__iadd__(self, other) source code
 
__radd__(self, other) source code
 
__repr__(self)
repr(x)
source code
 
__str__(self)
str(x)
source code
 
_asStringList(self, sep='') source code
 
asList(self)
Returns the parse results as a nested list of matching tokens, all converted to strings.
source code
 
asDict(self)
Returns the named parse results as a nested dictionary.
source code
 
copy(self)
Returns a new copy of a :class:`ParseResults` object.
source code
 
asXML(self, doctag=None, namedItemsOnly=False, indent='', formatted=True)
(Deprecated) Returns the parse results as XML.
source code
 
__lookup(self, sub) source code
 
getName(self)
Returns the results name for this token expression.
source code
 
dump(self, indent='', full=True, include_list=True, _depth=0)
Diagnostic method for listing out the contents of a :class:`ParseResults`.
source code
 
pprint(self, *args, **kwargs)
Pretty-printer for parsed results as a list, using the `pprint <https://docs.python.org/3/library/pprint.html>`_ module.
source code
 
__getstate__(self) source code
 
__setstate__(self, state) source code
 
__getnewargs__(self) source code
 
__dir__(self) source code

Inherited from object: __delattr__, __format__, __getattribute__, __hash__, __reduce__, __reduce_ex__, __setattr__, __sizeof__, __subclasshook__

Class Methods [hide private]
 
from_dict(cls, other, name=None)
Helper classmethod to construct a ParseResults from a dict, preserving the name-value relations as results names.
source code
Static Methods [hide private]
a new object with type S, a subtype of T
__new__(cls, toklist=None, name=None, asList=True, modal=True) source code
Properties [hide private]

Inherited from object: __class__

Method Details [hide private]

__new__(cls, toklist=None, name=None, asList=True, modal=True)
Static Method

source code 
Returns: a new object with type S, a subtype of T
Overrides: object.__new__
(inherited documentation)

__init__(self, toklist=None, name=None, asList=True, modal=True, isinstance=<built-in function isinstance>)
(Constructor)

source code 

x.__init__(...) initializes x; see help(type(x)) for signature

Overrides: object.__init__
(inherited documentation)

pop(self, *args, **kwargs)

source code 

Removes and returns item at specified index (default= ``last``). Supports both ``list`` and ``dict`` semantics for ``pop()``. If passed no argument or an integer argument, it will use ``list`` semantics and pop tokens from the list of parsed tokens. If passed a non-integer argument (most likely a string), it will use ``dict`` semantics and pop the corresponding value from any defined results names. A second default return value argument is supported, just as in ``dict.pop()``.

Example:

   def remove_first(tokens):
       tokens.pop(0)
   print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321']
   print(OneOrMore(Word(nums)).addParseAction(remove_first).parseString("0 123 321")) # -> ['123', '321']

   label = Word(alphas)
   patt = label("LABEL") + OneOrMore(Word(nums))
   print(patt.parseString("AAB 123 321").dump())

   # Use pop() in a parse action to remove named result (note that corresponding value is not
   # removed from list form of results)
   def remove_LABEL(tokens):
       tokens.pop("LABEL")
       return tokens
   patt.addParseAction(remove_LABEL)
   print(patt.parseString("AAB 123 321").dump())

prints:

   ['AAB', '123', '321']
   - LABEL: AAB

   ['AAB', '123', '321']

get(self, key, defaultValue=None)

source code 

Returns named result matching the given key, or if there is no such name, then returns the given ``defaultValue`` or ``None`` if no ``defaultValue`` is specified.

Similar to ``dict.get()``.

Example:

   integer = Word(nums)
   date_str = integer("year") + '/' + integer("month") + '/' + integer("day")

   result = date_str.parseString("1999/12/31")
   print(result.get("year")) # -> '1999'
   print(result.get("hour", "not specified")) # -> 'not specified'
   print(result.get("hour")) # -> None

insert(self, index, insStr)

source code 

Inserts new element at location index in the list of parsed tokens.

Similar to ``list.insert()``.

Example:

   print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321']

   # use a parse action to insert the parse location in the front of the parsed results
   def insert_locn(locn, tokens):
       tokens.insert(0, locn)
   print(OneOrMore(Word(nums)).addParseAction(insert_locn).parseString("0 123 321")) # -> [0, '0', '123', '321']

append(self, item)

source code 

Add single element to end of ParseResults list of elements.

Example:

   print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321']

   # use a parse action to compute the sum of the parsed integers, and add it to the end
   def append_sum(tokens):
       tokens.append(sum(map(int, tokens)))
   print(OneOrMore(Word(nums)).addParseAction(append_sum).parseString("0 123 321")) # -> ['0', '123', '321', 444]

extend(self, itemseq)

source code 

Add sequence of elements to end of ParseResults list of elements.

Example:

   patt = OneOrMore(Word(alphas))

   # use a parse action to append the reverse of the matched strings, to make a palindrome
   def make_palindrome(tokens):
       tokens.extend(reversed([t[::-1] for t in tokens]))
       return ''.join(tokens)
   print(patt.addParseAction(make_palindrome).parseString("lskdj sdlkjf lksd")) # -> 'lskdjsdlkjflksddsklfjkldsjdksl'

__repr__(self)
(Representation operator)

source code 

repr(x)

Overrides: object.__repr__
(inherited documentation)

__str__(self)
(Informal representation operator)

source code 

str(x)

Overrides: object.__str__
(inherited documentation)

asList(self)

source code 

Returns the parse results as a nested list of matching tokens, all converted to strings.

Example:

   patt = OneOrMore(Word(alphas))
   result = patt.parseString("sldkj lsdkj sldkj")
   # even though the result prints in string-like form, it is actually a pyparsing ParseResults
   print(type(result), result) # -> <class 'pyparsing.ParseResults'> ['sldkj', 'lsdkj', 'sldkj']

   # Use asList() to create an actual list
   result_list = result.asList()
   print(type(result_list), result_list) # -> <class 'list'> ['sldkj', 'lsdkj', 'sldkj']

asDict(self)

source code 

Returns the named parse results as a nested dictionary.

Example:

   integer = Word(nums)
   date_str = integer("year") + '/' + integer("month") + '/' + integer("day")

   result = date_str.parseString('12/31/1999')
   print(type(result), repr(result)) # -> <class 'pyparsing.ParseResults'> (['12', '/', '31', '/', '1999'], {'day': [('1999', 4)], 'year': [('12', 0)], 'month': [('31', 2)]})

   result_dict = result.asDict()
   print(type(result_dict), repr(result_dict)) # -> <class 'dict'> {'day': '1999', 'year': '12', 'month': '31'}

   # even though a ParseResults supports dict-like access, sometime you just need to have a dict
   import json
   print(json.dumps(result)) # -> Exception: TypeError: ... is not JSON serializable
   print(json.dumps(result.asDict())) # -> {"month": "31", "day": "1999", "year": "12"}

asXML(self, doctag=None, namedItemsOnly=False, indent='', formatted=True)

source code 

(Deprecated) Returns the parse results as XML. Tags are created for tokens and lists that have defined results names.

getName(self)

source code 

Returns the results name for this token expression. Useful when several different expressions might match at a particular location.

Example:

   integer = Word(nums)
   ssn_expr = Regex(r"\d\d\d-\d\d-\d\d\d\d")
   house_number_expr = Suppress('#') + Word(nums, alphanums)
   user_data = (Group(house_number_expr)("house_number")
               | Group(ssn_expr)("ssn")
               | Group(integer)("age"))
   user_info = OneOrMore(user_data)

   result = user_info.parseString("22 111-22-3333 #221B")
   for item in result:
       print(item.getName(), ':', item[0])

prints:

   age : 22
   ssn : 111-22-3333
   house_number : 221B

dump(self, indent='', full=True, include_list=True, _depth=0)

source code 

Diagnostic method for listing out the contents of a :class:`ParseResults`. Accepts an optional ``indent`` argument so that this string can be embedded in a nested display of other data.

Example:

   integer = Word(nums)
   date_str = integer("year") + '/' + integer("month") + '/' + integer("day")

   result = date_str.parseString('12/31/1999')
   print(result.dump())

prints:

   ['12', '/', '31', '/', '1999']
   - day: 1999
   - month: 31
   - year: 12

pprint(self, *args, **kwargs)

source code 

Pretty-printer for parsed results as a list, using the `pprint <https://docs.python.org/3/library/pprint.html>`_ module. Accepts additional positional or keyword args as defined for `pprint.pprint <https://docs.python.org/3/library/pprint.html#pprint.pprint>`_ .

Example:

   ident = Word(alphas, alphanums)
   num = Word(nums)
   func = Forward()
   term = ident | num | Group('(' + func + ')')
   func <<= ident + Group(Optional(delimitedList(term)))
   result = func.parseString("fna a,b,(fnb c,d,200),100")
   result.pprint(width=40)

prints:

   ['fna',
    ['a',
     'b',
     ['(', 'fnb', ['c', 'd', '200'], ')'],
     '100']]

from_dict(cls, other, name=None)
Class Method

source code 

Helper classmethod to construct a ParseResults from a dict, preserving the name-value relations as results names. If an optional 'name' argument is given, a nested ParseResults will be returned