pyparsing.ParseExpression

Module pyparsing :: Class ParseExpression |
[frames] | no frames]

# Class ParseExpression

source code

       object --+
                |
    ParserElement --+
                    |
                   ParseExpression

Known Subclasses:
  - And
  - , Each
  - , MatchFirst
  - , Or

Abstract subclass of ParserElement, for combining and post-processing parsed tokens.

Instance Methods
__init__(self, exprs, savelist=False) x.__init__(...) initializes x; see help(type(x)) for signature | source code
__getitem__(self, i) | source code
append(self, other) | source code
leaveWhitespace(self) Extends `leaveWhitespace` defined in base class, and also invokes `leaveWhitespace` on all contained expressions. | source code
ignore(self, other) Define expression to be ignored (e.g., comments) while doing pattern matching; may be called repeatedly, to define multiple comment or other ignorable patterns. | source code
__str__(self) str(x) | source code
streamline(self) | source code
setResultsName(self, name, listAllMatches=False) Define name for referencing matching tokens as a nested attribute of the returned parse results. | source code
validate(self, validateTrace=`[``]`) Check defined expressions for valid structure, check for infinite recursive definitions. | source code
copy(self) Make a copy of this `ParserElement`. | source code
Inherited from `ParserElement`: `__add__`, `__and__`, `__call__`, `__eq__`, `__hash__`, `__invert__`, `__mul__`, `__ne__`, `__or__`, `__radd__`, `__rand__`, `__repr__`, `__req__`, `__rmul__`, `__rne__`, `__ror__`, `__rsub__`, `__rxor__`, `__sub__`, `__xor__`, `addCondition`, `addParseAction`, `canParseNext`, `checkRecursion`, `matches`, `parseFile`, `parseImpl`, `parseString`, `parseWithTabs`, `postParse`, `preParse`, `runTests`, `scanString`, `searchString`, `setBreak`, `setDebug`, `setDebugActions`, `setFailAction`, `setName`, `setParseAction`, `setWhitespaceChars`, `split`, `suppress`, `transformString`, `tryParse` Inherited from `object`: `__delattr__`, `__format__`, `__getattribute__`, `__new__`, `__reduce__`, `__reduce_ex__`, `__setattr__`, `__sizeof__`, `__subclasshook__`

Static Methods
Inherited from `ParserElement`: `enablePackrat`, `inlineLiteralsUsing`, `resetCache`, `setDefaultWhitespaceChars`

Class Variables
Inherited from `ParserElement`: `DEFAULT_WHITE_CHARS`, `packrat_cache`, `packrat_cache_lock`, `packrat_cache_stats`, `verbose_stacktrace`

Properties
Inherited from `object`: `__class__`

Method Details

### __init__(self, exprs, savelist=False) (Constructor) | source code
x.__init__(...) initializes x; see help(type(x)) for signature Overrides: object.__init__ (inherited documentation)

### leaveWhitespace(self) | source code
Extends `leaveWhitespace` defined in base class, and also invokes `leaveWhitespace` on all contained expressions. Overrides: ParserElement.leaveWhitespace

### ignore(self, other) | source code
Define expression to be ignored (e.g., comments) while doing pattern matching; may be called repeatedly, to define multiple comment or other ignorable patterns. Example:
       patt = OneOrMore(Word(alphas))
       patt.parseString('ablaj /* comment */ lskjd') # -> ['ablaj']

       patt.ignore(cStyleComment)
       patt.parseString('ablaj /* comment */ lskjd') # -> ['ablaj', 'lskjd']
Overrides: ParserElement.ignore (inherited documentation)

### __str__(self) (Informal representation operator) | source code
str(x) Overrides: object.__str__ (inherited documentation)

### streamline(self) | source code
Overrides: ParserElement.streamline

### setResultsName(self, name, listAllMatches=False) | source code
Define name for referencing matching tokens as a nested attribute of the returned parse results. NOTE: this returns a *copy* of the original `ParserElement` object; this is so that the client can define a basic element, such as an integer, and reference it in multiple places with different names. You can also set results names using the abbreviated syntax, `expr("name")` in place of `expr.setResultsName("name")` - see __call__. Example:
       date_str = (integer.setResultsName("year") + '/'
                   + integer.setResultsName("month") + '/'
                   + integer.setResultsName("day"))

       # equivalent form:
       date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
Overrides: ParserElement.setResultsName (inherited documentation)

### validate(self, validateTrace=`[``]`) | source code
Check defined expressions for valid structure, check for infinite recursive definitions. Overrides: ParserElement.validate (inherited documentation)

### copy(self) | source code
Make a copy of this `ParserElement`. Useful for defining different parse actions for the same parsing pattern, using copies of the original parse element. Example:
       integer = Word(nums).setParseAction(lambda toks: int(toks[0]))
       integerK = integer.copy().addParseAction(lambda toks: toks[0]*1024) + Suppress("K")
       integerM = integer.copy().addParseAction(lambda toks: toks[0]*1024*1024) + Suppress("M")

       print(OneOrMore(integerK | integerM | integer).parseString("5K 100 640K 256M"))
prints:
       [5120, 100, 655360, 268435456]
Equivalent form of `expr.copy()` is just `expr()`:
       integerM = integer().addParseAction(lambda toks: toks[0]*1024*1024) + Suppress("M")
Overrides: ParserElement.copy (inherited documentation)