All combinations of list wIthout itertools

Question

I'm trying to make a recursive function that finds all the combinations of a python list.

I want to input ['a','b','c'] in my function and as the function runs I want the trace to look like this:

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

My recursive function looks like this:

def combo(lst,new_lst = []):
    for item in lst:
        new_lst.append([lst[0],item])
        print([lst[0],item])
    return combo(new_lst,lst[1:])

Answer 1

The right answer is that you should use itertools.combinations . But if for some reason you don't want to, and want to write a recursive function, you can use the following piece of code. It is an adaptation of the erlang way of generating combinations, so it may seem a bit weird at first:

def combinations(N, iterable):
    if not N:
        return [[]]
    if not iterable:
        return []

    head = [iterable[0]]
    tail = iterable[1:]
    new_comb = [ head + list_ for list_ in combinations(N - 1, tail) ]

    return new_comb + combinations(N, tail)

This a very elegant way of thinking of combinations of size N : you take the first element of an iterable ( head ) and combine it with smaller ( N-1 ) combinations of the rest of the iterable ( tail ). Then you add same size ( N ) combinations of the tail to that. That's how you get all possible combinations.

If you need all combinations, of all lengths you would do:

for n in range(1, len(iterable) + 1):
    print(combinations(n, iterable))

Answer 2

Seems that you want all the product of a list, you can use itertools.product within the following function to return a list of generators:

>>> from itertools import product
>>> def pro(li):
...       return [product(l,repeat=i) for i in range(2,len(l)+1)]
... 
>>> for i in pro(l):
...     print list(i)
... 
[('a', 'a'), ('a', 'b'), ('a', 'c'), ('b', 'a'), ('b', 'b'), ('b', 'c'), ('c', 'a'), ('c', 'b'), ('c', 'c')]
[('a', 'a', 'a'), ('a', 'a', 'b'), ('a', 'a', 'c'), ('a', 'b', 'a'), ('a', 'b', 'b'), ('a', 'b', 'c'), ('a', 'c', 'a'), ('a', 'c', 'b'), ('a', 'c', 'c'), ('b', 'a', 'a'), ('b', 'a', 'b'), ('b', 'a', 'c'), ('b', 'b', 'a'), ('b', 'b', 'b'), ('b', 'b', 'c'), ('b', 'c', 'a'), ('b', 'c', 'b'), ('b', 'c', 'c'), ('c', 'a', 'a'), ('c', 'a', 'b'), ('c', 'a', 'c'), ('c', 'b', 'a'), ('c', 'b', 'b'), ('c', 'b', 'c'), ('c', 'c', 'a'), ('c', 'c', 'b'), ('c', 'c', 'c')]