Использовать список вложенных индексов для доступа к элементу списка

Как список индексов (называемый «indlst»), например [[1,0], [3,1,2]], который соответствует элементам [1] [0] и [3] [1] [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] имеет три и так далее. (соответственно изменились примеры).

3 Solutions collect form web for “Использовать список вложенных индексов для доступа к элементу списка”

Вы можете просто перебирать и собирать значение.

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

Вы можете сформировать список с функциями. Освободить и перечислить понимание .

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

NB это решение python3. Для python2 вы можете просто игнорировать оператор импорта.

вы можете попробовать этот блок кода:

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

Recursion может захватывать произвольные / глубоко индексированные элементы из вложенных списков:

 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 ()
Затем непосредственно жестко кодируйте индексы вложенного списка, который игнорирует любые «лишние» жестко кодированные индексы с нулевой оценкой

ниже жестко закодированной 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'] 
Interesting Posts
Python - лучший язык программирования в мире.