pe 0.5.3

解析表达式

pe是一个用于解析表达式的库，包括解析表达式文法（PEG）。它旨在将解析表达式的表现力与正则表达式的熟悉性结合起来。例如

>>> import pe
>>> pe.match(r'"-"? [0-9]+', '-38')  # match an integer
<Match object; span=(0, 3), match='-38'>

语法可以用于更复杂或递归的模式

>>> float_parser = pe.compile(r'''
...   Start    <- INTEGER FRACTION? EXPONENT?
...   INTEGER  <- "-"? ("0" / [1-9] [0-9]*)
...   FRACTION <- "." [0-9]+
...   EXPONENT <- [Ee] [-+]? [0-9]+
... ''')
>>> float_parser.match('6.02e23')
<Match object; span=(0, 7), match='6.02e23'>

快速链接

• 文档
  • 规范
  • 指南
  • API文档
  • 常见问题解答
• 示例解析器

功能和目标

• 语法符号与标准PEG向后兼容，只有少数扩展
• 规范描述了解析的语义效果（例如，将表达式映射到函数调用）
• 解析器通常比其他解析库更快，有时快得多；请参阅基准测试
• API直观且熟悉；它基于标准API的re模块
• 语法定义和解析器实现是分开的
  • 优化目标是抽象语法定义
  • 有多种解析器可供选择（目前有packrat用于递归下降和machine用于迭代“解析机器”，如Medeiros和Ierusalimschy，2008所述，并在LPeg中实现）。

语法概述

pe向后兼容标准PEG语法，并且对扩展较为保守。

# terminals
.            # any single character
"abc"        # string literal
'abc'        # string literal
[abc]        # character class

# repeating expressions
e            # exactly one
e?           # zero or one (optional)
e*           # zero or more
e+           # one or more
e{5}         # exactly 5
e{3,5}       # three to five

# combining expressions
e1 e2        # sequence of e1 and e2
e1 / e2      # ordered choice of e1 and e2
(e)          # subexpression

# lookahead
&e           # positive lookahead
!e           # negative lookahead

# (extension) capture substring
~e           # result of e is matched substring

# (extension) binding
name:e       # bind result of e to 'name'

# grammars
Name <- ...  # define a rule named 'Name'
... <- Name  # refer to rule named 'Name'

# (extension) auto-ignore
X <  e1 e2   # define a rule 'X' with auto-ignore

使用解析表达式匹配输入

当解析表达式匹配输入时，它返回一个Match对象，这与Python的re模块中的正则表达式类似。默认情况下，不捕获任何内容，但捕获操作符（~）发出匹配表达式的子字符串，类似于正则表达式的捕获组。

>>> e = pe.compile(r'[0-9] [.] [0-9]')
>>> m = e.match('1.4')
>>> m.group()
'1.4'
>>> m.groups()
()
>>> e = pe.compile(r'~([0-9] [.] [0-9])')
>>> m = e.match('1.4')
>>> m.group()
'1.4'
>>> m.groups()
('1.4',)

值绑定

值绑定提取匹配的发出值，并将其与一个名称关联起来，该名称在Match.groupdict()字典中可用。这与正则表达式的命名捕获组类似，但它提取发出值而不是绑定表达式的子字符串。

>>> e = pe.compile(r'~[0-9] x:(~[.]) ~[0-9]')
>>> m = e.match('1.4')
>>> m.groups()
('1', '4')
>>> m.groupdict()
{'x': '.'}

动作

动作（也称为“语义动作”）是可调用的，用于转换解析结果。当给定任意函数时，它按以下方式调用

func(*match.groups(), **match.groupdict())

该函数调用的结果成为向前发出的唯一值，并且所有绑定值都被清除。

为了获得更多控制，pe提供了Action类和许多子类以供各种用途。这些动作可以访问更多关于解析结果的信息，并对匹配有更多的控制。例如，Pack类接受一个函数，并使用发出值打包成列表来调用它

func(match.groups())

而Join类将所有发出的字符串与分隔符连接起来

func(sep.join(match.groups()), **match.groupdict())

自动忽略

可以定义语法，使得某些规则忽略序列项之间的模式的出现。最常见的是，这用于忽略空白，因此默认的忽略模式是简单的空白。

>>> pe.match("X <- 'a' 'b'", "a b")  # regular rule does not match
>>> pe.match("X <  'a' 'b'", "a b")  # auto-ignore rule matches
<Match object; span=(0, 3), match='a b'>

此功能可以帮助使语法更易于阅读。

示例

这里是一种解析逗号分隔整数列表的方法

>>> from pe.actions import Pack
>>> p = pe.compile(
...   r'''
...     Start  <- "[" Values? "]"
...     Values <- Int ("," Int)*
...     Int    <  ~( "-"? ("0" / [1-9] [0-9]*) )
...   ''',
...   actions={'Values': Pack(list), 'Int': int})
>>> m = p.match('[5, 10, -15]')
>>> m.value()
[5, 10, -15]

类似项目

• Lark（Python）
• nom（Rust）
• Parsimonious（Python）
• Rosie（多种绑定）
• TatSu（Python）
• PEG.js（JavaScript）
• Pegged（D）
• pegen（Python / C）
• LPeg（Lua）