以不同的顺序生成 itertools.product

Question

我有一些排序/评分的参数列表。我想生成可能的参数组合（笛卡尔积）。但是，如果参数的数量很大，这个很快（很快！！）就会变成一个很大的数字。基本上，我想做一个笛卡尔积，但要尽早停止。

import itertools
parameter_options = ['1234',
                     '123',
                     '1234']
for parameter_set in itertools.product(*parameter_options):
    print ''.join(parameter_set)

生成：

111
112
113
114
121
122
123
124
131
132
133
134
...

我想生成（或类似的东西）：

111
112
121
211
122
212
221
222
...

因此，如果我提前停止，我至少会得到几组“好”的参数，其中一组好的参数大多来自列表的早期。这个特定的顺序很好，但我对任何改变“下一个排列”选择顺序的技术感兴趣。我希望生成的早期结果中的大多数项目都位于列表的前面，但并不真正关心解决方案是先生成 113 还是 122，还是先生成 211 或 112。

我的计划是在生成一些排列后停止（可能是 10K 左右？取决于结果）。因此，如果少于截止值，则最终都应该生成。并且最好每个只生成一次。

Answer 1

如果您根据输出空间的图遍历来考虑输出，我认为您可以按照您想要的顺序获得结果。您需要最近优先遍历，而 itertools.product 函数是深度优先遍历。

试试这样的：

import heapq

def nearest_first_product(*sequences):
    start = (0,)*len(sequences)
    queue = [(0, start)]
    seen = set([start])
    while queue:
        priority, indexes = heapq.heappop(queue)
        yield tuple(seq[index] for seq, index in zip(sequences, indexes))
        for i in range(len(sequences)):
            if indexes[i] < len(sequences[i]) - 1:
                lst = list(indexes)
                lst[i] += 1
                new_indexes = tuple(lst)
                if new_indexes not in seen:
                    new_priority = sum(index * index for index in new_indexes)
                    heapq.heappush(queue, (new_priority, new_indexes))
                    seen.add(new_indexes)

示例输出：

for tup in nearest_first_product(range(1, 5), range(1, 4), range(1, 5)):
    print(tup)

(1, 1, 1)
(1, 1, 2)
(1, 2, 1)
(2, 1, 1)
(1, 2, 2)
(2, 1, 2)
(2, 2, 1)
(2, 2, 2)
(1, 1, 3)
(1, 3, 1)
(3, 1, 1)
(1, 2, 3)
(1, 3, 2)
(2, 1, 3)
(2, 3, 1)
(3, 1, 2)
(3, 2, 1)
(2, 2, 3)
(2, 3, 2)
(3, 2, 2)
(1, 3, 3)
(3, 1, 3)
(3, 3, 1)
(1, 1, 4)
(2, 3, 3)
(3, 2, 3)
(3, 3, 2)
(4, 1, 1)
(1, 2, 4)
(2, 1, 4)
(4, 1, 2)
(4, 2, 1)
(2, 2, 4)
(4, 2, 2)
(3, 3, 3)
(1, 3, 4)
(3, 1, 4)
(4, 1, 3)
(4, 3, 1)
(2, 3, 4)
(3, 2, 4)
(4, 2, 3)
(4, 3, 2)
(3, 3, 4)
(4, 3, 3)
(4, 1, 4)
(4, 2, 4)
(4, 3, 4)

通过更改代码中new_priority 的计算，您可以获得一堆略有不同的订单。当前版本使用平方笛卡尔距离作为优先级，但如果您愿意，您可以使用其他值（例如，合并来自序列的值，而不仅仅是索引）。

如果您不太关心(1, 1, 3) 是否在(1, 2, 2) 之前（只要它们都在(1, 1, 2)、(1, 2, 1) 和(2, 1, 1) 之后），您可能会做广度优先遍历而不是最近优先。这会更简单一些，因为您可以使用常规队列（如collections.deque）而不是优先级队列。

这种图遍历使用的队列意味着这段代码使用了一些内存。但是，与在将结果整理之前必须预先生成所有结果相比，内存量要少得多。使用的最大内存与结果空间的表面积成正比，而不是其体积。

Answer 2

您的问题有点模棱两可，但是阅读您的 cmets 和其他答案后，您似乎想要一个笛卡尔积实现来进行广度搜索而不是深度搜索。

最近我有你同样的需求，但也有要求它不会将中间结果存储在内存中。这对我来说非常重要，因为我正在使用大量参数（因此是一个非常大的笛卡尔积），并且任何存储值或进行递归调用的实现都是不可行的。正如您在问题中所说，这似乎也是您的情况。

由于我没有找到满足这个要求的答案，我来到了这个解决方案：

def product(*sequences):
    '''Breadth First Search Cartesian Product'''
    # sequences = tuple(tuple(seq) for seqin sequences)

    def partitions(n, k):
        for c in combinations(range(n+k-1), k-1):
            yield (b-a-1 for a, b in zip((-1,)+c, c+(n+k-1,)))

    max_position = [len(i)-1 for i in sequences]
    for i in range(sum(max_position)):
        for positions in partitions(i, len(sequences)):
            try:
                yield tuple(map(lambda seq, pos: seq[pos], sequences, positions))
            except IndexError:
                continue
    yield tuple(map(lambda seq, pos: seq[pos], sequences, max_position))

在速度方面，这个生成器在开始时运行良好，但在最新结果中开始变慢。所以，虽然这个实现有点慢，但它作为一个不使用内存并且不给出重复值的生成器工作。

正如我在@Blckknght 答案中提到的，这里的参数也必须是序列（可下标和长度定义的迭代）。但是你也可以通过取消第一行的注释来绕过这个限制（牺牲一点内存）。如果您使用生成器/迭代器作为参数，这可能会很有用。

希望我对您有所帮助，如果这对您的问题有帮助，请告诉我。

Answer 3

这个解决方案可能不是最好的，因为它会短暂地将每个组合强制到内存中，但它确实有效。大型数据集可能需要一点时间。

import itertools
import random
count = 100  # the (maximum) amount of results
results = random.sample(list(itertools.product(*parameter_options)), count)

for parameter_set in results:
    print "".join(parameter_set)

这将为您提供随机顺序的产品列表。