объединить 2 списка списка в список кортежей

Question

Я пытаюсь объединить разные вложенные списки в список кортежей (x, y) где x берется из первого вложенного списка, а y из второго вложенного списка.

nested_list1 = [[1, 2, 3],[3],[0, 3],[1]]
nested_list2 = [[.0833, .0833, .0833], [.2], [.175, .175], [.2]]

при объединении их должно быть:

result = [(1,.0833), (2,.0833), (3,.0833), (3,.2), (0,.175), (3,.175), (1,.2)]

Мой подход заключается в том, что мне нужно перебирать список списков и объединять их по одному за раз. Я знаю, чтобы перебрать 1 вложенный список так:

for list in nested_list1:
    for number in list:
        print(number)

но я не могу перебрать 2 вложенных списка одновременно.

for list, list in zip(nested_list1, nested_list2):
    for number, prob in zip(list,list):
        print(tuple(number, prob)) #will not work

есть идеи?

Answer 1

Используйте два раза zip и сгладьте список

from functools import reduce
reduce(lambda x,y: x+y,[(zip(i,j)) for i,j in zip(nested_list1,nested_list2)])

Вы можете выровнять, используя chain, а также

from itertools import chain
list(chain(*[(zip(i,j)) for i,j in zip(nested_list1,nested_list2)]))

выход

[(1, 0.0833), (2, 0.0833), (3, 0.0833), (3, 0.2), (0, 0.175), (3, 0.175), (1, 0.2)]

Answer 2

Этот лайнер достигнет того, что вы хотите.

reduce(lambda x, y: x+y, [[(i, j) for i, j in zip(x,y)] for x, y in zip(nested_list1, nested_list2)])

Answer 3

Один из способов - преобразовать оба вложенных списка в полные списки, а затем использовать zip. Пример кода ниже:

>>> nested_list1 = [[1, 2, 3],[3],[0, 3],[1]]
>>> nested_list2 = [[.0833, .0833, .0833], [.2], [.175, .175], [.2]]
>>> new_list1 = [x for val in nested_list1 for x in val]
>>> new_list2 = [x for val in nested_list2 for x in val]
>>> print new_list1
[1, 2, 3, 3, 0, 3, 1]
>>> print new_list2
[0.0833, 0.0833, 0.0833, 0.2, 0.175, 0.175, 0.2]
>>> new_val = zip(new_list1, new_list2)
>>> print new_val
[(1, 0.0833), (2, 0.0833), (3, 0.0833), (3, 0.2), (0, 0.175), (3, 0.175), (1, 0.2)]

Answer 4

В вашем коде 2 ошибки:

1. Вы дублируете встроенную list дважды и таким образом, что не можете различить две переменные. Не делай этого.
2. Вы используете tuple(x, y) для создания tuple формы 2 переменных. Это неверно, поскольку tuple принимает только один аргумент. Чтобы создать кортеж из двух переменных, просто используйте синтаксис (x, y).

Так что это будет работать:

for L1, L2 in zip(nested_list1, nested_list2):
    for number, prob in zip(L1, L2):
        print((number, prob))

Более идиоматично было бы сгладить ваши вложенные списки; например, через itertools.chain:

from itertools import chain

res = list(zip(chain.from_iterable(nested_list1),
               chain.from_iterable(nested_list2)))

[(1, 0.0833), (2, 0.0833), (3, 0.0833), (3, 0.2), (0, 0.175), (3, 0.175), (1, 0.2)]

Answer 5

result = []
[result.extend(list(zip(x, y))) for x in nested_list1 for y in nested_list2]
print(result)

Answer 6

Использование itertools.chain:

>>> nested_list1 = [[1, 2, 3],[3],[0, 3],[1]]
>>> nested_list2 = [[.0833, .0833, .0833], [.2], [.175, .175], [.2]]
>>> import itertools
>>> res = list(zip(itertools.chain.from_iterable(nested_list1), itertools.chain.from_iterable(nested_list2)))
>>> res
[(1, 0.0833), (2, 0.0833), (3, 0.0833), (3, 0.2), (0, 0.175), (3, 0.175), (1, 0.2)]

Answer 7

Вы можете сделать двойной zip через списки:

lst1 = [[1, 2, 3],[3],[0, 3],[1]]
lst2 = [[.0833, .0833, .0833], [.2], [.175, .175], [.2]]

print([(u, v) for x, y in zip(lst1, lst2) for u, v in zip(x, y)])

Или используйте itertools.chain.from_iterable, чтобы сгладить список и zip:

from itertools import chain

lst1 = [[1, 2, 3],[3],[0, 3],[1]]
lst2 = [[.0833, .0833, .0833], [.2], [.175, .175], [.2]]

print(list(zip(chain.from_iterable(lst1), chain.from_iterable(lst2))))

Answer 8

Сведите свои списки и затем перейдите к zip():

list1 = [item for sublist in nested_list1 for item in sublist]
list2 = [item for sublist in nested_list2 for item in sublist]
final = list(zip(list1, list2))

Урожайность:

[(1, 0.0833), (2, 0.0833), (3, 0.0833), (3, 0.2), (0, 0.175), (3, 0.175), (1, 0.2)]