Maximum recursion depth exceeded while calling a python object как исправить

A Recursive function in programming is a function which calls itself. These functions find applications while constructing programs for factorial, Fibonacci series, Armstrong numbers, etc. The main idea is to break larger programs into smaller, less complex problems. With recursive functions, generating sequences becomes easy. But while using recursive functions, recursionerror may occur in python. In this article, we shall be looking into one such recursionerror: maximum recursion depth exceeded while calling a Python object

What is recursionerror?

As the name suggests, Recursionerror may occur when we are dealing with recursive functions. When we run the recursion function for a large number of times, recursion error is thrown. Python has a limit on the number of times a recursive function can call itself. This is done to ensure that the function does not execute infinitely and stops after some number of iterations. To know the recursion limit in python, we use the following code:

import sys
print(sys.getrecursionlimit())

The output is:

1000

Let us look at an example of RecursionError: maximum recursion depth exceeded. We shall take an example of a factorial function.

The following code shall generate factorial for a given number.

def find_fact(n):
  if n == 0 or n == 1:
    return 1
  else :
    return (n*find_fact(n-1))  

print("Factorial is :", find_fact(5))

Here, this program shall be executed successfully and shall print the below output:

Factorial is : 120

But if we pass a larger number into the find_fact() function, it will throw RecursionError: Maximum Recursion Depth Exceeded error.

print("Factorial is :", find_fact(5000))

Output:

RecursionError: maximum recursion depth exceeded in comparison

Since the recursion function exceeded the limit of 1000 iterations, recursionerror is thrown.

The RecursionError: Maximum Recursion Depth Exceeded error may also be thrown while we are trying to create a nested list whose length exceeds the recursion limit.

Let us take the following example. We have created a function named nested() which accepts one argument – n. Depending on the value of n, the length of that nested list would be created. Let us try to pass a value n greater than the recursion limit.

def nested(n): 
    list1 = list2 = [] 
    for i in range(n): 
        list1.append([])
        list1 = list1[0] 
    return list2

nestedlist = nested(2000)
print(nestedlist)

The output will be a recursion error.

RecursionError: maximum recursion depth exceeded while getting the repr of an object

RecursionError: Maximum Recursion Depth Exceeded While Calling A Python Object

The recursionerror for Maximum Recursion Depth Exceeded While Calling A Python Object is thrown when we are trying to call a python object in Django. The error may also occur while using Flask.

When the interpreter detects that the maximum depth for recursion has reached, it throws the recursionerror. To prevent the stack from getting overflow, python raises the recursionerror.

Best practices to avoid RecursionError: Maximum Recursion Depth Exceeded while calling a Python Object

1. Using other loops instead of recursion

To prevent the error from occurring, we can simply convert the piece of code from recursion to a loop statement.

If we take the example of the factorial function, we can convert it into a non – recursive function. We do that by placing a for loop inside the recursion function. The for loop will execute for a length equal to the value of the factorial number.

def find_fact(n):
  mul = 1
  for i in range(2,n+1):
    mul = mul * i
  return mul

print("Factorial is :", find_fact(1500))

Now, it will not throw any recursion error and simply print the large factorial number.

2. Using sys.setrecursionlimit() function

Else, if we still want to use the recursion function, we can increase the recursion limit from 1000 to a higher number. For that, we have to first import the sys library. Using the sys library, we will use the sys.setrecursionlimit() function.

import sys
sys.setrecursionlimit(2000)

Now, it will not thrown the recursionerror and the program will be executed for larger amount of recursions. On executing the recursive function, it will not throw any error and print its output.

def find_fact(n):
  if n == 0 or n == 1:
    return 1
  else :
    return (n*find_fact(n-1))  

print("Factorial is :", find_fact(1500))

3. Setting boundary conditions

It is necessary to set boundary conditions to ensures that the recursive function comes to an end. In the factorial program, the condition :

'if n == 1 or n == 0 : return 1'

is the boundary condition. It is with this condition that the loop comes to an end.

4. Creating a converging recursion

While writing the recursion condition, one has to ensure that the condition does come to an end and does not continue infinitely. The recursive calls should eventually tend towards the boundary condition.

We have to ensure that we creating a converging condition for that. In the factorial program, the ‘n*fact(n-1)’ is a converging condition that converges the value from n to 1.

5. Using Memoization

We can also use memoization to reduce the computing time of already calculated values. This way, we can speed up the calculations by remembering past calculations.

When recursive calls are made, then with memoization we can store the previously calculated values instead of unnecessarily calculating them again.

That sums up the article on RecursionError: Maximum Recursion Depth Exceeded While Calling A Python Object. If you have any questions in your mind, don’t forget to let us know in the comments below.

Until next time, Keep Learning!

You might have seen a Python recursion error when running your Python code. Why does this happen? Is there a way to fix this error?

A Python RecursionError exception is raised when the execution of your program exceeds the recursion limit of the Python interpreter. Two ways to address this exception are increasing the Python recursion limit or refactoring your code using iteration instead of recursion.

Let’s go through some examples so you can understand how this works.

The recursion begins!

Let’s create a program to calculate the factorial of a number following the formula below:

n! = n * (n-1) * (n-2) * ... * 1

Write a function called factorial and then use print statements to print the value of the factorial for a few numbers.

def factorial(n):
    if n == 0:
        return 1
    else:
        return n*factorial(n-1) 

This is a recursive function…

A recursive function is a function that calls itself. Recursion is not specific to Python, it’s a concept common to most programming languages.

You can see that in the else statement of the if else we call the factorial function passing n-1 as parameter.

The execution of the function continues until n is equal to 0.

Let’s see what happens when we calculate the factorial for two small numbers:

if __name__ == '__main__': 
    print("The factorial of 4 is: {}".format(factorial(4)))
    print("The factorial of 5 is: {}".format(factorial(5)))

[output]
The factorial of 4 is: 24
The factorial of 5 is: 120 

After checking that __name__ is equal to ‘__main__’ we print the factorial for two numbers.

It’s all good.

But, here is what happens if we calculate the factorial of 1000…

print("The factorial of 1000 is: {}".format(factorial(1000)))

[output]
Traceback (most recent call last):
  File "recursion_error.py", line 9, in <module>
    print("The factorial of 1000 is: {}".format(factorial(1000)))
  File "recursion_error.py", line 5, in factorial
    return n*factorial(n-1)
  File "recursion_error.py", line 5, in factorial
    return n*factorial(n-1)
  File "recursion_error.py", line 5, in factorial
    return n*factorial(n-1)
  [Previous line repeated 995 more times]
  File "recursion_error.py", line 2, in factorial
    if n <= 1:
RecursionError: maximum recursion depth exceeded in comparison 

The RecursionError occurs because the Python interpreter has exceeded the recursion limit allowed.

The reason why the Python interpreter limits the number of times recursion can be performed is to avoid infinite recursion and hence avoid a stack overflow.

Let’s have a look at how to find out what the recursion limit is in Python and how to update it.

What is the Recursion Limit in Python?

Open the Python shell and use the following code to see the value of the recursion limit for the Python interpreter:

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

Interesting…the limit is 1000.

To increase the recursion limit to 1500 we can add the following lines at the beginning of our program:

import sys
sys.setrecursionlimit(1500)

If you do that and try to calculate again the factorial of 1000 you get a long number back (no more errors).

The factorial of 1000 is: 4023872600770937735437024339230039857193748642107146325437999104299385123986290205920
.......835777939410970027753472000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

That’s good! But…

…this solution could work if like in this case we are very near to the recursion limit and we are pretty confident that our program won’t end up using too much memory on our system.

How to Catch a Python Recursion Error

One possible option to handle the RecursionError exception is by using try except.

It allows to provide a clean message when your application is executed instead of showing an unclear and verbose exception.

Modify the “main” of your program as follows:

if __name__ == '__main__':
    try:
        print("The factorial of 1000 is: {}".format(factorial(1000)))
    except RecursionError as re:
        print("Unable to calculate factorial. Number is too big.") 

Note: before executing the program remember to comment the line we have added in the section before that increases the recursion limit for the Python interpreter.

Now, execute the code…

You will get the following when calculating the factorial for 1000.

$ python recursion_error.py
Unable to calculate factorial. Number is too big. 

Definitely a lot cleaner than the long exception traceback.

Interestingly, if we run our program with Python 2.7 the output is different:

$ python2 recursion_error.py 
Traceback (most recent call last):
  File "recursion_error.py", line 13, in <module>
    except RecursionError as re:
NameError: name 'RecursionError' is not defined 

We get back a NameError exception because the exception of type RecursionError is not defined.

Looking at the Python documentation I can see that the error is caused by the fact that the RecursionError exception was only introduced in Python 3.5:

So, if you are using a version of Python older than 3.5 replace the RecursionError with a RuntimeError.

if __name__ == '__main__':
    try:
        print("The factorial of 1000 is: {}".format(factorial(1000)))
    except RuntimeError as re:
        print("Unable to calculate factorial. Number is too big.") 

In this way our Python application works fine with Python2:

$ python2 recursion_error.py
Unable to calculate factorial. Number is too big. 

How Do You Stop Infinite Recursion in Python?

As we have seen so far, the use of recursion in Python can lead to a recursion error.

How can you prevent infinite recursion from happening? Is that even something we have to worry about in Python?

Firstly, do you think the code we have written to calculate the factorial could cause an infinite recursion?

Let’s look at the function again…

def factorial(n):
    if n == 0:
        return 1
    else:
        return n*factorial(n-1) 

This function cannot cause infinite recursion because the if branch doesn’t make a recursive call. This means that the execution of our function eventually stops.

We will create a very simple recursive function that doesn’t have an branch breaking the recursion…

def recursive_func():
    recursive_func()

recursive_func() 

When you run this program you get back “RecursionError: maximum recursion depth exceeded”.

$ python recursion_error2.py
Traceback (most recent call last):
  File "recursion_error2.py", line 4, in <module>
    recursive_func()
  File "recursion_error2.py", line 2, in recursive_func
    recursive_func()
  File "recursion_error2.py", line 2, in recursive_func
    recursive_func()
  File "recursion_error2.py", line 2, in recursive_func
    recursive_func()
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded

So, in theory this program could have caused infinite recursion, in practice this didn’t happen because the recursion depth limit set by the Python interpreter prevents infinite recursion from occurring.

How to Convert a Python Recursion to an Iterative Approach

Using recursion is not the only option possible. An alternative to solve the RecursionError is to use a Python while loop.

We are basically going from recursion to iteration.

def factorial(n):
    factorial = 1

    while n > 0:
        factorial = factorial*n
        n = n - 1

    return factorial

Firstly we set the value of the factorial to 1 and then at each iteration of the while loop we:

• Multiply the latest value of the factorial by n
• Decrease n by 1

The execution of the while loop continues as long as n is greater than 0.

I want to make sure that this implementation of the factorial returns the same results as the implementation that uses recursion.

So, let’s define a Python list that contains a few numbers. Then we will calculate the factorial of each number using both functions and compare the results.

We use a Python for loop to go through each number in the list.

Our program ends as soon as the factorials calculated by the two functions for a given number don’t match.

def factorial(n):
    factorial = 1

    while n > 0:
        factorial = factorial*n
        n = n - 1

    return factorial

def recursive_factorial(n):
    if n == 0:
        return 1
    else:
        return n*factorial(n-1)

numbers = [4, 9, 18, 23, 34, 56, 78, 88, 91, 1000] 

for number in numbers:
    if factorial(number) != recursive_factorial(number):
        print("ERROR: The factorials calculated by the two functions for the number {} do not match.".format(number))

print("SUCCESS: The factorials calculated by the two functions match") 

Let’s run our program and see what we get:

$ python factorial.py
SUCCESS: The factorials calculated by the two functions match 

Great!

Our implementation of the factorial using an iterative approach works well.

Conclusion

In this tutorial we have seen why the RecursionError occurs in Python and how you can fix it.

Two options you have are:

• Increase the value of the recursion limit for the Python interpreter.
• Use iteration instead of recursion.

Which one are you going to use?

Sign Up for Our Newsletters

Subscribe to get notified of the latest articles. We will never spam you. Be a part of our ever-growing community.

By checking this box, you confirm that you have read and are agreeing to our terms of use regarding the storage of the data submitted through this form.

In Python, there is an upper limit to the number of recursions (the maximum number of recursions). To execute a recursive function with a large number of calls, it is necessary to change the limit. Use the functions in the sys module of the standard library.

The number of recursions is also limited by the stack size. In some environments, the resource module of the standard library can be used to change the maximum stack size (it worked on Ubuntu, but not on Windows or mac).

The following information is provided here.

• Get the upper limit of the current number of recursions:sys.getrecursionlimit()
• Change the upper limit of the number of recursions:sys.setrecursionlimit()
• Change the maximum size of the stack:resource.setrlimit()

The sample code is running on Ubuntu.

Get the current recursion limit: sys.getrecursionlimit()

The current recursion limit can be obtained with sys.getrecursionlimit().

• sys.getrecursionlimit() — System-specific parameters and functions — Python 3.10.0 Documentation

import sys
import resource

print(sys.getrecursionlimit())
# 1000

In the example, the maximum number of recursions is 1000, which may vary depending on your environment. Note that the resource we are importing here will be used later, but not on Windows.

As an example, we will use the following simple recursive function. If a positive integer n is specified as an argument, the number of calls will be n times.

def recu_test(n):
    if n == 1:
        print('Finish')
        return
    recu_test(n - 1)

An error (RecursionError) will be raised if you try to perform recursion more than the upper limit.

recu_test(950)
# Finish

# recu_test(1500)
# RecursionError: maximum recursion depth exceeded in comparison

Note that the value obtained by sys.getrecursionlimit() is not strictly the maximum number of recursions, but the maximum stack depth of the Python interpreter, so even if the number of recursions is slightly less than this value, an error (RecursionError) will be raised.

再帰限界は、再帰の限界ではなく、pythonインタープリタのスタックの最大深度です。
python – Max recursion is not exactly what sys.getrecursionlimit() claims. How come? – Stack Overflow

# recu_test(995)
# RecursionError: maximum recursion depth exceeded while calling a Python object

Change recursion limit: sys.setrecursionlimit()

The upper limit of the number of recursions can be changed by sys.setrecursionlimit(). The upper limit is specified as an argument.

• sys.setrecursionlimit() — System-specific parameters and functions — Python 3.10.0 Documentation

Allows deeper recursion to be performed.

sys.setrecursionlimit(2000)

print(sys.getrecursionlimit())
# 2000

recu_test(1500)
# Finish

If the specified upper limit is too small or too large, an error will occur. This constraint (upper and lower limits of the limit itself) varies depending on the environment.

The maximum value of limit depends on the platform. If you need deep recursion, you can specify a larger value within the range supported by the platform, but be aware that this value will cause a crash if it is too large.
If the new limit is too low at the current recursion depth, a RecursionError exception is raised.
sys.setrecursionlimit() — System-specific parameters and functions — Python 3.10.0 Documentation

sys.setrecursionlimit(4)
print(sys.getrecursionlimit())
# 4

# sys.setrecursionlimit(3)
# RecursionError: cannot set the recursion limit to 3 at the recursion depth 1: the limit is too low

sys.setrecursionlimit(10 ** 9)
print(sys.getrecursionlimit())
# 1000000000

# sys.setrecursionlimit(10 ** 10)
# OverflowError: signed integer is greater than maximum

The maximum number of recursions is also limited by the stack size, as explained next.

Change the maximum size of the stack: resource.setrlimit()

Even if a large value is set in sys.setrecursionlimit(), it may not be executed if the number of recursions is large. A segmentation fault occurs as follows.

sys.setrecursionlimit(10 ** 9)
print(sys.getrecursionlimit())
# 1000000000

recu_test(10 ** 4)
# Finish

# recu_test(10 ** 5)
# Segmentation fault

In Python, the resource module in the standard library can be used to change the maximum stack size. However, the resource module is a Unix-specific module and cannot be used on Windows.

• Unix Specific Services — Python 3.10.0 Documentation
• resource — Resource usage information — Python 3.10.0 Documentation

With resource.getrlimit(), you can get the limit of the resource specified in the argument as a tuple of (soft limit, hard limit). Here, we specify resource.RLIMIT_STACK as the resource, which represents the maximum size of the call stack of the current process.

• resource.getrlimit() — Resource usage information — Python 3.10.0 Documentation
• resource.RLIMIT_STACK — Resource usage information — Python 3.10.0 Documentation

print(resource.getrlimit(resource.RLIMIT_STACK))
# (8388608, -1)

In the example, the soft limit is 8388608 (8388608 B = 8192 KB = 8 MB) and the hard limit is -1 (unlimited).

You can change the limit of the resource with resource.setrlimit(). Here, the soft limit is also set to -1 (no limit). You can also use the constant resource.RLIM_INFINIT to represent the unlimited limit.

• resource.setrlimit() — Resource usage information — Python 3.10.0 Documentation

Deep recursion, which could not be performed due to segmentation fault before the stack size change, can now be performed.

resource.setrlimit(resource.RLIMIT_STACK, (-1, -1))

print(resource.getrlimit(resource.RLIMIT_STACK))
# (-1, -1)

recu_test(10 ** 5)
# Finish

Here, the soft limit is set to -1 (no limit) for a simple experiment, but in reality, it would be safer to limit it to an appropriate value.

In addition, when I tried to set an unlimited soft limit on my mac as well, the following error occurred.ValueError: not allowed to raise maximum limit
Running the script with sudo didn’t help. It may be restricted by the system.

A process with the effective UID of a superuser can request any reasonable limit, including no limit.
However, a request that exceeds the limit imposed by the system will still result in a ValueError.
resource.setrlimit() — Resource usage information — Python 3.10.0 Documentation

Windows doesn’t have a resource module, and mac couldn’t change the maximum stack size due to system limitations. If we can increase the stack size by some means, we should be able to solve the segmentation fault, but we have not been able to confirm this.

Recursive functions, without limits, could call themselves indefinitely. If you write a recursive function that executes over a certain number of iterations, you’ll encounter the “maximum recursion depth exceeded in comparison” Python error.

This guide discusses what this error means and why it is important. We’ll walk through an example of this error so you can learn how to fix it in your program.

maximum recursion depth exceeded in comparison

Recursive functions are functions that call themselves to find a solution to a program.

Well-written recursive functions include limits to ensure they do not execute infinitely. This may mean that a function should only run until a particular condition is met.

If you write a recursive function that executes more than a particular number of iterations (usually 997), you’ll see an error when you get to the next iteration.

This is because Python limits the depth of a recursion algorithm. This refers to how many times the function can call itself.

You can view the recursion limit in your Python shell using this code:

import sys
print(sys.getrecursionlimit())

An Example Scenario

Let’s write a recursive function that calculates a number in the Fibonacci Sequence. In the Fibonacci Sequence, the next number in the sequence is the sum of the last two numbers. The first two numbers in the sequence are 0 and 1.

Here is a recursive function that calculates the Fibonacci Sequence:

def fibonacci(n):
	if n <= 1:
		return n
	else:
		return(fibonacci(n-1) + fibonacci(n-2))

If the number we specify is less than or equal to 1, that number is returned. Otherwise, our program calculates the next number in the sequence.

Next, we’re going to call our function:

print(fibonacci(5000))


This code calculates the number after the 5,000th number in the Fibonacci Sequence. Let’s run our code and see what happens:

Traceback (most recent call last):
  File "main.py", line 7, in <module>
	print(recur_fibo(5000))
  File "main.py", line 5, in recur_fibo
	return(recur_fibo(n-1) + recur_fibo(n-2))
… 
  File "main.py", line 2, in recur_fibo
	if n <= 1:
RecursionError: maximum recursion depth exceeded in comparison

Our code returns a long error message. This message has been shortened for brevity.

The Solution

Python has raised a recursion error to protect us against a stack overflow. This is when the pointer in a stack exceeds the stack bound. Without this error, our program would try to use more memory space than was available.

We can fix this error by either making our sequence iterative, or by increasing the recursion limit in our program.

Solution #1: Use an Iterative Algorithm

We can change our program to use an iterative approach instead of a recursive approach:

to_calculate = 5
i = 0
next = 1
current = 1
last = 0

while i < to_calculate:
	next = current + last
	current = last
	last = next
	i += 1

This code calculates the first five numbers in the Fibonacci Sequence. We could increase the number of values we calculate but that would also increase the time it takes for our program to execute. Our program returns:

1

1

2

3

5

This approach bypasses the recursion error because we do not use recursive functions. Instead, we use a while loop to calculate the next number in the list.

Solution #2: Increase Recursion Limit

You can override the default recursion limit Python sets using the setrecursionlimit() method:

import sys
sys.setrecursionlimit(5000)

This code sets the maximum recursion depth to 5,000. You should be careful when you use this method because it may cause a stack overflow depending on the resources available to the Python interpreter.

In general, it is best to rewrite a function to use an iterative approach instead of increasing the recursion limit.

Conclusion

The “maximum recursion depth exceeded in comparison” error is raised when you try to execute a function that exceeds Python’s built in recursion limit. You can fix this error by rewriting your program to use an iterative approach or by increasing the recursion limit in Python.

Now you have the knowledge you need to fix this error like a pro!