Question

所以我将文件解析为python列表，并且遇到了这样的嵌套列表：

{   1   4{  2a  0.0 }{  3   0.0 }{  4c  0.0 }{  5   0.0 }   }

我想将其解释为一个列表，但仍嵌套，因此我希望它成为如下所示的python列表：

[1,4,[2a,0.0],[3,0.0],[4c,0.0],[5,0.0]]

我设法用下面的代码做一个正确的字符串：

l = """{    1   4{  2   0.0 }{  3   0.0 }{  4   0.0 }{  5   0.0 }   }"""
l = l.replace("{\t",",[").replace("\t}","]").replace("{","[").replace("}","]").replace("\t",",")[1:]

我还可以应用'l.strip("\t")，使其成为列表，但不能嵌套，否则将被展平，这是我不希望的。

我尝试了ast.literal_eval(l)，但在字符串等方面却失败了。 2a

Answer 1

Pyparsing具有内置的帮助器nestedExpr，可帮助解析打开和关闭定界符之间的嵌套列表：

>>> import pyparsing as pp
>>> nested_braces = pp.nestedExpr('{', '}')
>>> t = """{   1   4{  2a  0.0 }{  3   0.0 }{  4c  0.0 }{  5   0.0 }   }"""
>>> print(nested_braces.parseString(t).asList())
[['1', '4', ['2a', '0.0'], ['3', '0.0'], ['4c', '0.0'], ['5', '0.0']]]

Answer 2

您可以使用RegEx开发自己的解析器。根据您的情况，这不太困难。您可以解析其中的大括号，然后拆分项目并递归评估每个项目。

这是一个例子（并不完美）：

import re

RE_BRACE = r"\{.*\}"
RE_ITEM = r"\d+[a-z]+"
RE_FLOAT = r"[-+]?\d*\.\d+"
RE_INT = r"\d+"

find_all_items = re.compile(
    "|".join([RE_BRACE, RE_ITEM, RE_FLOAT, RE_INT]),
    flags=re.DOTALL).findall

def parse(text):
    mo = re.match(RE_BRACE, text, flags=re.DOTALL)
    if mo:
        content = mo.group()[1:-1]
        items = [parse(part) for part in find_all_items(content)]
        return items
    mo = re.match(RE_ITEM, text, flags=re.DOTALL)
    if mo:
        return mo.group()
    mo = re.match(RE_FLOAT, text, flags=re.DOTALL)
    if mo:
        return float(mo.group())
    mo = re.match(RE_INT, text, flags=re.DOTALL)
    if mo:
        return int(mo.group())
    raise Exception("Invalid text: {0}".format(text))

注意：此解析器无法正确解析{1 {2} {3} 4}。为此，您需要像pyparsing这样的递归解析器。

演示：

s = '''{   1   4{  2a  0.0 }{  3   0.0 }{  4c  0.0 }{  5   0.0 }   }'''

l = parse(s)
print(l)

您得到：

[1, 4, ['2a', 0.0, [3, 0.0, '4c', 0.0], 5, 0.0]]

从字符串解析python嵌套列表

2 个答案: