Python Recursive Function

In this section, you will learn Python recursive function.

What is Python Recursive Function

A recursive function is a function that calls itself and this process is called function recursion.

For example, let’s calculate the factorial of a number, for example, 6.

6 * 5 * 4 * 3 * 2 * 1

In the following code, a recursive function is created which finds the factorial of a number:

def fact(n):
    """Recursive function to find factorial"""
    if n == 1:
        return 1
    else:
        return (n * fact(n - 1))
a = 6
print("Factorial of", a, "=", fact(a))
Factorial of 6 = 720

The function fact(n) is a recursive function. The fact function calls itself with argument n-1 till the number becomes 1 and this is how factorial is calculated, that is multiplying the number by the factorial of one less than the number.

In this recursive function, there is a base condition that is when the number becomes 1, 1 is returned and in this way recursive call becomes finite.

When creating a recursive function, there must be a base condition to end that recursive call.

Limitation of Recursion:

As you have noticed, every time when the function calls itself, it needs some memory to store some intermediate values. Therefore recursive function consumes much more memory than a normal non-recursive function. Python sets the recursion calls limitation to 1000.

>>> import sys
>>> sys.getrecursionlimit()
1000

It raises a RecursionError if recursion exceeds 1000.

def fact(n):
    """Recursive function to find factorial"""
    if n == 1:
        return 1
    else:
        return (n * fact(n - 1))
    
print(fact(2000))
Traceback (most recent call last):
  File "<pyshell#2>", line 1, in <module>
    print(factorial(3000))
  File "<pyshell#1>", line 5, in factorial
    return n * factorial(n-1)
  File "<pyshell#1>", line 5, in factorial
    return n * factorial(n-1)
  File "<pyshell#1>", line 5, in factorial
    return n * factorial(n-1)
  [Previous line repeated 989 more times]
  File "<pyshell#1>", line 2, in factorial
    if n == 1:
RecursionError: maximum recursion depth exceeded in comparison

Solution to Remove Recursion Limitation

You could solve the recursion limitation by setting the recursion limitation to a number larger than the required recursion.

import sys
sys.setrecursionlimit(3000)
def fact(n):
    """Recursive function to find factorial"""
    if n == 1:
        return 1
    else:
        return (n * fact(n - 1))
    
print(fact(2000))

Advantage of Recursion:

  • Using recursive functions, the problem can be divided into sub problem which can be solved easily.
  • The code becomes neat and clean.

Disadvantage of Recursion:

  • It is sometimes difficult to follow through the logic of recursive function.
  • To solve each sub problem will take a lot of time so recursive functions are inefficient.