Question

如何对应于元素[1] [0]和[3] [1]的索引列表（称为“indlst”），如[[1,0]，[3,1,2]] [2]给定列表（称为“lst”），用于访问各自的元素？例如，给定

    indlst = [[1,0], [3,1,2]]
    lst = ["a", ["b","c"], "d", ["e", ["f", "g", "h"]]]
    (required output) = [lst[1][0],lst[3][1][2]]

输出应对应于[“b”，“h”]。我不知道从哪里开始，更不用说找到一种有效的方法（因为我认为解析字符串不是最常用的pythonic方法）。

EDIT:我应该提到索引的嵌套级别是可变的，因此虽然[1,0]中有两个元素，但[3,1,2]有三个，依此类推。（例子相应地改变了。）

Answer 1

您可以迭代并收集价值。

>>> for i,j in indlst:
...     print(lst[i][j])
... 
b
f

或者，您可以使用简单的列表理解从这些值中形成列表。

>>> [lst[i][j] for i,j in indlst]
['b', 'f']

编辑：

对于可变长度，您可以执行以下操作：

>>> for i in indlst:
...     temp = lst
...     for j in i:
...         temp = temp[j]
...     print(temp)
... 
b
h

您可以使用 functions.reduce 和列表理解形成一个列表。

>>> from functools import reduce
>>> [reduce(lambda temp, x: temp[x], i,lst) for i in indlst]
['b', 'h']

N.B。这是一个python3解决方案。对于python2，您可以忽略import语句。

Answer 2

你可以尝试这个代码块：

required_output = []
for i,j in indlst:
    required_output.append(lst[i][j])

Answer 3

递归可以从嵌套列表中获取任意/深度索引的项目：

indlst = [[1,0], [3,1,2]]
lst = ["a", ["b","c"], "d", ["e", ["f", "g", "h"]]]
#(required output) = [lst[1][0],lst[3][1][2]]


def nested_lookup(nlst, idexs):
    if len(idexs) == 1:
        return nlst[idexs[0]]
    return nested_lookup(nlst[idexs[0]], idexs[1::])

reqout = [nested_lookup(lst, i) for i in indlst]
print(reqout) 

dindx = [[2], [3, 0], [0], [2], [3, 1, 2], [3, 0], [0], [2]]    
reqout = [nested_lookup(lst, i) for i in dindx]
print(reqout)
['b', 'h']
['d', 'e', 'a', 'd', 'h', 'e', 'a', 'd']

我还发现任意额外零指数都很好：

    lst[1][0][0]
    Out[36]: 'b'

    lst[3][1][2]
    Out[37]: 'h'

    lst[3][1][2][0][0]
    Out[38]: 'h'

因此，如果您确实知道最大嵌套深度，则可以通过使用.update（）dictonary方法将您的（可变数量，较短）索引列表值覆盖到使用零填充的最大固定长度字典来填充索引列表值<登记/> 然后直接硬编码嵌套列表的索引，忽略任何“额外”硬编码零值索引

低于硬编码4深度：

def fix_depth_nested_lookup(nlst, idexs):
    reqout = []
    for i in idexs:
        ind = dict.fromkeys(range(4), 0)
        ind.update(dict(enumerate(i)))
        reqout.append(nlst[ind[0]][ind[1]][ind[2]][ind[3]])
    return reqout

print(fix_depth_nested_lookup(lst, indlst))
['b', 'h']

使用嵌套索引列表来访问列表元素

3 个答案: