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的任意数字，我能想到的最好的是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

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

修改

最后，最简单的是最快的。 <{1}}没有必要。

theshape

它通常比浏览快30％。它适用于列表的任何结构。

Answer 2

我会使用python-builtin reduce来实现这一点，它似乎并不复杂，而且在我的测试中并没有那么慢：

from itertools import product

for x in product(range(3), range(2)):
    rg = reduce(lambda result, index: result[index], x, lst)
    value = rg[0]

如果您担心来自reduce的时间损失，则可以改为使用for循环：

for x in product(range(3), range(2)):
    value = lst
    for index in x:
        value = value[index]
    value = value[0]

在所有情况下，这将比手动索引慢，因为for循环将需要额外的操作来确定停止条件。一如既往的问题是速度优化对于任意深度规范的灵活性是否值得。

至于您使用reduce与for的原因，JavaScript社区内存在持续的风格争论，即您是否应该使用reduce，map ，filter在Array上运行，或者执行for循环版本，因为它更快，你可能想参考那个辩论来选择你选择哪一方。

使用for循环进行计时：

In [22]: stmt = '''
    ...: from itertools import product
    ...: def go():
    ...:   lst = [[[1], [2]], [[3, 3], [4]], [[5], [6,6,6]]]
    ...:   for x in product(range(3), range(2)):
    ...:     # rg = reduce(lambda result, index: result[index], x, lst)
    ...:     value = lst
    ...:     for index in x:
    ...:         value = value[index]
    ...:     value = value[0]
    ...:     # value = lst[x[0]][x[1]][0]
    ...: '''

In [23]: timeit(setup=stmt, stmt='go()', number=1000000)
Out[23]: 4.003296852111816

reduce的时间安排：

In [18]: stmt = '''
    ...: from itertools import product
    ...: def go():
    ...:   lst = [[[1], [2]], [[3, 3], [4]], [[5], [6,6,6]]]
    ...:   for x in product(range(3), range(2)):
    ...:     rg = reduce(lambda result, index: result[index], x, lst)
    ...:     value = rg[0]
    ...:     # value = lst[x[0]][x[1]][0]
    ...: '''

In [19]: timeit(setup=stmt, stmt='go()', number=1000000)
Out[19]: 6.164631128311157

使用手动索引进行计时：

In [16]: stmt = '''
    ...: from itertools import product
    ...: def go():
    ...:   lst = [[[1], [2]], [[3, 3], [4]], [[5], [6,6,6]]]
    ...:   for x in product(range(3), range(2)):
    ...:     # rg = reduce(lambda result, index: result[index], x, lst)
    ...:     value = lst[x[0]][x[1]][0]
    ...: '''

In [17]: timeit(setup=stmt, stmt='go()', number=1000000)
Out[17]: 3.633723020553589

Answer 3

如何动态创建硬索引？

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])


# need depth info from somewhere to create hard coded indexing

prod_gen = product(range(3), range(2))

first = next(prod_gen)

indx_depth = len(first) + 1

exec( ('def IndexThisList(lst, indxl):\n' +
       '        return lst' + ''.join(('[indxl[' + str(i) + ']]' 
                                           for i in range(indx_depth)))))

# just to see what it exec'd:
print(("def IndexThisList(lst, indx_itrbl):\n" +
       "        return lst" + ''.join(('[indx_itrbl[' + str(i) + ']]' 
                                       for i in range(indx_depth)))))
# the exec is only invoked again when changing the indexing depth
# for accessing the list with its currently instantiated depth of indexing
# just use the current instance of the generated function

print(IndexThisList(lst, first + (0,)))
for itpl in prod_gen: 
    print (IndexThisList(lst, itpl + (0,)))

1
2
3
4
5
6
def IndexThisList(lst, indx_itrbl):
        return lst[indx_itrbl[0]][indx_itrbl[1]][indx_itrbl[2]]
1
2
3
4
5
6

只是一个初学者，看起来我的exec应该用另一个函数包装来传递index_depth，但它现在暂时不知道

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

3 个答案: