Python 如何找到我正在递归的嵌套列表的索引？

我很难找到一种方法来获取嵌套列表列表的列表索引

例如，我可以通过以下两个函数找出给定节点的节点数或列表结构

t = ['add', [ \
        ['divide a', [ \
            ['if statement', ['Var 9', 'Var 5', 'Var 1', 'Var 4']], \
            ['subtract', [ \
                ['add', [ \
                    ['round to integer', ['Var 10']], 'Var 4'] \
                ], 'Var 9' \
            ]] \
        ]], 'Var 4' \
     ]]

def total_nodes(structure,num_nodes):
    s = structure
    print "N:" , num_nodes , s
    num_nodes += 1
    if isinstance(s,str): return num_nodes    
    if s[1]:
        for x in range(len(s[1])):
            num_nodes = total_nodes(s[1][x], num_nodes)
        return num_nodes 


def get_structure_for_node(structure,counter,find_node=1):
    s = structure
    if not isinstance(counter,int):
        return counter
    if counter == find_node:
        return s
    counter += 1
    if isinstance(s,str): return counter
    if s[1]:
        for x in range(len(s[1])):
            counter = get_structure_for_node(s[1][x],counter,find_node=find_node)
        return counter



print 
print total_nodes(t,0)
print
print get_structure_for_node(t,0,find_node=12)

输出：

N: 0 ['add', [['divide a', [['if statement', ['Var 9', 'Var 5', 'Var 1', 'Var 4']], ['subtract', [['add', [['round to integer', ['Var 10']], 'Var 4']], 'Var 9']]]], 'Var 4']]
N: 1 ['divide a', [['if statement', ['Var 9', 'Var 5', 'Var 1', 'Var 4']], ['subtract', [['add', [['round to integer', ['Var 10']], 'Var 4']], 'Var 9']]]]
N: 2 ['if statement', ['Var 9', 'Var 5', 'Var 1', 'Var 4']]
N: 3 Var 9
N: 4 Var 5
N: 5 Var 1
N: 6 Var 4
N: 7 ['subtract', [['add', [['round to integer', ['Var 10']], 'Var 4']], 'Var 9']]
N: 8 ['add', [['round to integer', ['Var 10']], 'Var 4']]
N: 9 ['round to integer', ['Var 10']]
N: 10 Var 10
N: 11 Var 4
N: 12 Var 9
N: 13 Var 4
14

Var 9

从输出中，我可以看到从t到我们搜索的节点“12”的路径是：

t[1][0][1][1][1]

但是，在执行递归函数时，我无法找到跟踪此索引键的方法。我需要更改列表/树的元素

有人要吗

我应该补充一点，我一直试图通过向递归中添加一个变量来跟踪它，该递归构建了一个字符串，表示它的去向，即

path=“10112101”

---

然后稍后再尝试使用它，但是我无法准确地得到它，我希望使用更干净的方法。

您保持路径的方法会有效

但是，对于您的特定问题，使用生成器重写代码可能更有用（而且更像Python）

这意味着在函数中管理索引，并在遍历函数时产生部分结果

treewalk(node):
    for n in node.children:
        for result in treewalk(n):
            yield result
    else:
        yield node 

---

您保持路径的方法将起作用

但是，对于您的特定问题，使用生成器重写代码可能更有用（而且更像Python）

这意味着在函数中管理索引，并在遍历函数时产生部分结果

treewalk(node):
    for n in node.children:
        for result in treewalk(n):
            yield result
    else:
        yield node 

---

最简单的展平算法是：

def flat_list(l):
    for node in l:
        if isinstance(node, list):
            for i in flat_list(node):
                yield i
        else:
            yield node

修改扁平化算法以保持跟踪很容易：

def flat_list_keeping_track(l, track=None):
    track = track or ()
    for i, node in enumerate(l):
        new_track = track + (i,)
        if isinstance(node, list):
            for result in flat_list_keeping_track(node, track=new_track):
                yield result
        else:
            yield node, new_track

现在你可以打字了

def get_structure_for_node(structure, find_node=1):
    return list(flat_list(structure))[find_node][1]

这不是最快的方法。如果您的结构很大，并且使用相对较小的“find_node”值，那么您应该编写类似的内容（基于）：

---

如果速度非常重要，您还可以修改其他展平功能（请参见或）。

最简单的展平算法是：

def flat_list(l):
    for node in l:
        if isinstance(node, list):
            for i in flat_list(node):
                yield i
        else:
            yield node

修改扁平化算法以保持跟踪很容易：

def flat_list_keeping_track(l, track=None):
    track = track or ()
    for i, node in enumerate(l):
        new_track = track + (i,)
        if isinstance(node, list):
            for result in flat_list_keeping_track(node, track=new_track):
                yield result
        else:
            yield node, new_track

现在你可以打字了

def get_structure_for_node(structure, find_node=1):
    return list(flat_list(structure))[find_node][1]

这不是最快的方法。如果您的结构很大，并且使用相对较小的“find_node”值，那么您应该编写类似的内容（基于）：

---

如果速度非常重要，您也可以修改其他展平函数（请参见或）。

还没有仔细研究过这一点，但是您不能为

计数器返回一个列表而不是一个整数，并使用
counter.extend（获取\u节点的\u结构（s[1][x]，counter，find\u node=find\u node）
。（当然，另一个return语句应该类似于
if isinstance（s，str）：return[counter]
）这将非常类似于您的字符串，但感觉更自然（列表而不是带有索引的字符串）和2 /返回值，而不是在函数声明中有一个额外的变量。r

，并使用

counter.extend（为_节点（s[1][x]，counter，find_node=find_node）获取_结构）

（当然，另一个返回语句应该类似于

if isinstance（s，str）：return[counter]

）这与字符串非常相似，但感觉更自然（列表而不是带索引的字符串）2，返回值，而不是在函数声明中有一个额外的变量。ch！我已经插入了平面列表来跟踪，它工作得非常好。