Class ParseResults

Returns: a new object with type S, a subtype of T

Overrides: object.__new__

(inherited documentation)

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

Overrides: object.__init__

(inherited documentation)

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']

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

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']

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]

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(x)

Overrides: object.__repr__

(inherited documentation)

str(x)

Overrides: object.__str__

(inherited documentation)

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']

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"}

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

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

Diagnostic method for listing out the contents of a 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

Pretty-printer for parsed results as a list, using the pprint module. Accepts additional positional or keyword args as defined for the pprint.pprint method. (http://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']]