Python 如何迭代字符串列表并进行模式匹配？

我有一个字符串列表，如下所示：

lst= ['(', 'A', '(', 'B', '(', 'C', 'D', ')', '(', 'E', 'F', ')', ')', '(', 'G', 'H', ')', ')']

(A(B(CD)(EF))(GH))

结合在一起，看起来是这样的：

lst= ['(', 'A', '(', 'B', '(', 'C', 'D', ')', '(', 'E', 'F', ')', ')', '(', 'G', 'H', ')', ')']

(A(B(CD)(EF))(GH))

我想按元素遍历列表，并将值存储到两个列表中，如下所示：

['A'，'B'，'G']

['B'，'C'，'E']

我试着这么做：

l1=[]
for i in range(len(lst)):
    if lst[i] == '(':
        l1.append(lst[i+1])

我如何打破计算，使其计算开始和结束括号的数量，当开始括号得到结束括号时，然后在下一个开始括号后添加元素，以获得结果：

['A'，'B'，'G']

['B'，'C'，'E']

？

导入re
import re

string = ''.join(lst)
results = []

for match in re.finditer('\w\(', string):
    parens = 0
    substring = string[match.start():]
    results.append([substring[0]])
    for ii, ch in enumerate(substring):
        if ch == '(':
            parens += 1
            if parens == 1:
                results[-1].append(substring[ii+1])
        elif ch == ')':
            parens -= 1
            if parens < 0:
                break

字符串=“”。连接（lst）
结果=[]
对于re.finditer（“\w\（”，字符串）中的匹配项：
帕伦斯=0
substring=string[match.start（）：]
results.append（[子字符串[0]]）
对于ii，ch in枚举（子字符串）：
如果ch=='（'：
帕伦斯+=1
如果parens==1：
结果[-1]。追加（子字符串[ii+1]）
elif ch=='）'：
帕伦斯-=1
如果parens<0：
打破

或不带正则表达式：

results = []

for jj in range(len(lst) - 1):
    if lst[jj] != ')' and lst[jj+1] == '(':
        parens = 0
        results.append([lst[jj]])
        substring = lst[jj:]
        for ii, ch in enumerate(substring):
            if ch == '(':
                parens += 1
                if parens == 1:
                    results[-1].append(substring[ii+1])
            elif ch == ')':
                parens -= 1
                if parens < 0:
                    break

results=[]
对于范围内的jj（透镜（lst）-1）：
如果lst[jj]！='）和lst[jj+1]='（'：
帕伦斯=0
results.append（[lst[jj]]））
子字符串=lst[jj:]
对于ii，ch in枚举（子字符串）：
如果ch=='（'：
帕伦斯+=1
如果parens==1：
结果[-1]。追加（子字符串[ii+1]）
elif ch=='）'：
帕伦斯-=1
如果parens<0：
打破

如果我理解正确，字符串表示一个树结构，每个节点都有一个名称和任意数量的子节点。在s表达式样式中，此名称是列表中的第一个条目（如果有列表，则只命名叶节点）

在这个树中，您需要一个具有多个分支的节点的打印输出，包括这些分支的名称，但不包括它们的内容。使用堆栈（可能在递归中隐式）解析它们确实是最简单的

from pprint import pprint

instr="(A(B(CD)(EF))(GH))"

nodes=[]
curnode=nodes
nodestack=[]
for char in instr:
    if char == '(':
        nodestack.append(curnode)
        curnode.append([])
        curnode=curnode[-1]
    elif char == ')':
        curnode=nodestack.pop()
    else:
        curnode.append(char)

# Show that the tree is now converted into list form
pprint(nodes, width=20)

def name(node):
    return node[0]
def branches(tree):
    if len(tree)>=3:
        yield map(name,tree)    # exploits that names are only 1 char
    for branch in tree[1:]:
        # search deeper also
        for subbranch in branches(branch):
            yield subbranch

for root in nodes:
    pprint(list(branches(root)))

---

当分支节点完成解析时（在

案例中）

当然可以通过打印分支节点来合并操作。

我不理解您的示例。不清楚是什么机制导致A，B，G在一组中，而B，C，E在另一组中。例如，为什么F不存在，而B出现两次？这些规则到底是什么？“John Zwinck，我想考虑一下：A有2个内部列表（B（CD）（EF））和（GH），所以我想提取这两个内部列表的第一个元素。类似地，B有两个内部列表，（CD）和（EF），所以我想提取B，C，E.u应该使用堆栈来实现它