Parsley 语法解析器基础教程：从正则表达式到语法解析

什么是 Parsley

Parsley 是一个面向 Python 开发者的模式匹配和语法解析工具。它比 Python 内置的 re 模块提供的正则表达式功能更加强大，允许开发者定义复杂的语法规则来处理结构化文本。

从正则表达式到语法解析

大多数 Python 开发者都熟悉正则表达式，它们通过 re 模块提供。正则表达式使用字符串描述要匹配的模式：

import re
x = re.compile("a(b|c)d+e")
x.match("abddde")

在 Parsley 中，我们可以实现类似的功能：

import parsley
x = parsley.makeGrammar("foo = 'a' ('b' | 'c') 'd'+ 'e'", {})
x("abdde").foo()

Parsley 与正则表达式的区别

1. 命名规则

Parsley 语法可以包含多个命名规则，这些规则可以相互调用。例如：

foo = 'a' baz 'd'+ 'e'
baz = 'b' | 'c'

这种结构使得复杂的语法可以被分解为多个小的、可重用的部分。

2. 表达式返回值

Parsley 规则本质上是表达式，它们会返回最后一个匹配项的值。在底层，Parsley 将每个规则转换为 Python 方法：

def foo(self):
    match('a')
    self.baz()
    match_one_or_more('d')
    return match('e')

def baz(self):
    return match('b') or match('c')

高级特性

嵌入 Python 表达式

Parsley 允许在规则中嵌入 Python 代码，使用 -> 操作符：

x = parsley.makeGrammar("""
foo = 'a':one baz:two 'd'+ 'e' -> (one, two)
baz = 'b' | 'c'
""", {})
print(x("abdde").foo())  # 输出: ('a', 'b')

自定义匹配条件

使用 ?() 可以添加自定义匹配条件：

digit = anything:x ?(x in '0123456789') -> x

重复匹配生成列表

重复匹配操作符（*, +, {n,m}）会返回匹配结果的列表：

digit = anything:x ?(x in '0123456789') -> x
number = digit+
print(x("314159").number())  # 输出: ['3', '1', '4', '1', '5', '9']

捕获输入片段

使用 <> 可以捕获匹配的原始输入片段：

number = <digit+>:ds -> int(ds)

构建计算器示例

让我们用 Parsley 构建一个支持四则运算的计算器。

基础加法

x = parsley.makeGrammar("""
digit = anything:x ?(x in '0123456789')
number = <digit+>:ds -> int(ds)
expr = number:left ( '+' number:right -> left + right
                   | -> left)
""", {})

添加减法

expr = number:left ( '+' number:right -> left + right
                   | '-' number:right -> left - right
                   | -> left)

支持空格

ws = ' '*
expr = number:left ws ('+' ws number:right -> left + right
                      |'-' ws number:right -> left - right
                      | -> left)

多运算符支持

def calculate(start, pairs):
    result = start
    for op, value in pairs:
        if op == '+':
            result += value
        elif op == '-':
            result -= value
    return result

x = parsley.makeGrammar("""
number = <digit+>:ds -> int(ds)
ws = ' '*
add = '+' ws number:n -> ('+', n)
sub = '-' ws number:n -> ('-', n)
addsub = ws (add | sub)
expr = number:left addsub*:right -> calculate(left, right)
""", {"calculate": calculate})

添加乘除法

def calculate(start, pairs):
    result = start
    for op, value in pairs:
        if op == '+':
            result += value
        elif op == '-':
            result -= value
        elif op == '*':
            result *= value
        elif op == '/':
            result /= value
    return result

x = parsley.makeGrammar("""
number = <digit+>:ds -> int(ds)
ws = ' '*
add = '+' ws expr2:n -> ('+', n)
sub = '-' ws expr2:n -> ('-', n)
mul = '*' ws number:n -> ('*', n)
div = '/' ws number:n -> ('/', n)

addsub = ws (add | sub)
muldiv = ws (mul | div)

expr = expr2:left addsub*:right -> calculate(left, right)
expr2 = number:left muldiv*:right -> calculate(left, right)
""", {"calculate": calculate})

支持括号

x = parsley.makeGrammar("""
number = <digit+>:ds -> int(ds)
parens = '(' ws expr:e ws ')' -> e
value = number | parens
ws = ' '*
add = '+' ws expr2:n -> ('+', n)
sub = '-' ws expr2:n -> ('-', n)
mul = '*' ws value:n -> ('*', n)
div = '/' ws value:n -> ('/', n)

addsub = ws (add | sub)
muldiv = ws (mul | div)

expr = expr2:left addsub*:right -> calculate(left, right)
expr2 = value:left muldiv*:right -> calculate(left, right)
""", {"calculate": calculate})

print(x("4 * (5 + 6) + 1").expr())  # 输出: 45

总结

通过这个教程，我们学习了 Parsley 的基础语法和核心概念，从简单的模式匹配到构建一个完整的四则运算计算器。Parsley 的强大之处在于：

1. 支持命名规则和规则间的相互调用
2. 能够嵌入 Python 表达式
3. 提供灵活的输入捕获机制
4. 支持复杂的语法结构如运算符优先级和括号

这些特性使得 Parsley 成为处理复杂文本解析任务的强大工具。