0

我在寻找针对嵌套列表列表获取列表索引的方法时遇到了一些麻烦。

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

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][1]

但是当我正在使用递归函数时，我一直无法找到一种方法来跟踪这个索引键。我需要更改列表/树的元素

有接盘侠吗？

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

路径=“10112101”

然后尝试稍后使用它，但是我无法准确地得到它，并且更喜欢更清洁的方式。

4

2 回答 2

3

最简单的扁平化算法是：

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”值，那么您应该编写类似的内容（基于get-the-nth-item-of-a-generator-in-python）：

import itertools
def get_structure_for_node(structure, find_node=1):
    return next(itertools.islice(flat_list(structure), find_node, find_node+1))[1]

You can also modify other flatten function if the speed is really important (see making-a-flat-list-out-of-list-of-lists-in-python or making-a-flat-list-out-of-a-multi-type-nested-list).

于 2012-10-12T14:41:05.543 回答
1

你保持路径的方法会奏效。

但是，对于您的特定问题，使用生成器重写代码可能更有用（和 pythonic）。

这意味着您在运行函数时管理函数内部的索引和yield部分结果。

treewalk(node):
    for n in node.children:
        for result in treewalk(n):
            yield result
    else:
        yield node
于 2012-10-12T14:26:12.640 回答