Btukfyl

I am currently stuck with the following problem (I could not find solution already on here that really fitted this):

I have three lists a = [a, b, c], b = [1, 2, 3] and c = [0.1, 0.2, 0.3].

I would like to create a lists of list of lists (maybe I should be using numpy arrays?), that contains all combinations between these lists, but where each element in each sub list are also iterated in a bruce-force like pattern, such that the following is generated:

mylist = [[[a, 1, 0.1], [b, 1, 0.1], [c, 1, 0.1]],
[[a, 1, 0.1], [b, 1, 0.1], [c, 1, 0.2]],
...
[[a, 2, 0.3], [b, 3, 0.3], [c, 1, 0.1]],
...
[[a, 1, 0.3], [b, 1, 0.3], [c, 1, 0.3]],
...
[[a, 3, 0.3], [b, 1, 0.3], [c, 3, 0.1]]
...
[[a, 3, 0.3], [b, 3, 0.3], [c, 3, 0.3]]]


I appreciate that this would equate to an extremely large list (happy to be advised on a better approach!), but I effectively need to have a three dimensional list with each sublist e.g. mylist[0], passed as list containing individual sublist parameters (e.g., [[a, 3, 0.3], [b, 3, 0.3], [c, 3, 0.3]] to an algorithm which will use them as input. This 3-D list forms effectively the entire parameter space that will need to be "searched". Thus you can see why the following combination examples:

[[a, 1, 0.3], [b, 2, 0.3], [c, 2, 0.3]],
[[a, 3, 0.1], [b, 1, 0.3], [c, 2, 0.1]]

Are important, because they serve as a unique of parameters for algorithmic input.

Really grateful for any guidance on this, thanks.

A generator seems a good approach, to avoid cluttering up the memory.

import itertools as it

bc=list(it.product(b,c)) 

#[(1, 0.1), (1, 0.2), (1, 0.3), (2, 0.1), (2, 0.2), (2, 0.3), (3, 0.1), (3, 0.2), (3, 0.3)]

res = ([[u,*v] for u,v in zip(a,bc3)] for bc3 in it.product(*[bc]*3))

you can then scan your space with :

 for list_of_list in res : 

    #compute  list_of_list

First values :

In [49]: next(res) 

Out[49]: [['a', 1, 0.1], ['b', 1, 0.1], ['c', 1, 0.1]] 

In [50]: next(res) 

Out[50]: [['a', 1, 0.1], ['b', 1, 0.1], ['c', 1, 0.2]]

You can obtain an array by arr = np.array(list(res),dtype=object) . its shape is (729,3,3).

import numpy as np 

import itertools as it

a = ['a', 'b', 'c']

b = [1, 2, 3]

c = [0.1, 0.2, 0.3]

l = np.array(np.meshgrid(a,b,c)).T

l = l.reshape(l.size//3,3)

subs = [[list(x) for x in l if x[0]==val] for val in a]

list(list(x) for x in it.product(*subs))

Try this one. It generalizes to a,b,c,d,... in an obvious way.

That said, you're going to run out of memory very quickly.