我有一个包含15个数字的列表，我需要编写一些代码来生成这些数字的所有32,768种组合。
我发现some code（通过谷歌搜索）显然正在寻找我正在寻找的东西，但我发现代码相当不透明并且对使用它很谨慎。另外我觉得必须有一个更优雅的解决方案。
我唯一想到的就是循环遍历十进制整数1-32768并将它们转换为二进制，并使用二进制表示作为过滤器来选择适当的数字。
有谁知道更好的方法？使用map()，也许？
答案 0 :(得分：550)
This answer错过了一个方面：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)
或者 - 如果你想变得时髦（或者在你之后弯曲你的代码的大脑） - 你可以生成“combination（）”生成器链，并迭代：
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)
答案 1 :(得分：357)
itertools.combinations(iterable, r)返回元素的r长度子序列 输入可迭代。
组合以字典排序顺序发出。所以，如果 输入iterable被排序， 组合元组将在 排序顺序。
自2.6以来，包括电池！
答案 2 :(得分：43)
这是一个懒惰的单行，也使用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作为{的替代品{1}};它基本上是一个多集...但如果你需要它可以使用set，你可能需要稍后使用{}} <强>演示
tuple(sorted(Counter(...).elements()))答案 3 :(得分：39)
在@Dan H高度评价answer的评论中，提到itertools documentation中的powerset()食谱 - 包括Dan himself之一。 然而，到目前为止还没有人发布它作为答案。因为它可能是解决问题的最佳方法之一 - 并且从另一位评论者那里得到little encouragement，如下所示。该函数生成所有长度的列表元素的所有唯一组合（包括那些包含零和所有元素的列表元素）。
注意：如果略有不同，目标是仅获取唯一元素的组合，请将行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)
答案 4 :(得分：30)
这是一个使用递归：
>>> 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']
答案 5 :(得分：27)
如果原始列表/集包含0个不同的元素，则此单行为您提供所有组合（n和n项之间的组合）并使用本机方法{{3} }：
from itertools import combinations
input = ['a', 'b', 'c', 'd']
output = sum([map(list, combinations(input, i)) for i in range(len(input) + 1)], [])
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']]
在线试用：
答案 6 :(得分：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
答案 7 :(得分：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)]
答案 8 :(得分：8)
我想我会为那些寻求答案的人添加这个功能，而无需导入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]，
答案 9 :(得分：6)
您还可以使用优质的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
答案 10 :(得分：5)
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)
答案 11 :(得分：5)
可以使用itertools
完成用于排列
此方法将列表作为输入，并以列表形式返回包含长度L的排列的元组的对象列表。
# A Python program to print all
# permutations of given length
from itertools import permutations
# Get all permutations of length 2
# and length 2
perm = permutations([1, 2, 3], 2)
# Print the obtained permutations
for i in list(perm):
print (i)
组合
此方法将一个列表和一个输入r作为输入，并返回一个元组的对象列表，该元组包含以列表形式包含长度r的所有可能组合。
# A Python program to print all
# combinations of given length
from itertools import combinations
# Get all combinations of [1, 2, 3]
# and length 2
comb = combinations([1, 2, 3], 2)
# Print the obtained combinations
for i in list(comb):
print (i)
请参阅this
答案 12 :(得分：5)
这是另一个解决方案（单行），涉及使用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)]
答案 13 :(得分：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
答案 14 :(得分：3)
这是一种可以轻松地转移到支持递归的所有编程语言的方法（没有迭代器，没有收益，没有列表理解）：
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]]
答案 15 :(得分：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 = "".
答案 16 :(得分：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)]
答案 17 :(得分：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))
由于
答案 18 :(得分：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)
答案 19 :(得分：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]]
这是一个非常肤浅的案例，但最好是安全而不是抱歉
答案 20 :(得分：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']))
答案 21 :(得分：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()
答案 22 :(得分：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
答案 23 :(得分：1)
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']
]
答案 24 :(得分：1)
使用列表理解：
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']
答案 25 :(得分：0)
如果有人正在寻找一个反向列表，就像我一样：
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)
答案 26 :(得分：0)
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
答案 27 :(得分：0)
我参加聚会很晚，但想分享我在同一问题上发现的解决方案： 具体来说，我想进行顺序组合，因此对于“ STAR”，我想要“ STAR”，“ TA”，“ AR”，而不是“ SR”。
lst = [S, T, A, R]
lstCombos = []
for Length in range(0,len(lst)+1):
for i in lst:
lstCombos.append(lst[lst.index(i):lst.index(i)+Length])
如果在最后一行之前添加其他内容，则可以过滤重复项：
lst = [S, T, A, R]
lstCombos = []
for Length in range(0,len(lst)+1):
for i in lst:
if not lst[lst.index(i):lst.index(i)+Length]) in lstCombos:
lstCombos.append(lst[lst.index(i):lst.index(i)+Length])
如果由于某种原因在输出中返回了空白列表，这对我来说是偶然的，我添加：
for subList in lstCombos:
if subList = '':
lstCombos.remove(subList)
答案 28 :(得分：0)
如果您不想使用组合库，这里是解决方案：
nums = [1,2,3]
p = [[]]
fnl = [[],nums]
for i in range(len(nums)):
for j in range(i+1,len(nums)):
p[-1].append([i,j])
for i in range(len(nums)-3):
p.append([])
for m in p[-2]:
p[-1].append(m+[m[-1]+1])
for i in p:
for j in i:
n = []
for m in j:
if m < len(nums):
n.append(nums[m])
if n not in fnl:
fnl.append(n)
for i in nums:
if [i] not in fnl:
fnl.append([i])
print(fnl)
输出：
[[], [1, 2, 3], [1, 2], [1, 3], [2, 3], [1], [2], [3]]
答案 29 :(得分：-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')