来自pyparsing的嵌套字典输出

Question

我正在使用pyparsing来解析形如以下表达式：

"and(or(eq(x,1), eq(x,2)), eq(y,3))"

我的测试代码如下：

from pyparsing import Word, alphanums, Literal, Forward, Suppress, ZeroOrMore, CaselessLiteral, Group

field = Word(alphanums)
value = Word(alphanums)
eq_ = CaselessLiteral('eq') + Group(Suppress('(') + field + Literal(',').suppress() + value + Suppress(')'))
ne_ = CaselessLiteral('ne') + Group(Suppress('(') + field + Literal(',').suppress() + value + Suppress(')'))
function = ( eq_ | ne_ )

arg = Forward()
and_ = Forward()
or_ = Forward()

arg << (and_ | or_ |  function) + Suppress(",") + (and_ | or_ | function) + ZeroOrMore(Suppress(",") + (and_ | function))

and_ << Literal("and") + Suppress("(") + Group(arg) + Suppress(")")
or_ << Literal("or") + Suppress("(") + Group(arg) + Suppress(")")

exp = (and_ | or_ | function)

print(exp.parseString("and(or(eq(x,1), eq(x,2)), eq(y,3))"))

我有以下格式的输出：

['and', ['or', ['eq', ['x', '1'], 'eq', ['x', '2']], 'eq', ['y', '3']]]

列表输出看起来还不错。但是为了后续处理，我希望以嵌套字典的形式输出：

{
    name: 'and',
    args: [
        {
            name: 'or',
            args: [
                {
                    name: 'eq',
                    args: ['x','1']
                },
                {
                    name: 'eq',
                    args: ['x','2']
                }
            ]
        },
        {
            name: 'eq',
            args: ['y','3']
        }
    ]
}

我尝试过使用Dict类，但没有成功。

是否可以使用pyparsing完成？还是我需要手动格式化列表输出？

- Horned Owl

Answer 1

您要查找的功能是pyparsing中一个重要的功能，即设置结果名称。对于大多数pyparsing应用程序，建议使用结果名称。这个功能自版本0.9以来就一直存在。

expr.setResultsName("abc")

这使我可以通过 res["abc"] 或者 res.abc（其中 res 是从 parser.parseString 返回的值）来访问整个解析结果中特定的字段。您还可以调用 res.dump() 查看嵌套式的结果视图。

但考虑到保持解析器易于一目了然，我在 1.4.6 中添加了对这种形式 setResultsName 的支持：

expr("abc")

这是经过简洁处理并添加结果名称的解析器：

COMMA,LPAR,RPAR = map(Suppress,",()")
field = Word(alphanums)
value = Word(alphanums)
eq_ = CaselessLiteral('eq')("name") + Group(LPAR + field + COMMA + value + RPAR)("args")
ne_ = CaselessLiteral('ne')("name") + Group(LPAR + field + COMMA + value + RPAR)("args")
function = ( eq_ | ne_ )

arg = Forward()
and_ = Forward()
or_ = Forward()
exp = Group(and_ | or_ | function)

arg << delimitedList(exp)

and_ << Literal("and")("name") + LPAR + Group(arg)("args") + RPAR
or_ << Literal("or")("name") + LPAR + Group(arg)("args") + RPAR

不幸的是，dump() 只处理结果的嵌套，而不是值列表，因此它不像json.dumps那样好用(也许这将是一个很好的增强 dump() 的方法?)。所以这里有一个自定义方法来转储您的嵌套名称参数结果:

ob = exp.parseString("and(or(eq(x,1), eq(x,2)), eq(y,3))")[0]

INDENT_SPACES = '    '
def dumpExpr(ob, level=0):
    indent = level * INDENT_SPACES
    print (indent + '{')
    print ("%s%s: %r," % (indent+INDENT_SPACES, 'name', ob['name']))
    if ob.name in ('eq','ne'):
        print ("%s%s: %s"   % (indent+INDENT_SPACES, 'args', ob.args.asList()))
    else:
        print ("%s%s: ["   % (indent+INDENT_SPACES, 'args'))
        for arg in ob.args:
            dumpExpr(arg, level+2)
        print ("%s]"   % (indent+INDENT_SPACES))
    print (indent + '}' + (',' if level > 0 else ''))
dumpExpr(ob)

提供：

{
    name: 'and',
    args: [
        {
            name: 'or',
            args: [
                {
                    name: 'eq',
                    args: ['x', '1']
                },
                {
                    name: 'eq',
                    args: ['x', '2']
                },
            ]
        },
        {
            name: 'eq',
            args: ['y', '3']
        },
    ]
}

- PaulMcG

---

是的，这正是我所需要的。感谢您清理我的代码。我是pyparsing的新手。 - Horned Owl

有时候你会有一种冲动，它必须被满足。基于这个问题的工作，我增强了pyparsing的ParseResults类中dump()方法，以列出未命名嵌套结果的数组值。它已经在最新的SVN代码中检查过，并将包含在2.0.3版本中发布。 - PaulMcG

Answer 2

我认为pyparsing没有这样的功能，但您可以递归创建数据结构：

def toDict(lst):
    if not isinstance(lst[1], list):
        return lst
    return [{'name': name, 'args': toDict(args)}
            for name, args in zip(lst[::2], lst[1::2])]

你的示例在args子项的数量上表现不同。如果只有一个，你只需使用一个dict，否则就是一组字典。这将导致复杂的使用。即使只有一个子项，最好使用一组字典。这样，您始终知道如何迭代子项而无需类型检查。

范例

我们可以使用json.dumps来漂亮地打印输出（注意这里我们打印parsedict[0]，因为我们知道根节点只有一个子项，但我们总是按照前面指定的返回列表）。

import json
parsed = ['and', ['or', ['eq', ['x', '1'], 'eq', ['x', '2']], 'eq', ['y', '3']]]
parsedict = toDict(parsed)
print json.dumps(parsedict[0], indent=4, separators=(',', ': '))

输出

{
    "name": "and",
    "args": [
        {
            "name": "or",
            "args": [
                {
                    "name": "eq",
                    "args": [
                        "x",
                        "1"
                    ]
                },
                {
                    "name": "eq",
                    "args": [
                        "x",
                        "2"
                    ]
                }
            ]
        },
        {
            "name": "eq",
            "args": [
                "y",
                "3"
            ]
        }
    ]
}

为了获得这个输出，我在toDict函数中使用collections.OrderedDict替换了dict，只是为了保留args前面的name。

- enrico.bacis

---

输出为：{'args': [{'args': [{'args': [['x', '1'], 'eq', ['x', '2']], 'name': 'eq'}, 'eq', ['y', '3']], 'name': 'or'}], 'name': 'and'} 结构 ['x', '1'] 和 ['x', '2'] 不正确。 - Stephen Lin

好主意 - 在pyparsing中仅进行解析数据的结构化处理，然后跟随转换过程将其转换为特定的数据结构并不罕见，如果结果名称和解析操作不足（例如当所需的输出数据结构表示某些数据的汇总或累积时，这在解析的子元素之间很困难）。在这种情况下，结果名称和添加组以进行结构处理就足够了。 - PaulMcG