Bir liste öğelerinin tüm olası kombinasyonlarını nasıl elde edebilirim?

15 numara ile bir liste var ve ben bu sayıların 32.768 kombinasyonları üreten bazı kod yazmak gerekiyor.

Kod buldum görünüşe göre ben aradığım yapar (Googling tarafından), ama kod oldukça opak bulundu ve bunu kullanarak dikkatli değilim. Ayrıca daha şık bir çözüm olması gerektiğini hissediyorum.

Benim başıma gelen tek şey, 1–32768 ondalık sayıları arasında döngü yapmak ve bunları ikili sayıya dönüştürmek ve ikili sayıları uygun sayıları seçmek için bir filtre olarak kullanmak olacaktır.

Daha iyi bir yol bilen var mı? Kullanılması map()belki?

İtertools.com'a bir göz atın :

itertools.combinations(iterable, r)

Tekrarlanabilir girişten elemanların r uzunluk sıralarını döndürün.

Kombinasyonlar sözlükbilimsel sıralama düzeninde yayılır. Bu nedenle, yinelenebilir girdi sıralanırsa, kombinasyon tupleri sıralı olarak üretilir.

2.6'dan beri piller dahildir!

Bu cevap bir yönü kaçırdı: OP TÜM kombinasyonları istedi ... sadece "r" uzunluk kombinasyonlarını değil.

Yani ya tüm "L" uzunlukları arasında döngü yapmalısınız:

import itertools

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

Veya - şık olmak istiyorsanız (veya kodunuzu sizden sonra okuyanın beynini bükmek istiyorsanız) - "kombinasyonlar ()" jeneratörleri zincirini oluşturabilir ve bunu tekrarlayabilirsiniz:

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)

İşte itertools kullanan tembel bir astar:

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)) )

Bu cevabın arkasındaki ana fikir: 2 ^ N kombinasyonu vardır - N uzunluğundaki ikili dizelerin sayısı ile aynıdır. Her ikili dize için, "1" e karşılık gelen tüm öğeleri seçersiniz.

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

Düşünülmesi gereken şeyler:

• Bu Arayabileceğin gerektirir len(...)üzerinde items(: eğer çözüm itemsbir jeneratör gibi bir iterable gibi bir şey, ilk bir liste haline getirmek items=list(_itemsArg))
• Bu, yineleme sırasının itemsrastgele olmamasını gerektirir (geçici çözüm: deli olma)
• Bu, öğelerin benzersiz veya başka şekilde olmasını {2,2,1}ve {2,1,1}her ikisinin de daralmasını gerektirir {2,1}(geçici çözüm: için collections.Counterbir yedek değiştirme olarak kullanın set; temelde bir çoklu ayardır ... ancak daha sonra tuple(sorted(Counter(...).elements()))yıkanabilir olması gerekiyorsa kullanmanız gerekebilir)

gösteri

>>> 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'}]

@ Dan H tarafından son derece onaylanan cevap altındaki yorumlarda , Dan'ın kendisi de dahil olmak üzere dokümantasyondakipowerset() tariften bahsedilmektedir . Ancak , şimdiye kadar kimse bunu yanıt olarak göndermedi. Muhtemelen soruna en iyi yaklaşım olmasa da daha iyi olanlardan biri olduğu ve başka bir yorumcunun biraz cesaretlendirdiği için aşağıda gösterilmiştir. İşlev, mümkün olan her uzunluktaki liste öğelerinin tüm benzersiz kombinasyonlarını üretir (sıfır içerenler ve tüm öğeler dahil).itertools

Not :, ustaca farklı, amaç eşsiz elemanların sadece kombinasyonlarını elde etmek ise, hat değiştirmek s = list(iterable)için s = list(set(iterable))herhangi bir yinelenen unsurları ortadan kaldırmak. Ne olursa olsun, iterablenihayetinde listjeneratörlerle çalışacağı bir araca dönüşmesi (diğer cevapların çoğunun aksine).

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))

Çıktı:

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)

İşte özyineleme kullanan biri:

>>> 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']

Bu tek satırlık size tüm kombinasyonları verir (arasına 0ve nürün orijinal liste / set içeriyorsa nfarklı unsurları) ve yerli yöntemini kullanıritertools.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)], [])

Çıktı şöyle olacaktır:

[[],
 ['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']]

Çevrimiçi deneyin:

http://ideone.com/COghfX

Dan H ile Ben'in tüm kombinasyonları istediğini kabul ediyorum . itertools.combinations()tüm kombinasyonları vermez.

Başka bir sorun, yinelenebilir girdi büyükse, listedeki her şey yerine bir jeneratör döndürmek daha iyidir:

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

Bu, özyinelemeyi destekleyen tüm programlama dillerine kolayca aktarılabilen bir yaklaşımdır ( yineleme yok, verim yok, liste kavrama yok) :

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]]

Bu basit kodu kullanarak python'da bir listenin tüm kombinasyonlarını oluşturabilirsiniz

import itertools

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

Sonuç:

[()]
[(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)]

Bu işlevi itertools veya başka herhangi bir ek kitaplığı içe aktarmadan yanıt arayanlar için ekleyeceğimi düşündüm.

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

Basit Verim Jeneratörü Kullanımı:

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

Yukarıdaki Kullanım örneğinden çıktı:

[], [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],

İşte itertools.combinationsfonksiyonun kullanılmasını içeren başka bir çözüm (tek astar), ancak burada bir çift liste kavrayışı kullanıyoruz (for döngüsü veya toplamının aksine):

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

Demo:

>>> 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)]

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))

çıktı

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

Aşağıda, diğer benzer yanıta benzer bir "standart özyinelemeli yanıt" bulunmaktadır https://stackoverflow.com/a/23743696/711085 . (Tüm N! Permütasyonlarını işleyebilmemizin bir yolu olmadığından, gerçekçi olarak yığın boşluğunun bitmesi konusunda endişelenmemize gerek yoktur.)

Sırasıyla her öğeyi ziyaret eder ve onu alır veya bırakır (bu algoritmadan doğrudan 2 ^ N kardinalitesini görebiliriz).

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

Demo:

>>> 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

Liste kavrayışı kullanma:

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 )

Çıktı:

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

Bu kod, iç içe listelerle basit bir algoritma kullanır ...

# 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()

Tüm kombinasyonları elde etmek için itertools'u kullanmanın çok daha pratik olduğunu biliyorum , ancak bunu sadece arzu ederseniz, sadece kod anlama ile verdiğiniz takdirde, sadece liste kavrama ile elde edebilirsiniz. çok

İki çift kombinasyonu için:

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

Ve üç çiftin kombinasyonları için, bu kadar kolay:

    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:]]

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)]

Itertools kullanmadan:

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']))

İşte iki uygulama itertools.combinations

Bir liste döndüren

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

Biri bir jeneratör döndürür

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

Başlatma argümanının statik olduğu ve her çağrıda değişmediği için bunlara yardımcı işlev sağlamanın tavsiye edildiğini lütfen unutmayın

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]]

Bu çok yüzeysel bir durum ama üzgün olmaktan daha iyi

Buna ne dersin .. liste yerine bir dize kullandı ama aynı şey .. string Python'da bir liste gibi ele alınabilir:

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)

Itertools'tan kombinasyon

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))

Teşekkürler

itertoolsPython 3 olmadan böyle bir şey yapabilirsiniz:

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

başlangıçta nerede carry = "".

3 fonksiyon:

1. n elemanlar listesinin tüm kombinasyonları
2. n öğesinin tüm kombinasyonları, siparişin farklı olmadığı yerlerde listelenir
3. tüm permütasyonlar

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)

Bu benim uygulamam

    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

Güçmore_itertools paketi işlevini mükemmel paketten de kullanabilirsiniz .

from more_itertools import powerset

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

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

Ayrıca OP'nin gereksinimlerini karşıladığını da doğrulayabiliriz

from more_itertools import ilen

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

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

Birisi benim gibi ters bir liste arıyor:

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)

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')