如果你经常需要改变递归限制(例如在解决编程难题时)，你可以定义一个简单的上下文管理器，像这样:

import sys

class recursionlimit:
    def __init__(self, limit):
        self.limit = limit

    def __enter__(self):
        self.old_limit = sys.getrecursionlimit()
        sys.setrecursionlimit(self.limit)

    def __exit__(self, type, value, tb):
        sys.setrecursionlimit(self.old_limit)

然后调用具有自定义限制的函数，您可以这样做:

with recursionlimit(1500):
    print(fib(1000, 0))

从with语句体退出时，递归限制将恢复到默认值。

附注:您可能还想增加Python进程的堆栈大小，以获得较大的递归限制值。例如，这可以通过ulimit shell内置或limits.conf(5)文件来完成。

import sys
sys.setrecursionlimit(1500)

def fib(n, sum):
    if n < 1:
        return sum
    else:
        return fib(n-1, sum+n)

c = 998
print(fib(c, 0))

我有一个类似的问题，错误“最大递归深度超过”。我发现这个错误是由我用os.walk循环遍历的目录中的一个损坏文件触发的。如果您在解决这个问题时遇到了困难，并且您正在使用文件路径，请务必缩小范围，因为它可能是一个损坏的文件。

我想给你一个使用内存计算斐波那契的例子，因为这将允许你使用递归计算更大的数字:

cache = {}
def fib_dp(n):
    if n in cache:
        return cache[n]
    if n == 0: return 0
    elif n == 1: return 1
    else:
        value = fib_dp(n-1) + fib_dp(n-2)
    cache[n] = value
    return value

print(fib_dp(998))

这仍然是递归的，但是使用了一个简单的哈希表，允许重用以前计算的斐波那契数，而不是重新计算。

我们还可以使用一种自底向上的动态规划方法

def fib_bottom_up(n):

    bottom_up = [None] * (n+1)
    bottom_up[0] = 1
    bottom_up[1] = 1

    for i in range(2, n+1):
        bottom_up[i] = bottom_up[i-1] + bottom_up[i-2]

    return bottom_up[n]

print(fib_bottom_up(20000))

正如@alex所建议的，您可以使用生成器函数按顺序而不是递归地完成此操作。

这里是你问题中的等效代码:

def fib(n):
    def fibseq(n):
        """ Iteratively return the first n Fibonacci numbers, starting from 0. """
        a, b = 0, 1
        for _ in xrange(n):
            yield a
            a, b = b, a + b

    return sum(v for v in fibseq(n))

print format(fib(100000), ',d')  # -> no recursion depth error