Quelle est la profondeur de récursivité maximale en Python et comment l'augmenter?

J'ai cette fonction récursive de queue ici:

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

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

Ça marche n=997, puis ça casse et crache a RecursionError: maximum recursion depth exceeded in comparison. Est-ce juste un débordement de pile? Y a-t-il un moyen de le contourner?

C'est une protection contre un débordement de pile, oui. Python (ou plutôt, l'implémentation CPython) n'optimise pas la récursivité de queue, et la récursion débridée provoque des débordements de pile. Vous pouvez vérifier la limite de récursivité avec sys.getrecursionlimitet modifier la limite de récursivité avec sys.setrecursionlimit, mais cela est dangereux - la limite standard est un peu conservatrice, mais les stackframes Python peuvent être assez gros.

Python n'est pas un langage fonctionnel et la récursivité de la queue n'est pas une technique particulièrement efficace. La réécriture itérative de l'algorithme, si possible, est généralement une meilleure idée.

Il semble que vous ayez juste besoin de définir une profondeur de récursivité plus élevée :

import sys
sys.setrecursionlimit(1500)

C'est pour éviter un débordement de pile. L'interpréteur Python limite les profondeurs de récursivité pour vous aider à éviter les récursions infinies, entraînant des débordements de pile. Essayez d'augmenter la limite de récursivité ( sys.setrecursionlimit) ou de réécrire votre code sans récursivité.

Dans la documentation Python :

sys.getrecursionlimit()

Renvoie la valeur actuelle de la limite de récursivité, la profondeur maximale de la pile d'interpréteur Python. Cette limite empêche une récursion infinie de provoquer un débordement de la pile C et de planter Python. Il peut être réglé par setrecursionlimit().

Si vous devez souvent modifier la limite de récursivité (par exemple lors de la résolution d'énigmes de programmation), vous pouvez définir un gestionnaire de contexte simple comme celui-ci:

import sys

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

    def __enter__(self):
        sys.setrecursionlimit(self.limit)

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

Ensuite, pour appeler une fonction avec une limite personnalisée, vous pouvez faire:

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

À la sortie du corps de l' withinstruction, la limite de récursivité sera restaurée à la valeur par défaut.

Utilisez un langage qui garantit l'optimisation des appels de queue. Ou utilisez l'itération. Alternativement, soyez mignon avec des décorateurs .

resource.setrlimit doit également être utilisé pour augmenter la taille de la pile et éviter les erreurs de segmentation

Le noyau Linux limite la pile de processus .

Python stocke des variables locales sur la pile de l'interpréteur, et donc la récursivité occupe l'espace de pile de l'interpréteur.

Si l'interpréteur Python essaie de dépasser la limite de pile, le noyau Linux lui fait un défaut de segmentation.

La taille limite de pile est contrôlée avec les appels système getrlimitet setrlimit.

Python offre un accès à ces appels système via le resourcemodule.

import resource
import sys

print resource.getrlimit(resource.RLIMIT_STACK)
print sys.getrecursionlimit()
print

# Will segfault without this line.
resource.setrlimit(resource.RLIMIT_STACK, [0x10000000, resource.RLIM_INFINITY])
sys.setrecursionlimit(0x100000)

def f(i):
    print i
    sys.stdout.flush()
    f(i + 1)
f(0)

Bien sûr, si vous continuez à augmenter ulimit, votre RAM s'épuisera, ce qui ralentira votre ordinateur à l'arrêt en raison de la folie des échanges, ou tuera Python via OOM Killer.

Depuis bash, vous pouvez voir et définir la limite de pile (en Ko) avec:

ulimit -s
ulimit -s 10000

La valeur par défaut pour moi est de 8 Mo.

Voir également:

• Définition de stacksize dans un script python
• Quelle est la limite de récursivité stricte pour Linux, Mac et Windows?

Testé sur Ubuntu 16.10, Python 2.7.12.

Je me rends compte que c'est une vieille question mais pour ceux qui lisent, je recommanderais de ne pas utiliser la récursivité pour des problèmes comme celui-ci - les listes sont beaucoup plus rapides et évitent complètement la récursivité. Je mettrais cela en œuvre comme:

def fibonacci(n):
    f = [0,1,1]
    for i in xrange(3,n):
        f.append(f[i-1] + f[i-2])
    return 'The %.0fth fibonacci number is: %.0f' % (n,f[-1])

(Utilisez n + 1 dans xrange si vous commencez à compter votre séquence fibonacci à partir de 0 au lieu de 1.)

Bien sûr, les nombres de Fibonacci peuvent être calculés en O (n) en appliquant la formule de Binet:

from math import floor, sqrt

def fib(n):                                                     
    return int(floor(((1+sqrt(5))**n-(1-sqrt(5))**n)/(2**n*sqrt(5))+0.5))

Comme les commentateurs le notent, ce n'est pas O (1) mais O (n) à cause de 2**n. Une différence est également que vous n'obtenez qu'une seule valeur, tandis qu'avec la récursivité, vous obtenez toutes les valeurs Fibonacci(n)jusqu'à cette valeur.

J'ai eu un problème similaire avec l'erreur "Profondeur de récursivité maximale dépassée". J'ai découvert que l'erreur était déclenchée par un fichier corrompu dans le répertoire avec lequel je faisais une boucle os.walk. Si vous rencontrez des problèmes pour résoudre ce problème et que vous travaillez avec des chemins de fichier, assurez-vous de le réduire, car il peut s'agir d'un fichier corrompu.

Si vous ne souhaitez obtenir que quelques nombres de Fibonacci, vous pouvez utiliser la méthode matricielle.

from numpy import matrix

def fib(n):
    return (matrix('0 1; 1 1', dtype='object') ** n).item(1)

C'est rapide car numpy utilise un algorithme d'exponentiation rapide. Vous obtenez la réponse en O (log n). Et c'est mieux que la formule de Binet car elle n'utilise que des entiers. Mais si vous voulez tous les nombres de Fibonacci jusqu'à n, alors il vaut mieux le faire par mémorisation.

Utilisez des générateurs?

def fib():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

fibs = fib() #seems to be the only way to get the following line to work is to
             #assign the infinite generator to a variable

f = [fibs.next() for x in xrange(1001)]

for num in f:
        print num

ci-dessus fonction fib () adaptée de: http://intermediatepythonista.com/python-generators

Comme l'a suggéré @alex , vous pouvez utiliser une fonction de générateur pour le faire de manière séquentielle plutôt que récursive.

Voici l'équivalent du code dans votre question:

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

Beaucoup recommandent que l'augmentation de la limite de récursivité soit une bonne solution mais ce n'est pas parce qu'il y aura toujours une limite. Utilisez plutôt une solution itérative.

def fib(n):
    a,b = 1,1
    for i in range(n-1):
        a,b = b,a+b
    return a
print fib(5)

Je voulais vous donner un exemple d'utilisation de la mémorisation pour calculer Fibonacci car cela vous permettra de calculer des nombres beaucoup plus importants en utilisant la récursivité:

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))

C'est encore récursif, mais utilise une table de hachage simple qui permet la réutilisation des nombres de Fibonacci précédemment calculés au lieu de les refaire.

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))

Nous pouvons le faire en utilisant le @lru_cachedécorateur et la setrecursionlimit()méthode:

import sys
from functools import lru_cache

sys.setrecursionlimit(15000)


@lru_cache(128)
def fib(n: int) -> int:
    if n == 0:
        return 0
    if n == 1:
        return 1

    return fib(n - 2) + fib(n - 1)


print(fib(14000))

Production

3002468761178461090995494179715025648692747937490792943468375429502230242942284835863402333575216217865811638730389352239181342307756720414619391217798542575996541081060501905302157019002614964717310808809478675602711440361241500732699145834377856326394037071666274321657305320804055307021019793251762830816701587386994888032362232198219843549865275880699612359275125243457132496772854886508703396643365042454333009802006384286859581649296390803003232654898464561589234445139863242606285711591746222880807391057211912655818499798720987302540712067959840802106849776547522247429904618357394771725653253559346195282601285019169360207355179223814857106405285007997547692546378757062999581657867188420995770650565521377874333085963123444258953052751461206977615079511435862879678439081175536265576977106865074099512897235100538241196445815568291377846656352979228098911566675956525644182645608178603837172227838896725425605719942300037650526231486881066037397866942013838296769284745527778439272995067231492069369130289154753132313883294398593507873555667211005422003204156154859031529462152953119957597195735953686798871131148255050140450845034240095305094449911578598539658855704158240221809528010179414493499583473568873253067921639513996596738275817909624857593693291980841303291145613566466575233283651420134915764961372875933822262953420444548349180436583183291944875599477240814774580187144637965487250578134990402443365677985388481961492444981994523034245619781853365476552719460960795929666883665704293897310201276011658074359194189359660792496027472226428571547971602259808697441435358578480589837766911684200275636889192254762678512597000452676191374475932796663842865744658264924913771676415404179920096074751516422872997665425047457428327276230059296132722787915300105002019006293320082955378715908263653377755031155794063450515731009402407584683132870206376994025920790298591144213659942668622062191441346200098342943955169522532574271644954360217472458521489671859465232568419404182043966092211744372699797375966048010775453444600153524772238401414789562651410289808994960533132759532092895779406940925252906166612153699850759933762897947175972147868784008320247586210378556711332739463277940255289047962323306946068381887446046387745247925675240182981190836264964640612069909458682443392729946084099312047752966806439331403663934969942958022237945205992581178803606156982034385347182766573351768749665172549908638337611953199808161937885366709285043276595726484068138091188914698151703122773726725261370542355162118164302728812259192476428938730724109825922331973256105091200551566581350508061922762910078528219869913214146575557249199263634241165352226570749618907050553115468306669184485910269806225894530809823102279231750061652042560772530576713148647858705369649642907780603247428680176236527220826640665659902650188140474762163503557640566711903907798932853656216227739411210513756695569391593763704981001125

La source

functools lru_cache

Nous pourrions également utiliser une variante de l'approche ascendante de la programmation dynamique

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))