How to make a recursive program run for a long time without getting RunTimeError in Python

Question

This code is the recursive factorial function.

The problem is that if I want to calculate a very large number, it generates this error: RuntimeError : maximum recursion depth exceeded

import time

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

print " The factorial of the number is: " , factorial (1500)

time.sleep (3600)

The goal is to do with the recursive function is a factor which can calculate maximum one hour.

Answer 1

Don't do that. There is an upper limit on how deep your recursion can get. Instead, do something like this:

def factorial(n):
    result = 1
    for i in range(1, n+1):
        result *= i
    return result

Any recursive function can be rewritten to an iterative function. If your code is fancier than this, show us the actual code and we'll help you rewrite it.

Answer 2

This is a really bad idea. Python is not at all well-suited for recursing that many times. I'd strongly recommend you switch this to a loop which checks a timer and stops when it reaches the limit.

But, if you're seriously interested in increasing the recursion limit in cython (the default depth is 1000), there's a sys setting for that, sys.setrecursionlimit. Note as it says in the documentation that "the highest possible limit is platform-dependent" - meaning there's no way to know when your program will fail. Nor is there any way you, I or cython could ever tell whether your program will recurse for something as irrelevant to the actual execution of your code as "an hour." (Just for fun, I tried this with a method that passes an int counting how many times its already recursed, and I got to 9755 before IDLE totally restarted itself.)

Here's an example of a way I think you should do this:

# be sure to import time
start_time = time.time()
counter = 1

# will execute for an hour
while time.time() < start_time + 3600:
    factorial(counter) # presumably you'd want to do something with the return value here
    counter += 1

You should also keep in mind that regardless of whether you use iteration or recursion, (unless you're using a separate thread) you're still going to be blocking the entire program for the entirety of the hour.

Answer 3

It is a guard against a stack overflow. You can change the recursion limit with sys.setrecursionlimit(newLimit)where newLimit is an integer.

Python isn't a functional language. Rewriting the algorithm iteratively, if possible, is generally a better idea.

Answer 4

Few things to note here:

You can increase recursion stack with:

import sys
sys.setrecursionlimit(someNumber) # may be 20000 or bigger.

Which will basically just increase your limit for recursion. Note that in order for it to run one hour, this number should be so unreasonably big, that it is mostly impossible. This is one of the problems with recursion and this is why people think about iterative programs.

So basically what you want is practically impossible and you would rather make it with a loop/while approach.

Moreover your sleep function does not do what you want. Sleep just forces you to wait additional time (frozing your program)