pyparsing的嵌套字典输出

Question

我使用pyparsing来解析形式的表达式：

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

我的测试代码如下：

^{pr2}$

我有以下形式的输出：

['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中可以这样做吗？还是应该手动格式化列表输出？在

Answer 1

您正在寻找的特性是pyparsing中的一个重要特性，即设置结果名称。对于大多数pyparsing应用程序，建议使用结果名称。这个特性从0.9版就已经存在了，因为

expr.setResultsName("abc")

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

但我仍然注意到让解析器易于理解，我在1.4.6中添加了对这种形式的setResultsName的支持：

^{pr2}$

下面是您的解析器，稍加清理，并添加了结果名称：

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文件（也许这会是一个很好的改进来抛弃吗？）。因此，下面是一个自定义方法来转储嵌套的name args结果：

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

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，否则就是一个dict列表。这将导致复杂的使用。即使只有一个孩子，也最好使用一个字典列表。通过这种方式，您总是知道如何在不进行类型检查的情况下迭代子对象。在

示例

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

^{pr2}$

输出

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

为了获得输出，我将dict替换为toDict函数中的collections.OrderedDict，只是为了在args之前保留{}。