python - 链接列表的多个索引操作的最快方法？

Question

我想对我拥有的一些数据进行分类，为了使它工作，我想对 python 列表进行链式索引。简化我有一个嵌套列表:

lst = [[[1], [2]], [[3, 3], [4]], [[5], [6,6,6]]]

我想迭代前两个索引的乘积，但保持第三个相同:

from itertools import product

for index1, index2 in product(range(3), range(2)):
    print(lst[index1][index2][0])

但是我想在事先不知道需要深入多少子结构的情况下使它更通用(我想使 range 的数量传递给 itertools.product变量)。

我正在努力如何概括 [index1][index2][0] 以接受任意数量的 indices，我能做到的最好up with functools.reduce:

from functools import reduce

for indices in product(range(3), range(2)):
    print(reduce(list.__getitem__, indices, lst)[0])

这看起来非常复杂(而且比手动索引要慢得多)，所以我想知道是否有更好更快的方法来做到这一点。我同时使用 python 2.x 和 3.x，外部库绝对没问题(但它不需要 NumPy 或基于 NumPy 的包)。

Answer 1

我提出了一种递归的方式。

def theshape(lst):
    l=lst
    shape=[]
    while isinstance(l,list):
                shape.append(len(l))
                l=l[0]
    return shape

此函数旨在找到您的结构的形状，在最后一个维度之前它应该是规则的。

def browse(lst):
    shape=theshape(lst)
    ndim=len(shape)
    def level(l,k):
        if k==ndim:
            print(l)
        else:
            for i in range(shape[k]):
                level(l[i],k+1)
    level(lst,0)

这个递归浏览所有级别。它最小化指针变化。

一个简单的例子:

u=arange(2**6).reshape(4,2,1,2,2,1,1,2).tolist()
browse(u)
0
2
.
.
.
62

对大结构的一些测试(打印被 print = lambda _ : None 丢弃):

def go(lst):
 for x in product(*[range(k) for k in theshape(lst)]):
    print(reduce(lambda result, index: result[index], x, lst))

In [1]: u=arange(2**21).reshape([2]*21).tolist()

In [2]: %time go(u)
Wall time: 14.8 s

In [3]: %time browse(u)
Wall time: 3.5 s

In [5]: u=arange(2**21).reshape([1]*30+[2**21]+[1]).tolist()

In [6]: %time go(u)
Wall time: 18 s

In [7]: %time browse(u)
Wall time: 3.48 s

In [8]: u=arange(2**21).reshape([1]+[2**21]+[1]*30).tolist()

In [9]: %time go(u)
Wall time: 14 s

In [10]: %time browse(u)
Wall time: 58.1 s

这表明性能非常依赖于数据结构。

编辑:

最后，最简单的就是最快的。 theshape 不是必需的。

def browse2(lst):
        if isinstance(lst,list):
            for l in lst:
                browse2(l)
        else: print(lst)

它通常比浏览快 30%。无论列表的结构如何，它都有效。