Python 问题 — lambda 版本的递归组合 function

Question

Okay so I have the following simple Python 3 function that does exactly what it's supposed to do:

def comb(a):
    if len(a)==0:
        return[[]]
    else:
        p=[]
        for c in comb(a[1:]):
            p+=[c,c+a[:1]]      
        return p

which correctly produces

>>> comb([1,2,3])
[[], [1], [2], [2, 1], [3], [3, 1], [3, 2], [3, 2, 1]]

Motivated by nothing other than a desire to better my own understanding of recursive functions, I tried to see if I could turn this simple function into a lambda. First thing I tried was various versions of:

comb=lambda a:[[]]if len(a)==0 else[[c,c+a[:1]]for c in comb(a[1:])]

Which, obviously, didn't work. Then I took a step back and just tried to change the syntax of the original function like:

def comb(a):
    return[[]]if len(a)==0 else[p for p in[[c,c+a[:1]]for c in comb(a[1:])]]

Which also doesn't work, like at all. I tried all kinds of different arrangements but to no avail. Obviously the original function is the most useful and easiest to read, I'm only asking about this to better my own python understanding. I'm normally pretty good at this game when recursion isn't involved so I'm just trying to understand what it is I'm missing here.

Answer 1

If your goal is to rewrite the function to lambda one-liner, you can do it using sum() for example:

comb = lambda a: [[]] if len(a)==0 else sum(([c,c+a[:1]] for c in comb(a[1:])), [])

print(comb([1, 2, 3]))

Prints:

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

NOTE: The above solution is not very readable. The classic function is better.

---

Thanks @Chris_Rands, solution with itertools.chain :

from itertools import chain

comb = lambda a: [[]] if len(a)==0 else [*chain.from_iterable([c,c+a[:1]] for c in comb(a[1:]))]

Answer 2

Your problem is with the list comprehension.

[[c,c+a[:1]]for c in l] is a list of length len(l) whose elements are lists are with 2 elements. What you want is a list of length 2*len(l) , which is the flattened version of this.

comb=lambda a:[[]]if len(a)==0 else[c+a[:1]for c in comb(a[1:])] + comb(a[1:])

Works but can probably be improved because it makes 2 calls to comb each time, when only 1 is needed.