Python lambda function to calculate factorial of a number

The factorial itself is almost as you'd expect it. You infer that the a is... the factorial function. b is the actual parameter.

<factorial> = lambda a, b: b*a(a, b-1) if b > 0 else 1

This bit is the application of the factorial:

<factorial-application> = (lambda a, b: a(a, b))(<factorial>, b)

a is the factorial function itself. It takes itself as its first argument, and the evaluation point as the second. This can be generalized to recursive_lambda as long as you don't mind a(a, b - 1) instead of a(b - 1):

recursive_lambda = (lambda func: lambda *args: func(func, *args))
print(recursive_lambda(lambda self, x: x * self(self, x - 1) if x > 0 else 1)(6))
# Or, using the function verbatim:
print(recursive_lambda(lambda a, b: b*a(a, b-1) if b > 0 else 1)(6))

So we have the outer part:

(lambda b: <factorial-application>)(num)

As you see all the caller has to pass is the evaluation point.

---

If you actually wanted to have a recursive lambda, you could just name the lambda:

fact = lambda x: 1 if x == 0 else x * fact(x-1)

If not, you can use a simple helper function. You'll notice that ret is a lambda that can refer to itself, unlike in the previous code where no lambda could refer to itself.

def recursive_lambda(func):
    def ret(*args):
        return func(ret, *args)
    return ret

print(recursive_lambda(lambda factorial, x: x * factorial(x - 1) if x > 1 else 1)(6))  # 720

Both ways you don't have to resort to ridiculous means of passing the lambda to itself.

There are two hard parts about this function.
1. lambda a, b: b*a(a, b-1) if b > 0 else 1.
2. the "b" that's folowing 1.

For 1, it's nothing more than:

def f(a, b):
    if b > 0:
        b * a(a, b - 1)
    else:
        1

For 2, this b

(lambda b: (lambda a, b: a(a, b))(lambda a, b: b*a(a, b-1) if b > 0 else 1,b))(num)
                                                                      (this one)

is actually this b:

(lambda b: (lambda a, b: a(a, b))(lambda a, b: b*a(a, b-1) if b > 0 else 1,b))(num)
   (this one)

The reason is that it's not inside the definition of the second and third lambda, so it refers to the first b.

After we apply num and strip off the outer function:

(lambda a, b: a(a, b))  (lambda a, b: b*a(a, b-1) if b > 0 else 1, num) 

It's just applying a function to a tuple, (lambda a, b: b*a(a, b-1) if b > 0 else 1, num)
Let's call this tuple as (f, num) (f's def is above) Applying lambda a, b: a(a, b) on it, we get

f(f, num).

Suppose your num is 5.
By definiton of f, it first evaluates to

5 * f(f, 4)  

Then to:

5 * (4 * f(f, 3)) 

All the way down to

5 * (4 * (3 * (2 * (1 * f(f, 0)))))

f(f, 0) goes to 1.

5 * (4 * (3 * (2 * (1 * 1))))

Here we go, the factorial of 5.

It is this simple:

n=input()

print reduce(lambda x,y:x*y,range(1,n+1))

Let's peel this one liner open like an onion.

print (lambda b: (Y))(num)

We are making an anonymous function (the keyword lambda means we're about to type a series of parameter names, then a colon, then a function that uses those parameters) and then pass it num to satisfy its one parameter.

   (lambda a, b: a(a, b))(X,b)

Inside of the lambda, we define another lambda. Call this lambda Y. This one takes two parameters, a and b. a is called with a and b, so a is a callable that takes itself and one other parameter

            (lambda a, b: b*a(a, b-1) if b > 0 else 1
            ,
            b)

These are the parameters to Y. The first one is a lambda function, call it X. We can see that X is the factorial function, and that the second parameter will become its number.

That is, if we go up and look at Y, we can see that we will call:

X(X, b)

which will do

b*X(X, b-1) if b > 0 else 1

and call itself, forming the recursive part of factorial.

And looking all the way back outside, we can see that b is num that we passed into the outermost lambda.

num*X(X, b-1) if num > 0 else 1

This is kind of confusing because it was written as a confusing one liner :)