Python Recursion (Recursive Function) | Learn Python Programming

Python Recursion: In this tutorial, you will learn to make a recursive function (a function that calls itself).

In this article, you will learn-

1 What is recursion?
2 Python Recursive Function
3 Example of a recursive function
4 Advantages of Recursion
5 Disadvantages of Recursion

What is recursion?

Recursion is the process of defining something in terms of itself.

A physical world example is a place two equal mirrors confronting one another. Any article in the middle of them would be reflected recursively.

Python Recursive Function

In Python, we know that a function can call different functions. It is even feasible for the function to call itself. These kinds of build are named as recursive functions.
The following image shows the working of a recursive function called recurse.

Following is an example of a recursive function to find the factorial of an integer.

Factorial of a number is the product of all the integers from 1 to that number. For example, the factorial of 6 (denoted as 6!) is 1*2*3*4*5*6 = 720.

Example of a recursive function

def factorial(x):
    """This is a recursive function
    to find the factorial of an integer"""

    if x == 1:
        return 1
    else:
        return (x * factorial(x-1))


num = 3
print("The factorial of", num, "is", factorial(num))

Output

The factorial of 3 is 6

In the above example, factorial() is a recursive function as it calls itself.

When we call this function with a positive integer, it will recursively call itself by diminishing the number.

Each capacity duplicates the number with the factorial of the number beneath it until it is equivalent to one. This recursive call can be explained in the following steps.

factorial(3)          # 1st call with 3
3 * factorial(2)      # 2nd call with 2
3 * 2 * factorial(1)  # 3rd call with 1
3 * 2 * 1             # return from 3rd call as number=1
3 * 2                 # return from 2nd call
6                     # return from 1st call

Let’s look at an image that shows a step-by-step process of what is going on:

Our recursion closes when the number reduces to 1. This is known as the base condition.

Each recursive capacity must have a base condition that stops the recursion or, in all likelihood the capacity calls itself unendingly.

The Python mediator restricts the profundities of recursion to help maintain a strategic distance from limitless recursions, bringing about stack floods.

By default, the maximum depth of recursion is 1000. If the limit is crossed, it results in RecursionError. Let’s look at one such condition.

def recursor():
    recursor()
recursor()

Output

Traceback (most recent call last):
  File "<string>", line 3, in <module>
  File "<string>", line 2, in a
  File "<string>", line 2, in a
  File "<string>", line 2, in a
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded