Question

我目前遇到以下问题（在这里我找不到真正适合此情况的解决方案）：

我有三个列表a = [a, b, c]，b = [1, 2, 3]和c = [0.1, 0.2, 0.3]。

我想创建一个列表列表的列表（也许我应该使用numpy数组？），其中包含这些列表之间的所有组合，但是每个子列表中的每个元素也要像布鲁斯力一样进行迭代模式，从而生成以下内容：

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

我很欣赏这相当于一个很大的列表（很高兴在更好的方法上得到建议！），但是我实际上需要为每个子列表提供一个三维列表，例如mylist [0]作为包含单个子列表参数（例如[[a，3、0.3]，[b，3、0.3]，[c，3、0.3]]的列表）传递给将使用它们作为输入的算法。该3-D列表有效地形成了需要“搜索”的整个参数空间，因此您可以了解为什么以下组合示例：

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

这很重要，因为它们是算法输入的唯一参数。

非常感谢您对此提供的指导。

Answer 1

生成器似乎是一种很好的方法，可以避免使内存混乱。

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

然后您可以使用：

扫描您的空间

 for list_of_list in res : 
    #compute  list_of_list

第一个值：

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

您可以通过arr = np.array(list(res),dtype=object)获得一个数组。它的形状是（729,3,3）。

Answer 2

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

尝试这个。它以一种显而易见的方式概括为a,b,c,d,...。

也就是说，您将很快耗尽内存。

创建具有3个级别的列表，其中包含子列表值的每种组合

2 个答案: