结合两个列表和 output 列表 1 给定列表 2 的所有可能组合

Question

I have two lists in python.

list1 = ['A', 'B']
list2 = [True, False]

list1 has been simplified in the real world it will be more than 2 elements. list 2 will only be true or false.

I'd like to generate the following output, given 2 elements in list1:

output=[
    [['A', True], ['B', True]],
    [['A', False], ['B', True]],
    [['A', True], ['B', False]],
    [['A', False], ['B', False]]]

I'd like the algorithm to be able to support the scenario with more than 2 elements in list1.

Here is an example with 3 elements in list1:

list1 = ['A', 'B', 'C']
list2 = [True, False]

output=[
    [['A', True], ['B', True], ['C', True]],
    [['A', True], ['B', True], ['C', False]],
    [['A', True], ['B', False], ['C', True]],
    [['A', False], ['B', True], ['C', True]],
    [['A', False, ['B', False], ['C', True]],
    [['A', True], ['B', False, ['C', False]],
    [['A', False], ['B', True], ['C', False]],
    [['A', False], ['B', False], ['C', False]]
    ]

The following gets me close but not quite there.

[zip(x, list2) for x in it.permutations(list1, len(list2))]

I know I need to do something using itertools but cannot wrap my head around it. Any advice would be greatly appreciated.

Answer 1

from pprint import pprint
import itertools

list1 = ['A', 'B']
list2 = [True, False]

newdict = {}
final_list = []
for element in itertools.product(list1,list2):
    if element[0] not in newdict.keys():
        newdict[element[0]] = []
    newdict[element[0]].append(list(element))
values =  (list(newdict.values()))


for x in itertools.product('01', repeat=len(values)):
    tmp_list = []
    for i,index in enumerate(list(x)):
        tmp_list.append(values[int(i)][int(index)])
    final_list.append(tmp_list)

pprint (final_list)

OUTPUT:

[[['A', True], ['B', True]],
 [['A', True], ['B', False]],
 [['A', False], ['B', True]],
 [['A', False], ['B', False]]]

OUTPUT WITH A,B,C:

[[['A', True], ['B', True], ['C', True]],
 [['A', True], ['B', True], ['C', False]],
 [['A', True], ['B', False], ['C', True]],
 [['A', True], ['B', False], ['C', False]],
 [['A', False], ['B', True], ['C', True]],
 [['A', False], ['B', True], ['C', False]],
 [['A', False], ['B', False], ['C', True]],
 [['A', False], ['B', False], ['C', False]]]

Initially I take the cartesian product, but I separate each key (A,B, or C) into its own list. That yields:

[[['A', True], ['A', False]],
 [['B', True], ['B', False]],
 [['C', True], ['C', False]]]

From there we are just counting in binary to index into those list. eg

000 = A,True B,True C,True
001 = A,True B,True C,False
...
111 = A,False B,False C,False

Answer 2

You are nearly there with your list comprehension. You just need to use product instead of permutations , since you want to repeat the same values from list2 . Try this:

output = [list(zip(list1, x)) for x in itertools.product(list2, repeat=len(list1))]

This creates a list of lists of 2-tuples. If you need the innermost elements to be lists too, you can use list(map(list, zip(...))) .

Answer 3

I think this would work

import itertools
list1=['A','B']
list2 = [True, False]

output=[]
for a,b in itertools.product(list1,list2):
    temp=[]
    temp.append(a)
    temp.append(b)
    output.append(temp)

print(output)

It is basically permuting everything in list1 with list2