Python RecursionError: maximum recursion depth exceeded while calling a Python object

Posted in /  

Python RecursionError: maximum recursion depth exceeded while calling a Python object
vinaykhatri

Vinay Khatri
Last updated on May 22, 2024

    In programming, recursive functions are routines or methods that call themselves directly or indirectly. Python limits the number of times a recursion function can call itself. If the recursion function exceeds that limit, Python raises the error RecursionError: maximum recursion depth exceeded while calling a Python object .

    This tutorial will discuss the above error in detail and help you learn to debug and resolve it. We will also walk through an example to understand this error.

    So let's get started!

    Python RecursionError: Maximum Recursion Depth Exceeded while Calling a Python Object

    Recursion is a powerful technique to solve specific types of problems in programming. However, one must be very careful while dealing with recursive functions, as they may enter infinite loops.

    Every recursive function has a base case that acts as a terminating condition. When a function meets the base case, it stops calling itself and returns the value back.

    However, if the base case is not defined correctly or the recursive logic is incorrect, the function may end up calling itself infinitely. This means the function continues calling itself without any termination condition.

    Calling any function occupies space in the memory. And calling a function inside a function for infinite times can occupy almost every part of your computer memory. To tackle this problem, Python has implemented a Recursion Depth limit.

    According to the Python recursion depth limit, by default, a recursion function can all itself only 1000 times. If the recursion exceeds this limit, the interpreter throws the error RecursionError: maximum recursion depth exceeded while calling a Python object .

    To know the default Recursion limit for your program, you can use the getrecursionlimit() method from the Python sys modules.

    Example

    import sys
    
    print("This default recursion limit is :", sys.getrecursionlimit())

    Output

    This default recursion limit is : 1000
    

    If we look at the recursion error statement, we can divide it into two parts

    1. RecursionError
    2. maximum recursion depth exceeded while calling a Python object

    1. RecursionError

    RecursionError is one of the Python standard exceptions. It is a module exception that comes under the Python RuntimeError. Python raises this exception when it detects a maximum recursion depth in a program.

    2. maximum recursion depth exceeded while calling a Python object

    The " maximum recursion depth exceeded while calling a Python object " statement is the error message that tags along with the RecursionError exception. This error message tells us that a Python function has exceeded the number of recursion calls.

    Common Example Scenario

    Let us write a Python program using recursion that prints the nth number from a Fibonacci series. You can even write this program using the for loop.

    In the Fibonacci series , the first two numbers are 0 and 1; the following numbers are calculated with the sum of the previous two numbers.

    Program

    # recursive function to find the nth Fibonacci number
    def n_fibonacci(n):
        if n==0:
            return 0
        elif n==1:
            return 1
        else:
            return n_fibonacci(n-1)+n_fibonacci(n-2)
    #
    n=10
    
    print(f"The {n} st/nd/th Fibonacci number is: ",n_fibonacci(n-1))

    Output

    The 10 st/nd/th Fibonacci number is: 34

    The above program is correct, and it also shows the correct output. But if we change the value of n=10 to n=1005 , it will raise the error.

    Program

    # recursive function to find the nth Fibonacci number
    def n_fibonacci(n):
        if n==0:
            return 0
        elif n==1:
            return 1
        else:
            return n_fibonacci(n-1)+n_fibonacci(n-2)
    #out of the recursion range
    n=1005
    
    print(f"The {n}st/nd/th Fibonacci number is: ",n_fibonacci(n-1))

    Output

    RecursionError: maximum recursion depth exceeded in comparison

    You can see that we receive the RecursionError with a different Error message. This is because the error message changes according to the operation we perform inside the function.

    Here, it displays " maximum recursion depth exceeded in comparison ". This is because after exceeding the recursion limit, the Python interpreter can also not perform the comparison operator inside the recursion.

    Solution

    Python provides a setrecursionlimit() method that accepts an integer value as an argument and sets it as a recursion limit for the program. We can use this method to increase the default recursion depth limit.

    Note: The setrecursionlimit() method is also limited and can only increase the recursion limit depth to 3500.

    To solve the above example, we can increase the recursion limit to 2000 using the setrecursionlimit() method.

    Example

    import sys
    # increase the recursion limit
    sys.setrecursionlimit(2000)
    
    # recursive function to find the nth fibonacci number
    def n_fibonacci(n):
        if n==0:
            return 0
        elif n==1:
            return 1
        else:
            return n_fibonacci(n-1)+n_fibonacci(n-2)
    #now in recursion range
    n=1005
    
    print(f"the {n}st/nd/th fibonacci number is: ",n_fibonacci(n-1))

    Output

    the 1005 st/nd/th fibonacci number is: 482051511617926448416241857411039626258600330733909004920469712704382351844831823569922886993050824175326520025449797859766560885196970738202943545195859929088936259370887605815413541849563887924611727164704130

    Executing the above program may take 10 to 20 minutes to finish because it calls the function repeatedly 2000 times.

    Wrapping Up!

    The RecursionError occurs when a recursion call exceeds the default recursion depth limit. When you encounter this error in your Python program, you must consider using an iterative approach to solve the problem. Using iterative statements like for and while loop, we can perform the desired action quickly and efficiently.

    However, if you wish to solve your problem recursively, in that case, you can use them setrecursivelimit() to increase the default limit of the recursion call.

    If you still get this error in your Python program, you can share your code in the comment section. We will try to help you with debugging.

    People are also reading:

    Leave a Comment on this Post

    0 Comments