如何生成最终全覆盖且带抽取偏置的集合笛卡尔积概率分布

你需要的是权重可控、无重复、无遗漏的笛卡尔积遍历逻辑，既满足不同集合维度的抽取频次优先级，又能保证所有元素最终都被遍历到，不需要先生成全量元素再排序，下面两个方案可以直接用。 #

方案1：修改原数制映射逻辑（推荐，和你现有代码兼容性最好） #

你原来的生成逻辑本质是把递增的整数N当成混合进制数，每一位的进制对应集合的长度，通过逐位取模得到索引。这个逻辑默认按集合传入顺序决定轮转速度：排在遍历顺序前面的集合轮转慢、频次低，排在后面的轮转快、频次高，所以输出是均匀分布。
要加偏置只需要做两处修改：

1. 给每个集合分配对应权重，权重值和预期抽取频次正相关，比如要a集合频次>b>c，就给a设最大的权重值
2. 调整混合进制的位权：权重越高的集合放在越低的数位（轮转越快），同时通过虚拟索引映射保证所有真实组合都能被覆盖

可直接运行的代码如下：

class WeightedCartesianGenerator:
    def __init__(self, sets, weights):
        """
        :param sets: 输入的集合列表，例如[a,b,c]
        :param weights: 对应集合的权重，数值越大抽取频次越高，例如[3,2,1]对应a频次>b>c
        """
        self.sets = sets
        self.weights = weights
        # 按权重降序排列遍历顺序，权重越高轮转速度越快
        self.traverse_order = sorted(range(len(sets)), key=lambda x: -weights[x])
        # 预计算每个数位的位权
        self.radix_list = []
        current_radix = 1
        for set_idx in self.traverse_order:
            self.radix_list.append(current_radix)
            set_len = len(self.sets[set_idx])
            set_w = weights[set_idx]
            current_radix *= set_len * set_w
        self.total_count = current_radix
        self.current_n = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.current_n >= self.total_count:
            raise StopIteration
        result = [None] * len(self.sets)
        n = self.current_n
        for i, set_idx in enumerate(self.traverse_order):
            radix = self.radix_list[i]
            real_set_len = len(self.sets[set_idx])
            set_weight = self.weights[set_idx]
            # 取当前数位的虚拟索引
            virtual_idx = n // radix % (real_set_len * set_weight)
            # 虚拟索引映射回真实集合的索引
            real_idx = virtual_idx % real_set_len
            result[set_idx] = self.sets[set_idx][real_idx]
        self.current_n += 1
        return tuple(result)

这个方案的优势：

• 内存占用极低，不需要提前存储所有笛卡尔积元素，哪怕集合规模很大（比如总元素量到百万、千万级）也能正常运行
• 权重控制精准，不同集合的频次比严格等于设置的权重比
• 遍历完全部total_count个元素后，刚好覆盖所有笛卡尔积组合，没有重复也没有遗漏
• 如果需要避免固定顺序导致的任务阻塞，可以每遍历完一个完整周期，给每个维度的虚拟索引加随机偏移，不会破坏全覆盖的特性。

方案2：全量排序方案（适合小规模场景） #

如果你的笛卡尔积总元素量不大（比如10万以内），可以用你提到的排序思路，实现更简单：

• 先生成所有笛卡尔积元素
• 给每个元素计算优先级得分：score = sum(维度索引 * 对应维度权重)，权重越高的维度乘的系数越大
• 按score排序后按顺序遍历即可

这个方案逻辑简单，但是总元素量大了之后内存和初始化耗时会很高，不适合大规模任务调度场景。 #

内容的提问来源于stack exchange，提问作者Samuel Squire