Recursive Function Calls or Functional Programming as a concept can be quite daunting for beginners.

This example shows how looping can be replaced, with a lambda. Do not fear.

• Calculating the factorial of a number by using loops
``````# factorial with loops

# while-loop
def while_factorial(n):
if n <= 0:
return 0
else:
num = 1
while n >= 1:
num = num * n
n = n - 1
return num

assert while_factorial(4) == 24
assert while_factorial(5) == 120

# for-loop
def for_factorial(x):
if x == 1:
return 1
elif x <= 0:
return 0
else:
for i in range(1, x):
x *= i
return x

assert for_factorial(4) == 24
assert for_factorial(5) == 120
``````
• by recalling a function/method:
``````# traditional
def rec_factorial(x):
if x is 1:
return 1
else:
return x * rec_factorial(x - 1)

assert rec_factorial(4) == 24
assert rec_factorial(5) == 120
``````
• using lambdas results in code that looks something like this:
``````# lambda implementation
lambda_factorial = lambda x: 1 if x is 1 else x * lambda_factorial(x-1)
# pay attention to how a if-else-guard is implemented

assert lambda_factorial(4) == 24
assert lambda_factorial(5) == 120
``````

Functional Programming means a function may return a function. To get an idea of what is going on behind the curtains - visualizing functions helps me.

``````lambda_factorial(4) ==
# lambda_factorial(4) => 4 * lambda_factorial(4-1)

4 * lambda_factorial(4-1) ==

4 * lambda_factorial(3) ==
# lambda_factorial(3) => 3 * lambda_factorial(3-1)

4 * 3 * lambda_factorial(3-1) ==

4 * 3 * lambda_factorial(2) ==

4 * 3 * 2 * lambda_factorial(2-1) ==

4 * 3 * 2 * lambda_factorial(1) == #(lambda_factorial(1) returns 1)

4 * 3 * 2 * 1
# => 24
``````