Python中的正则表达式曲线括号

我有这样一个字符串：

a = '{CGPoint={CGPoint=d{CGPoint=dd}}}{CGSize=dd}dd{CSize=aa}'

['CGPoint={CGPoint=d{CGPoint=dd}}', 'CGSize=dd', 'dd', 'CSize=aa']

import pyparsing

lbrace = Literal('{')
rbrace = Literal('}')  
contents = Word(printables)
expr = Forward()
expr << Combine(Suppress(lbrace) + contents + Suppress(rbrace) + expr)

for line in lines:
    results = expr.parseString(line)

目前，我正在使用此

re

语句来获得所需的结果：

filter(None, re.split("\\{(.*?)\\}", a))

但这给了我：

['CGPoint={CGPoint=d{CGPoint=dd', '}}', 'CGSize=dd', 'dd', 'CSize=aa']

这对于我目前的情况是不正确的，我需要这样的列表：

a = '{CGPoint={CGPoint=d{CGPoint=dd}}}{CGSize=dd}dd{CSize=aa}'

['CGPoint={CGPoint=d{CGPoint=dd}}', 'CGSize=dd', 'dd', 'CSize=aa']

import pyparsing

lbrace = Literal('{')
rbrace = Literal('}')  
contents = Word(printables)
expr = Forward()
expr << Combine(Suppress(lbrace) + contents + Suppress(rbrace) + expr)

for line in lines:
    results = expr.parseString(line)

---

下面是一些伪代码。它创建一个字符串堆栈，并在遇到右大括号时弹出它们。一些额外的逻辑来处理数组中不包含遇到的第一个大括号这一事实

String source = "{CGPoint={CGPoint=d{CGPoint=dd}}}{CGSize=dd}dd{CSize=aa}";
Array results;
Stack stack;

foreach (match in source.match("[{}]|[^{}]+")) {
    switch (match) {
        case '{':
           if (stack.size == 0) stack.push(new String()); // add new empty string
           else stack.push('{'); // child, so include matched brace.
        case '}':
           if (stack.size == 1) results.add(stack.pop()) // clear stack add to array
           else stack.last += stack.pop() + '}"; // pop from stack and concatenate to previous
        default:
           if (stack.size == 0) results.add(match); // loose text, add to results
           else stack.last += match;  // append to latest member.
    }
}

---

@m.buettner在评论中指出，Python对正则表达式的实现不能匹配任意程度的嵌套符号对。（其他语言可以，尤其是当前版本的Perl。）当您有正则表达式无法解析的文本时，Pythonic方法就是使用递归下降解析器

然而，没有必要通过编写自己的文档来重新发明轮子；有许多易于使用的解析库。我建议您直接在代码中定义语法，并轻松地将操作附加到匹配的标记。您的代码如下所示：

a = '{CGPoint={CGPoint=d{CGPoint=dd}}}{CGSize=dd}dd{CSize=aa}'

['CGPoint={CGPoint=d{CGPoint=dd}}', 'CGSize=dd', 'dd', 'CSize=aa']

import pyparsing

lbrace = Literal('{')
rbrace = Literal('}')  
contents = Word(printables)
expr = Forward()
expr << Combine(Suppress(lbrace) + contents + Suppress(rbrace) + expr)

for line in lines:
    results = expr.parseString(line)

import-pyparsing
lbrace=Literal（“{”）
rbrace=Literal（'}'）
内容=Word（可打印）
expr=Forward（）
exprPython有一个替代的正则表达式模块，我非常喜欢它，它支持递归模式：

然后，您可以在正则表达式中使用递归模式，如下脚本所示：

import regex
from pprint import pprint


thestr = '{CGPoint={CGPoint=d{CGPoint=dd}}}{CGSize=dd}dd{CSize=aa}'

theregex = r'''
    (
        {
            (?<match>
                [^{}]*
                (?:
                    (?1)
                    [^{}]*
                )+
                |
                [^{}]+
            )
        }
        |
        (?<match>
            [^{}]+
        )
    )
'''

matches = regex.findall(theregex, thestr, regex.X)

print 'all matches:\n'
pprint(matches)

print '\ndesired matches:\n'
print [match[1] for match in matches]

具有用于匹配嵌套表达式的
nestedExpr
函数：

import pyparsing as pp

ident = pp.Word(pp.alphanums)
expr = pp.nestedExpr("{", "}") | ident

thestr = '{CGPoint={CGPoint=d{CGPoint=dd}}}{CGSize=dd}dd{CSize=aa}'
for result in expr.searchString(thestr):
    print(result)

屈服

[['CGPoint=', ['CGPoint=d', ['CGPoint=dd']]]]
[['CGSize=dd']]
['dd']
[['CSize=aa']]

用python的正则表达式风格无法做到这一点。任意嵌套的结构超出了它的能力范围。逐个字符遍历字符串，并保持
深度
计数，遇到
{
时增加，遇到
}
时减少。回到
0
时，从找到第一个
{
到此为止。@m.buettner是正确的。您需要在标记上编写一个解析器到解析器，本例为大括号和大括号，以生成结果。考虑到问题的简单性，这应该很容易做到。我认为python可以为我做到这一点：D，但是的，像这样编写解析器不会有任何问题，tnx:）确切的想法是什么，我没有完全看到你想要得到的结果中的逻辑。你确实有正则表达式的递归反向引用，虽然这是可能的，但我只是不完全理解你想要什么？有没有办法让theregex匹配内括号字符串，
{CGPoint=d{CGPoint=dd}
和
{CGPoint=dd}
？@unutbu这可能是有可能的，但是从正则表达式返回的匹配中，您将不知道嵌套括号的深度。如果您想知道深度，您提供的解决方案会更好。