Python 列表上所有可能的数字组合

我需要找到定义长度的列表和定义大小的数字的所有可能组合，但受限于不允许列表中有相同重复数字的限制（0除外）。 目前，我有一个递归代码生成所有的组合，但当试图创建约束时，我失去了许多选项。 我已经尝试了一些选项来解决这个问题，但它仍然不适合我。提前感谢您的帮助

size=3
l=[0 for x in range(size)]

def recursive(l, index, num, final):
    if index == len(l) or num == final:
        return
#     if num!=0 and num in l:
#         return
    l[index]=num
    print(l)
    recursive(l, index+1, 0, final)
    recursive(l, index, num+1, final)
recursive(l, 0, 0, 4)

大小为3且最终编号为3的列表的预期输出如下所示

[0, 0, 0]
[0, 0, 1]
[0, 0, 2]
[0, 0, 3]
[0, 1, 0]
[0, 1, 2]
[0, 1, 3]
[0, 2, 0]
[0, 2, 1]
[0, 2, 3]
[0, 3, 0]
[0, 3, 1]
[0, 3, 2]
[1, 0, 0]
[1, 0, 2]
[1, 0, 3]
[1, 2, 0]
[1, 2, 3]
[1, 3, 0]
[1, 3, 2]
[2, 0, 0]
[2, 0, 1]
[2, 0, 3]
[2, 1, 0]
[2, 1, 3]
[2, 3, 0]
[2, 3, 1]
[3, 0, 0]
[3, 0, 1]
[3, 0, 2]
[3, 1, 0]
[3, 1, 2]
[3, 2, 0]
[3, 2, 1]

---

从非零值的功率集开始（可在

itertools

文档中找到用于计算列表功率集的函数。）

（您可以计算包含0的幂集，但仍然需要对较短的元素进行零填充，并丢弃

（0,1,2,3）

）

接下来，应使用零填充动力集的每个元素，以便它们都具有相同的长度

---

最后，您需要原始输入的每个0填充置换的置换列表（使用

itertools.permutations

）。

从非零值的幂集开始（计算列表幂集的函数可在

itertools

文档中找到）

（您可以计算包含0的幂集，但仍然需要对较短的元素进行零填充，并丢弃

（0,1,2,3）

）

接下来，应使用零填充动力集的每个元素，以便它们都具有相同的长度

---

最后，您需要原始输入的每个0填充置换的置换列表（使用

itertools.permutations

）。

使用

itertools.compositions\u with_replacement（）

，然后过滤掉重复的元素

def has_duplicates(l):
    '''Return True if list has duplicate elements other than 0'''
    l = [x in l if x != 0]
    return len(l) != len(set(l))

result = [comb for comb in itertools.combinations_with_replacement(l, 3) if not has_duplicates(comb)]

您可以使用

itertools.filterfalse（）

使其变为惰性；这样，您就不会用一个大列表的所有组合来填充内存

result = itertools.filterfalse(has_duplicates, itertools.combinations_with_replacement(l, 3))

---

使用

itertools.compositions\u和\u replacement（）

，然后过滤掉重复的元素

def has_duplicates(l):
    '''Return True if list has duplicate elements other than 0'''
    l = [x in l if x != 0]
    return len(l) != len(set(l))

result = [comb for comb in itertools.combinations_with_replacement(l, 3) if not has_duplicates(comb)]

您可以使用

itertools.filterfalse（）

使其变为惰性；这样，您就不会用一个大列表的所有组合来填充内存

result = itertools.filterfalse(has_duplicates, itertools.combinations_with_replacement(l, 3))

---

这是一个基于计数器的解决方案，我使用的是base 4计数器：

def charcnt（s，a）：
ctr=[1如果x==a，则s中的x为0]
回报总额（ctr）
def my_范围（开始、结束、基本、步骤=1）：
def转换（n，基本）：
string=“0123”
如果n1或charcnt（s，'2'）>1或charcnt（s，'3'）>1：
持续
其他：
结果。追加
结果=[[int（n）表示列表中的n]s表示结果中的s]
#打印（len（结果））
就我而言，结果是：
印刷品（一）

将产生：

[0,0,0]
[0, 0, 1]
[0, 0, 2]
[0, 0, 3]
[0, 1, 0]
[0, 1, 2]
[0, 1, 3]
[0, 2, 0]
[0, 2, 1]
[0, 2, 3]
[0, 3, 0]
[0, 3, 1]
[0, 3, 2]
[1, 0, 0]
[1, 0, 2]
[1, 0, 3]
[1, 2, 0]
[1, 2, 3]
[1, 3, 0]
[1, 3, 2]
[2, 0, 0]
[2, 0, 1]
[2, 0, 3]
[2, 1, 0]
[2, 1, 3]
[2, 3, 0]
[2, 3, 1]
[3, 0, 0]
[3, 0, 1]
[3, 0, 2]
[3, 1, 0]
[3, 1, 2]
[3, 2, 0]
[3, 2, 1]

这是一个基于计数器的解决方案，我使用的是基本4计数器：

def charcnt（s，a）：
ctr=[1如果x==a，则s中的x为0]
回报总额（ctr）
def my_范围（开始、结束、基本、步骤=1）：
def转换（n，基本）：
string=“0123”
如果n1或charcnt（s，'2'）>1或charcnt（s，'3'）>1：
持续
其他：
结果。追加
结果=[[int（n）表示列表中的n]s表示结果中的s]
#打印（len（结果））
就我而言，结果是：
印刷品（一）

将产生：

[0,0,0]
[0, 0, 1]
[0, 0, 2]
[0, 0, 3]
[0, 1, 0]
[0, 1, 2]
[0, 1, 3]
[0, 2, 0]
[0, 2, 1]
[0, 2, 3]
[0, 3, 0]
[0, 3, 1]
[0, 3, 2]
[1, 0, 0]
[1, 0, 2]
[1, 0, 3]
[1, 2, 0]
[1, 2, 3]
[1, 3, 0]
[1, 3, 2]
[2, 0, 0]
[2, 0, 1]
[2, 0, 3]
[2, 1, 0]
[2, 1, 3]
[2, 3, 0]
[2, 3, 1]
[3, 0, 0]
[3, 0, 1]
[3, 0, 2]
[3, 1, 0]
[3, 1, 2]
[3, 2, 0]
[3, 2, 1]
尝试，但是ItRealToT不考虑顺序[1,2,3]＝[3，2,1]，但在我的情况下，这不是一个有用的技巧，而是要考虑的是，您可以使用“<代码> k < /COD>元素>list@GuillermoMeza：
itertools
是整个模块；其中一些是顺序不敏感的（
组合
，
带替换的组合
），一些不是（
置换
，
产品
）。整个<代码>迭代器模块充满了令人惊讶的有用的实用程序，如果你认为“它不考虑订单”，你就不会仔细查看。我试过了，但是TyrToice不考虑顺序[1,2,3]＝[3，2,1]，但在我的情况下，这不是一个有用的技巧，而是要考虑的是，您可以使用“<代码> k < /COD>元素>list@GuillermoMeza：
itertools
是整个模块；其中一些是顺序不敏感的（
组合
，
带替换的组合
），一些不是（
置换
，
产品
）。整个<代码>迭代器模块充满了令人惊讶的有用的实用程序，如果你认为“它不考虑订单”，你就看得不够仔细。你如何得到所有不同的PADD？