Python 循环搜索数组中所有可能的组合

我在python的算法方面遇到了问题。 我有一个由4个值组成的数组[a，b，c，d]，它们是百分比，所以在任何给定的时间a+b+c+d=1。我需要一个循环，以0.1的步长遍历这些数字的所有可能组合。例如：

[0,0,0,1]
[0,0,0.1,0.9]
[0,0.1,0.1,0.8]
[0.1,0.1,0.1,0.7]
.....
[0.1,0.1,0.2,0.6]
[0.1,0.1,0.3,0.5]
....
[1,0,0,0]

我创建了一个似乎溢出的代码。。。有什么帮助吗？泰，我知道这是一个很难回答的问题

def frange(start, stop, step):
    while start <= stop:
        yield start
        start += step

def distribuir(p,array):
    if len(array) == 3:
        array.append(p)
        print(Array)
        return
    for i in frange(0,1,0.1):
        temp = []
        temp.append(array)
        temp.append(i)
        distribuir(p-i,temp)

def法兰（启动、停止、步骤）：
而start则是一个简单的递归解决方案，有很大的优化空间：

import itertools

def possibilities(prefix, size, values, total):                                                                                                                                               
    if size == 0:
        return [prefix] if sum(prefix) == total else []
    return itertools.chain(*map(
        lambda v: possibilities(prefix+[v], size-1, values, total),
        values
    ))

例如：

list(
    map(
        lambda t: map(float, t),
        possibilities(
            prefix=[],
            size=3,
            values=map(Decimal, ['0', '0.1', '0.2', '0.3']),
            total=Decimal('0.4')
        )
    )
)                                                                            

输出：

[[0.0, 0.1, 0.3],
 [0.0, 0.2, 0.2],
 [0.0, 0.3, 0.1],
 [0.1, 0.0, 0.3],
 [0.1, 0.1, 0.2],
 [0.1, 0.2, 0.1],
 [0.1, 0.3, 0.0],
 [0.2, 0.0, 0.2],
 [0.2, 0.1, 0.1],
 [0.2, 0.2, 0.0],
 [0.3, 0.0, 0.1],
 [0.3, 0.1, 0.0]]

那么，你试过什么？如果不知道如何从<代码> 0代码/代码>通过<代码> 1代码> >代码大小> 0.1 < /代码>的步骤大小，考虑如果您执行<代码>范围（10）< /代码>会发生什么，并将每个值乘以<代码> 0.1 < /代码>。一旦你有了它，你应该知道如何写下下下一个循环（提示：如果第一个值是
0.4
，那么下一个值只需要从
0.0
循环到
0.6
），下一个，下一个。如果你在某个地方卡住了，你可以把你的代码和卡住的地方贴出来。@abarnert：这是Python中分区的一个实现。唯一的区别是按0.1进行缩放。@GregHewgill:但这个问题适用于所有长度为4的分区，而不仅仅是长度为4的分区，并且没有
0
s，并且将
1,1,7
和
7,1,1,1
视为同一个分区，所有这些分区都不同于此处所需的输出。您知道，有时候，如果你得到了90%的解决方案，那么你自己多做10%可能是值得的。无论如何，我会打开这个，你可以把它整理出来。@GregHewgill:当然，但我认为OP不太可能知道如何将该算法转化为一个处理置换的算法（除了可能通过获取每个值的所有置换，然后过滤它们，这不是一个很好的解决方案）。