Python lambda function to calculate factorial of a number

Question

I have just started learning python. I came across lambda functions. On one of the problems, the author asked to write a one liner lambda function for factorial of a number.

This is the solution that was given:

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

I cannot understand the weird syntax. What does a(a,b) mean?

Can someone explain?

Thanks

Answer 1

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.

Answer 2

It is this simple:

n=input()

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

Answer 3

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

Answer 4

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.