如何获得列表元素的所有可能组合?


422

我有一个包含15个数字的列表,我需要编写一些代码来生成这些数字的所有32,768个组合。

我已经找到了一些代码(通过Googling),这些代码显然可以满足我的需求,但是我发现代码相当不透明并且对使用它很谨慎。另外,我觉得必须有一个更优雅的解决方案。

对我而言,唯一发生的就是循环遍历十进制整数1–32768,并将其转换为二进制,然后使用二进制表示形式作为筛选器来选择适当的数字。

有谁知道更好的方法吗?使用map(),也许?


9
读者应注意,列表项是否唯一是一个非常重要的考虑因素,因为许多算法随后会夸大某些子集(例如'abccc'-> ['','a','b','c','c' ,“C”,“交流”,“交流”,“交流”,...]一个简单的解决方法是只推一组的所有元素之前得到他们的排列。
ninjagecko

@ninjagecko使用Set库效率不高,因为每个函数最好都是O(n)。因此,将n个函数添加到集合中实际上是O(n ^ 2)!
Scott Biggs

通过仔细阅读问题,似乎OP正在要求他的15个数字列表的PowerSet,而不是所有组合。我认为这可能就是答案无处不在的原因。
Scott Biggs

@Scott Biggs:您确定要在这里使用Python吗?集插入和查找是O(1)平均情况。他们就像字典。他们使用哈希。Python没有特殊的集合库(在标准库中)。我们在这里插入数字而不是功能。(使用O(2 ^ n)内存仍然效率不高;对于想要组合而不是幂集的人来说,正确的解决方案是简单的递归实现product,等等)
ninjagecko

Answers:


466

看看itertools.combinations

itertools.combinations(iterable, r)

从可迭代的输入中返回元素的r长度子序列。

组合按字典顺序排序。因此,如果将输入的iterable排序,则将按排序顺序生成组合元组。

从2.6开始,包括电池!


31
您可以列出所有内容。list(itertools.combinations(iterable, r))
silgon

1
是否有不需要的东西r,即元素的任何长度子序列的组合。
mLstudent33

630

这个答案错过了一个方面:OP要求所有组合……而不仅仅是长度“ r”的组合。

因此,您要么必须遍历所有长度“ L”:

import itertools

stuff = [1, 2, 3]
for L in range(0, len(stuff)+1):
    for subset in itertools.combinations(stuff, L):
        print(subset)

或者-如果您想变得眼花or乱(或者想让以后阅读代码的人都屈服)-您可以生成“ combinations()”生成器链,然后进行迭代:

from itertools import chain, combinations
def all_subsets(ss):
    return chain(*map(lambda x: combinations(ss, x), range(0, len(ss)+1)))

for subset in all_subsets(stuff):
    print(subset)

42
感谢您的支持!自发布上述答复以来的几周内,我发现Ben所寻找的概念的名称是原始15个项目集中的“幂集”。实际上,在标准python“ itertools”文档页面上提供了示例实现:docs.python.org/library/itertools.html(“powerset”的grep)。
丹·H

38
对于到此为止的读者:该文档powerset()的配方部分中的generator函数更简单,可能使用的内存更少,并且可能比此处显示的实现更快。itertools
martineau

是否可以按字典顺序生成所有组合?
guik

@guik:我有99%的把握确保itertools.combinations将项目顺序保留在它产生的列表中。因此,如果按词法对输入进行排序,那么每个输出也将被分类。
丹·H

是的,itertools.combinations按字典顺序生成n个中的k个组合,但不是n个中直到 k个的所有组合。据我所知,powerset生成的所有组合最多为 k,但不按字典顺序排列:powerset([1,2])-> [(),(1,),(2,),(1,2)] 。它不应该是:[(),(1,),(1,2),(2,)]吗?
guik

52

这是一个懒惰的单行代码,也使用itertools:

from itertools import compress, product

def combinations(items):
    return ( set(compress(items,mask)) for mask in product(*[[0,1]]*len(items)) )
    # alternative:                      ...in product([0,1], repeat=len(items)) )

答案背后的主要思想是:有2 ^ N个组合-与长度为N的二进制字符串的数目相同。对于每个二进制字符串,请选择与“ 1”相对应的所有元素。

items=abc * mask=###
 |
 V
000 -> 
001 ->   c
010 ->  b
011 ->  bc
100 -> a
101 -> a c
110 -> ab
111 -> abc

注意事项:

  • 这就需要你可以调用len(...)items(解决方法:如果items是这样的迭代就像一台发电机,与第一把它变成一个列表items=list(_itemsArg)
  • 这要求迭代的顺序items不是随机的(解决方法:不要疯了)
  • 这就要求项目是独一无二的,要不然{2,2,1}{2,1,1}都将崩溃{2,1}(解决方法:使用collections.Counter作为一个下拉更换set;它基本上是一个多集...尽管你可能需要以后使用tuple(sorted(Counter(...).elements())),如果你需要它是可哈希)

演示版

>>> list(combinations(range(4)))
[set(), {3}, {2}, {2, 3}, {1}, {1, 3}, {1, 2}, {1, 2, 3}, {0}, {0, 3}, {0, 2}, {0, 2, 3}, {0, 1}, {0, 1, 3}, {0, 1, 2}, {0, 1, 2, 3}]

>>> list(combinations('abcd'))
[set(), {'d'}, {'c'}, {'c', 'd'}, {'b'}, {'b', 'd'}, {'c', 'b'}, {'c', 'b', 'd'}, {'a'}, {'a', 'd'}, {'a', 'c'}, {'a', 'c', 'd'}, {'a', 'b'}, {'a', 'b', 'd'}, {'a', 'c', 'b'}, {'a', 'c', 'b', 'd'}]

46

在@Dan H 极力支持的答案的评论powerset()中,itertools文档中提到了该配方—包括Dan本人的配方。但是,到目前为止,还没有人将其发布为答案。由于它可能是解决问题的最佳方法,即使不是最好的方法之一,并且在另一位评论者的鼓励下,它显示如下。该函数产生的所有列表中的元件的独特组合长度可能的(包括那些含有零和所有的元素)。

注意:如果,微妙的不同,目标是获得唯一的独特元素的组合,改线s = list(iterable),以s = list(set(iterable))消除任何重复的元素。无论如何,iterable最终会变成的事实list意味着它将与生成器一起使用(与其他几个答案不同)。

from itertools import chain, combinations

def powerset(iterable):
    "powerset([1,2,3]) --> () (1,) (2,) (3,) (1,2) (1,3) (2,3) (1,2,3)"
    s = list(iterable)  # allows duplicate elements
    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))

stuff = [1, 2, 3]
for i, combo in enumerate(powerset(stuff), 1):
    print('combo #{}: {}'.format(i, combo))

输出:

combo #1: ()
combo #2: (1,)
combo #3: (2,)
combo #4: (3,)
combo #5: (1, 2)
combo #6: (1, 3)
combo #7: (2, 3)
combo #8: (1, 2, 3)

list()首先转换是什么?
AMC

@Alexander:为了确定迭代器的长度。
martineau

36

这是使用递归的一种:

>>> import copy
>>> def combinations(target,data):
...     for i in range(len(data)):
...         new_target = copy.copy(target)
...         new_data = copy.copy(data)
...         new_target.append(data[i])
...         new_data = data[i+1:]
...         print new_target
...         combinations(new_target,
...                      new_data)
...                      
... 
>>> target = []
>>> data = ['a','b','c','d']
>>> 
>>> combinations(target,data)
['a']
['a', 'b']
['a', 'b', 'c']
['a', 'b', 'c', 'd']
['a', 'b', 'd']
['a', 'c']
['a', 'c', 'd']
['a', 'd']
['b']
['b', 'c']
['b', 'c', 'd']
['b', 'd']
['c']
['c', 'd']
['d']

可以修改它以返回列表列表而不是打印吗?
James Vickery

@JamesVickery是的,您可以查看在函数之外创建列表并追加到列表之外,或者(更好)使函数生成器,看看'yield'关键字:)
Dangercrow

new_data = copy.copy(data)-此行是多余的,因为据我看到的,它不会对任何影响
德米特里Fialkovskiy

31

这种单行代码为您提供了所有组合(如果原始列表/集合包含不同的元素,则在0n项之间n),并使用本机方法itertools.combinations

Python 2

from itertools import combinations

input = ['a', 'b', 'c', 'd']

output = sum([map(list, combinations(input, i)) for i in range(len(input) + 1)], [])

Python 3

from itertools import combinations

input = ['a', 'b', 'c', 'd']

output = sum([list(map(list, combinations(input, i))) for i in range(len(input) + 1)], [])

输出将是:

[[],
 ['a'],
 ['b'],
 ['c'],
 ['d'],
 ['a', 'b'],
 ['a', 'c'],
 ['a', 'd'],
 ['b', 'c'],
 ['b', 'd'],
 ['c', 'd'],
 ['a', 'b', 'c'],
 ['a', 'b', 'd'],
 ['a', 'c', 'd'],
 ['b', 'c', 'd'],
 ['a', 'b', 'c', 'd']]

在线尝试:

http://ideone.com/COghfX


这是一个排列
AdHominem '16

15
@AdHominem:不,不是。这是所有组合的列表。排列将包括例如['b', 'a']
naught101

TypeError: can only concatenate list (not "map") to list
0x48piraj

@ 0x48piraj:谢谢您的注意,因此我编辑了答案!
Mathieu Rodic,

21

我同意Dan H的观点,Ben确实要求所有组合。itertools.combinations()没有给出所有组合。

另一个问题是,如果可迭代的输入很大,则最好返回一个生成器而不是列表中的所有内容:

iterable = range(10)
for s in xrange(len(iterable)+1):
  for comb in itertools.combinations(iterable, s):
    yield comb

1
很好的例子。我爱发电机...我也喜欢Python!此示例一次只具有一个combinations()对象,并一次产生一个组合。(也许您想在此周围添加def块-作为一个使用示例。)请注意,我的实现(上面给出的chain())并没有太糟糕:的确,它在以下位置创建了所有len(iterable)生成器一次...但是它不会一次创建所有2个**(可迭代)组合,因为-据我了解-链“用完”第一个生成器,然后再从后续生成器中提取。
丹·H

18

这是一种可以轻松转移到支持递归的所有编程语言的方法(没有itertools,没有yield,没有列表理解)

def combs(a):
    if len(a) == 0:
        return [[]]
    cs = []
    for c in combs(a[1:]):
        cs += [c, c+[a[0]]]
    return cs

>>> combs([1,2,3,4,5])
[[], [1], [2], [2, 1], [3], [3, 1], [3, 2], ..., [5, 4, 3, 2, 1]]

14

您可以使用以下简单代码在python中生成列表的所有组合

import itertools

a = [1,2,3,4]
for i in xrange(0,len(a)+1):
   print list(itertools.combinations(a,i))

结果将是:

[()]
[(1,), (2,), (3,), (4,)]
[(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]
[(1, 2, 3), (1, 2, 4), (1, 3, 4), (2, 3, 4)]
[(1, 2, 3, 4)]

这段代码中的错误:不返回空集。可能表示xrange(0,...),但尚未测试。编辑:我继续编辑了您的答案以解决此问题。
ninjagecko 2015年

13

我认为我可以为那些寻求答案的人添加此功能,而无需导入itertools或任何其他额外的库。

def powerSet(items):
    """
    Power set generator: get all possible combinations of a list’s elements

    Input:
        items is a list
    Output:
        returns 2**n combination lists one at a time using a generator 

    Reference: edx.org 6.00.2x Lecture 2 - Decision Trees and dynamic programming
    """

    N = len(items)
    # enumerate the 2**N possible combinations
    for i in range(2**N):
        combo = []
        for j in range(N):
            # test bit jth of integer i
            if (i >> j) % 2 == 1:
                combo.append(items[j])
        yield combo

简单良率生成器用法:

for i in powerSet([1,2,3,4]):
    print (i, ", ",  end="")

上面用法示例的输出:

[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3],[4],[1,4] ,[2、4],[1、2、4],[3、4],[1、3、4],[2、3、4],[1、2、3、4],


我认为这是非常巧妙的解决方案。
greentec

8

这是涉及使用itertools.combinations函数的另一种解决方案(单行),但是这里我们使用了双重列表理解(与for循环或求和相对):

def combs(x):
    return [c for i in range(len(x)+1) for c in combinations(x,i)]

演示:

>>> combs([1,2,3,4])
[(), 
 (1,), (2,), (3,), (4,), 
 (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4), 
 (1, 2, 3), (1, 2, 4), (1, 3, 4), (2, 3, 4), 
 (1, 2, 3, 4)]

5
from itertools import permutations, combinations


features = ['A', 'B', 'C']
tmp = []
for i in range(len(features)):
    oc = combinations(features, i + 1)
    for c in oc:
        tmp.append(list(c))

输出

[
 ['A'],
 ['B'],
 ['C'],
 ['A', 'B'],
 ['A', 'C'],
 ['B', 'C'],
 ['A', 'B', 'C']
]

4

下面是一个“标准递归答案”,类似于其他类似的答案https://stackoverflow.com/a/23743696/711085。(我们实际上不必担心会耗尽堆栈空间,因为我们不可能处理所有N!个置换。)

它依次访问每个元素,然后接受或离开它(我们可以从该算法直接看到2 ^ N基数)。

def combs(xs, i=0):
    if i==len(xs):
        yield ()
        return
    for c in combs(xs,i+1):
        yield c
        yield c+(xs[i],)

演示:

>>> list( combs(range(5)) )
[(), (0,), (1,), (1, 0), (2,), (2, 0), (2, 1), (2, 1, 0), (3,), (3, 0), (3, 1), (3, 1, 0), (3, 2), (3, 2, 0), (3, 2, 1), (3, 2, 1, 0), (4,), (4, 0), (4, 1), (4, 1, 0), (4, 2), (4, 2, 0), (4, 2, 1), (4, 2, 1, 0), (4, 3), (4, 3, 0), (4, 3, 1), (4, 3, 1, 0), (4, 3, 2), (4, 3, 2, 0), (4, 3, 2, 1), (4, 3, 2, 1, 0)]

>>> list(sorted( combs(range(5)), key=len))
[(), 
 (0,), (1,), (2,), (3,), (4,), 
 (1, 0), (2, 0), (2, 1), (3, 0), (3, 1), (3, 2), (4, 0), (4, 1), (4, 2), (4, 3), 
 (2, 1, 0), (3, 1, 0), (3, 2, 0), (3, 2, 1), (4, 1, 0), (4, 2, 0), (4, 2, 1), (4, 3, 0), (4, 3, 1), (4, 3, 2), 
 (3, 2, 1, 0), (4, 2, 1, 0), (4, 3, 1, 0), (4, 3, 2, 0), (4, 3, 2, 1), 
 (4, 3, 2, 1, 0)]

>>> len(set(combs(range(5))))
32

2

使用列表理解:

def selfCombine( list2Combine, length ):
    listCombined = str( ['list2Combine[i' + str( i ) + ']' for i in range( length )] ).replace( "'", '' ) \
                     + 'for i0 in range(len( list2Combine ) )'
    if length > 1:
        listCombined += str( [' for i' + str( i ) + ' in range( i' + str( i - 1 ) + ', len( list2Combine ) )' for i in range( 1, length )] )\
            .replace( "', '", ' ' )\
            .replace( "['", '' )\
            .replace( "']", '' )

    listCombined = '[' + listCombined + ']'
    listCombined = eval( listCombined )

    return listCombined

list2Combine = ['A', 'B', 'C']
listCombined = selfCombine( list2Combine, 2 )

输出为:

['A', 'A']
['A', 'B']
['A', 'C']
['B', 'B']
['B', 'C']
['C', 'C']

4
这个建议是做字符串处理以建立集合吗?!?!乌鸦……。而且:它不是在返回功率集,而是返回类似于combings_with_replacement()的东西。(见docs.python.org/library/...
丹^ h

这的确与combination_with_replacement()相同,但是至少在我的机器上,它的运行速度比itertools略快。我能说什么,我喜欢列表理解。
2011年

1
谢谢您的回答!关于创建列表怎么办?结合反向列表,例如['A','A'],['A','B'],['A','C'],['B','A'],[ 'B','B'],['B','C'],['C','A'],['C','B']和['C','C']包括一切?
卡约

非常有趣,但是我的python无法完全理解此处的细微差别。在不同范围内使用listCombined是否有一些特殊之处,并且for循环全部在一行中?我试图运气很小,将其移植到Java。
Scott Biggs

2

该代码采用带有嵌套列表的简单算法...

# FUNCTION getCombos: To generate all combos of an input list, consider the following sets of nested lists...
#
#           [ [ [] ] ]
#           [ [ [] ], [ [A] ] ]
#           [ [ [] ], [ [A],[B] ],         [ [A,B] ] ]
#           [ [ [] ], [ [A],[B],[C] ],     [ [A,B],[A,C],[B,C] ],                   [ [A,B,C] ] ]
#           [ [ [] ], [ [A],[B],[C],[D] ], [ [A,B],[A,C],[B,C],[A,D],[B,D],[C,D] ], [ [A,B,C],[A,B,D],[A,C,D],[B,C,D] ], [ [A,B,C,D] ] ]
#
#  There is a set of lists for each number of items that will occur in a combo (including an empty set).
#  For each additional item, begin at the back of the list by adding an empty list, then taking the set of
#  lists in the previous column (e.g., in the last list, for sets of 3 items you take the existing set of
#  3-item lists and append to it additional lists created by appending the item (4) to the lists in the
#  next smallest item count set. In this case, for the three sets of 2-items in the previous list. Repeat
#  for each set of lists back to the initial list containing just the empty list.
#

def getCombos(listIn = ['A','B','C','D','E','F'] ):
    listCombos = [ [ [] ] ]     # list of lists of combos, seeded with a list containing only the empty list
    listSimple = []             # list to contain the final returned list of items (e.g., characters)

    for item in listIn:
        listCombos.append([])   # append an emtpy list to the end for each new item added
        for index in xrange(len(listCombos)-1, 0, -1):  # set the index range to work through the list
            for listPrev in listCombos[index-1]:        # retrieve the lists from the previous column
                listCur = listPrev[:]                   # create a new temporary list object to update
                listCur.append(item)                    # add the item to the previous list to make it current
                listCombos[index].append(listCur)       # list length and append it to the current list

                itemCombo = ''                          # Create a str to concatenate list items into a str
                for item in listCur:                    # concatenate the members of the lists to create
                    itemCombo += item                   # create a string of items
                listSimple.append(itemCombo)            # add to the final output list

    return [listSimple, listCombos]
# END getCombos()

因此,这段代码似乎要做的是返回[listOfCombinations,listOfCombinationsGroupedBySize]。不幸的是,当使用演示输入运行时,它提供了63个元素,而不是64个。它似乎缺少空集(在本例中为空字符串"")。
ninjagecko

2

我知道这是更为实际使用itertools得到所有的组合,但你可以想代码实现这个部分,只有列表中理解,如果你这么碰巧的愿望,给予了很多

对于两对组合:

    lambda l: [(a, b) for i, a in enumerate(l) for b in l[i+1:]]


而且,对于三对组合,就这么简单:

    lambda l: [(a, b, c) for i, a in enumerate(l) for ii, b in enumerate(l[i+1:]) for c in l[i+ii+2:]]


结果与使用itertools.combinations相同:

import itertools
combs_3 = lambda l: [
    (a, b, c) for i, a in enumerate(l) 
    for ii, b in enumerate(l[i+1:]) 
    for c in l[i+ii+2:]
]
data = ((1, 2), 5, "a", None)
print("A:", list(itertools.combinations(data, 3)))
print("B:", combs_3(data))
# A: [((1, 2), 5, 'a'), ((1, 2), 5, None), ((1, 2), 'a', None), (5, 'a', None)]
# B: [((1, 2), 5, 'a'), ((1, 2), 5, None), ((1, 2), 'a', None), (5, 'a', None)]

2

不使用itertools:

def combine(inp):
    return combine_helper(inp, [], [])


def combine_helper(inp, temp, ans):
    for i in range(len(inp)):
        current = inp[i]
        remaining = inp[i + 1:]
        temp.append(current)
        ans.append(tuple(temp))
        combine_helper(remaining, temp, ans)
        temp.pop()
    return ans


print(combine(['a', 'b', 'c', 'd']))

2

这是两个实现 itertools.combinations

返回列表的一个

def combinations(lst, depth, start=0, items=[]):
    if depth <= 0:
        return [items]
    out = []
    for i in range(start, len(lst)):
        out += combinations(lst, depth - 1, i + 1, items + [lst[i]])
    return out

一个还发电机

def combinations(lst, depth, start=0, prepend=[]):
    if depth <= 0:
        yield prepend
    else:
        for i in range(start, len(lst)):
            for c in combinations(lst, depth - 1, i + 1, prepend + [lst[i]]):
                yield c

请注意,建议为这些函数提供帮助函数,因为prepend参数是静态的,并且不会在每次调用时更改

print([c for c in combinations([1, 2, 3, 4], 3)])
# [[1, 2, 3], [1, 2, 4], [1, 3, 4], [2, 3, 4]]

# get a hold of prepend
prepend = [c for c in combinations([], -1)][0]
prepend.append(None)

print([c for c in combinations([1, 2, 3, 4], 3)])
# [[None, 1, 2, 3], [None, 1, 2, 4], [None, 1, 3, 4], [None, 2, 3, 4]]

这是一个非常肤浅的案例,但总比后悔要安全


2

怎么样..使用字符串而不是列表,但是同样的事情..字符串可以像Python中的列表一样对待:

def comb(s, res):
    if not s: return
    res.add(s)
    for i in range(0, len(s)):
        t = s[0:i] + s[i + 1:]
        comb(t, res)

res = set()
comb('game', res) 

print(res)

2

来自itertools的组合

import itertools
col_names = ["aa","bb", "cc", "dd"]
all_combinations = itertools.chain(*[itertools.combinations(col_names,i+1) for i,_ in enumerate(col_names)])
print(list(all_combinations))

谢谢


2

没有 itertools Python 3,您可以执行以下操作:

def combinations(arr, carry):
    for i in range(len(arr)):
        yield carry + arr[i]
        yield from combinations(arr[i + 1:], carry + arr[i])

最初在哪里 carry = "".


2

3个功能:

  1. n个元素的所有组合列表
  2. n个元素的所有组合列出了顺序不同的地方
  3. 所有排列
import sys

def permutations(a):
    return combinations(a, len(a))

def combinations(a, n):
    if n == 1:
        for x in a:
            yield [x]
    else:
        for i in range(len(a)):
            for x in combinations(a[:i] + a[i+1:], n-1):
                yield [a[i]] + x

def combinationsNoOrder(a, n):
    if n == 1:
        for x in a:
            yield [x]
    else:
        for i in range(len(a)):
            for x in combinationsNoOrder(a[:i], n-1):
                yield [a[i]] + x

if __name__ == "__main__":
    for s in combinations(list(map(int, sys.argv[2:])), int(sys.argv[1])):
        print(s)

我很喜欢这个!!!谢谢!!!Python的combinatorics函数虽然有点奇怪。在数学中,“组合”函数将是“变体”,而“ combinationsNoOrder”实际上是组合。我想这会让来自数学分支的python迷惑,就像这次对我所做的那样。无论如何,这是一个不错的解决方案,非常感谢!
Đumić伊万

1

这是我的实现

    def get_combinations(list_of_things):
    """gets every combination of things in a list returned as a list of lists

    Should be read : add all combinations of a certain size to the end of a list for every possible size in the
    the list_of_things.

    """
    list_of_combinations = [list(combinations_of_a_certain_size)
                            for possible_size_of_combinations in range(1,  len(list_of_things))
                            for combinations_of_a_certain_size in itertools.combinations(list_of_things,
                                                                                         possible_size_of_combinations)]
    return list_of_combinations

1
您实现的解决方案比此处发布的以前的实现更好。
user1767754'1

0

您也可以使用优质包装中的Powerset功能more_itertools

from more_itertools import powerset

l = [1,2,3]
list(powerset(l))

# [(), (1,), (2,), (3,), (1, 2), (1, 3), (2, 3), (1, 2, 3)]

我们还可以验证它是否符合OP的要求

from more_itertools import ilen

assert ilen(powerset(range(15))) == 32_768

-1
def combinations(iterable, r):
# combinations('ABCD', 2) --> AB AC AD BC BD CD
# combinations(range(4), 3) --> 012 013 023 123
pool = tuple(iterable)
n = len(pool)
if r > n:
    return
indices = range(r)
yield tuple(pool[i] for i in indices)
while True:
    for i in reversed(range(r)):
        if indices[i] != i + n - r:
            break
    else:
        return
    indices[i] += 1
    for j in range(i+1, r):
        indices[j] = indices[j-1] + 1
    yield tuple(pool[i] for i in indices)


x = [2, 3, 4, 5, 1, 6, 4, 7, 8, 3, 9]
for i in combinations(x, 2):
    print i

1
如果我是对的,那么这是从python文档[ docs.python.org/3.6/library/itertools.html ] 复制的确切代码。如果是这样,请参考来源。
GabrielChu

有趣的方法
pelos

-1

如果有人正在寻找反向列表,就像我曾经那样:

stuff = [1, 2, 3, 4]

def reverse(bla, y):
    for subset in itertools.combinations(bla, len(bla)-y):
        print list(subset)
    if y != len(bla):
        y += 1
        reverse(bla, y)

reverse(stuff, 1)

-1
flag = 0
requiredCals =12
from itertools import chain, combinations

def powerset(iterable):
    s = list(iterable)  # allows duplicate elements
    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))

stuff = [2,9,5,1,6]
for i, combo in enumerate(powerset(stuff), 1):
    if(len(combo)>0):
        #print(combo , sum(combo))
        if(sum(combo)== requiredCals):
            flag = 1
            break
if(flag==1):
    print('True')
else:
    print('else')
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.