Как распаковать кортежи во вложенном списке?

Question

У меня возникли проблемы с распаковкой двумерного списка кортежей (точнее, я ищу более элегантное решение).

Список, как показано ниже:

a = [ [(2, 3, 5), (3, 4, 6), (4, 5, 7), (1, 1, 1), (1, 2, 3)], 
     [(4, 9, 2), (8, 8, 0), (3, 5, 1), (2, 6, 8), (2, 4, 8)], 
     [(8, 7, 5), (2, 5, 1), (9, 2, 2), (4, 5, 1), (0, 1, 9)], ...] 

И я хочу, чтобы распаковать кортежи, чтобы получить 3 вложенных списков той же формы, т.е .:

a_r = [ [2, 3, 4, 1, 1] , [4, 8, 3, 2, 2] , [8, 2, 9, 4, 0] , ...] 
a_g = [ [3, 4, 5, 1, 2] , [9, 8, 5, 6, 4] , [7, 5, 2, 5, 1] , ...] 

и так далее. Вот мой код:

a_r = [] 
a_g = [] 
a_b = [] 

for i in xrange(len(a)): 
    r0=[] 
    g0=[] 
    b0=[] 
    for j in range(5): 
     r0.append(a[i][j][0]) 
     g0.append(a[i][j][1]) 
     b0.append(a[i][j][2]) 
    a_r.append(r0) 
    a_g.append(g0) 
    a_b.append(b0) 

Я уверен, что есть более эффективные способы сделать это (я только начал изучать Python). This question аналогичен, но я не смог следить за функциональным программированием.

Спасибо!

Answer 1

>>> a = [ [(2, 3, 5), (3, 4, 6), (4, 5, 7), (1, 1, 1), (1, 2, 3)], 
...  [(4, 9, 2), (8, 8, 0), (3, 5, 1), (2, 6, 8), (2, 4, 8)], 
...  [(8, 7, 5), (2, 5, 1), (9, 2, 2), (4, 5, 1), (0, 1, 9)]] 
>>> zip(*(zip(*x) for x in a)) 
[((2, 3, 4, 1, 1), (4, 8, 3, 2, 2), (8, 2, 9, 4, 0)), ((3, 4, 5, 1, 2), (9, 8, 5, 6, 4), (7, 5, 2, 5, 1)), ((5, 6, 7, 1, 3), (2, 0, 1, 8, 8), (5, 1, 2, 1, 9))] 

>>> for row in _: 
...  print row 
... 
((2, 3, 4, 1, 1), (4, 8, 3, 2, 2), (8, 2, 9, 4, 0)) 
((3, 4, 5, 1, 2), (9, 8, 5, 6, 4), (7, 5, 2, 5, 1)) 
((5, 6, 7, 1, 3), (2, 0, 1, 8, 8), (5, 1, 2, 1, 9)) 

Если он должен быть списки

>>> map(list, zip(*(map(list, zip(*x)) for x in a))) 
[[[2, 3, 4, 1, 1], [4, 8, 3, 2, 2], [8, 2, 9, 4, 0]], [[3, 4, 5, 1, 2], [9, 8, 5, 6, 4], [7, 5, 2, 5, 1]], [[5, 6, 7, 1, 3], [2, 0, 1, 8, 8], [5, 1, 2, 1, 9]]] 
>>> for row in _: 
...  print row 
... 
[[2, 3, 4, 1, 1], [4, 8, 3, 2, 2], [8, 2, 9, 4, 0]] 
[[3, 4, 5, 1, 2], [9, 8, 5, 6, 4], [7, 5, 2, 5, 1]] 
[[5, 6, 7, 1, 3], [2, 0, 1, 8, 8], [5, 1, 2, 1, 9]] 

Answer 2

Я думаю, что вы после этого что-то вроде этого:

a = [ [(2, 3, 5), (3, 4, 6), (4, 5, 7), (1, 1, 1), (1, 2, 3)], 
     [(4, 9, 2), (8, 8, 0), (3, 5, 1), (2, 6, 8), (2, 4, 8)], 
     [(8, 7, 5), (2, 5, 1), (9, 2, 2), (4, 5, 1), (0, 1, 9)]] 

for row in a: 
    print(list(zip(*row))) 

Что дает:

[(2, 3, 4, 1, 1), (3, 4, 5, 1, 2), (5, 6, 7, 1, 3)] 
[(4, 8, 3, 2, 2), (9, 8, 5, 6, 4), (2, 0, 1, 8, 8)] 
[(8, 2, 9, 4, 0), (7, 5, 2, 5, 1), (5, 1, 2, 1, 9)] 

Полученные кортежи такие же, как в вашем примере, но другой порядок. Я не понимаю, как вы их заказали. Если бы вы могли это прояснить, я мог бы изменить пример.

Надеюсь, это поможет.

Answer 3

Кортежи неизменяемы (то есть вы не можете их изменить), поэтому вам придется проходить через каждый элемент, чтобы извлечь их. Это, по сути, то, что делает пример функционального программирования, с которым вы связаны, в очень понятном понимании списка.

Чтобы помочь вам помочь, как говорит shirdharama, взгляните на пример снова и узнайте, что fmap_lol действительно означает «отображение функции - список списков», fmap_list означает «отображение функции - список», а функция fmap_el означает «функция» map-element ". Таким образом split_nt вызывает fmap_lol, который разбивает ваш вход в список списков (кортежи), вызывает fmap_list, который берет каждый список и вызывает fmap_el, который возвращает элемент в цепочку.

Пример - это просто способ пройти через кортежи, чтобы извлечь каждый элемент и поместить их туда, где хотите. Это функционально, потому что это вызовы функций, а не одна строка более позднего забытого gobbligook.

Если вы не знакомы со списками, lamda (или анонимными функциями) или что-либо еще в этом примере, я предлагаю потратить некоторое время на документацию python и посмотреть на них.