Python : Réinitialiser la limite de récursion

sys.getrecursionlimit() lit la limite de récursion de l’interpréteur et sys.setrecursionlimit() la modifie. Avant de l’augmenter, vérifiez que la fonction termine bien et qu’une boucle ou une pile explicite ne convient pas mieux.

Lire la limite réellement utilisée

import sys
print(sys.getrecursionlimit())  # Valeur de cet interpréteur, pas une constante du langage.

La limite est souvent 1000 dans CPython, mais ce n’est pas une constante universelle à recopier. Un RecursionError signale une profondeur excessive ; il peut aussi révéler un cas d’arrêt absent ou incorrect.

Modifier temporairement puis restaurer

Voici le mécanisme de restauration. La valeur 1500 sert à illustrer l’API ; elle ne constitue pas un réglage recommandé pour toutes les plateformes :

import sys

ancienne_limite = sys.getrecursionlimit()
try:
    sys.setrecursionlimit(max(ancienne_limite, 1500))
    # Placer ici un calcul dont la profondeur nécessaire a été vérifiée.
finally:
    sys.setrecursionlimit(ancienne_limite)

print(sys.getrecursionlimit() == ancienne_limite)

True

Selon la documentation de sys.setrecursionlimit, le maximum supporté dépend de la plateforme et une limite trop haute peut faire planter l’interpréteur. Fixer une limite inférieure à la profondeur actuelle peut aussi déclencher RecursionError. Le bloc finally restaure le réglage après le calcul.

Pour une factorielle, éviter les appels imbriqués

Calculer 1000! ne nécessite pas d’augmenter cette limite. Une boucle permet de garder la multiplication explicite et de comparer avec la bibliothèque standard :

import math

def factorielle_iterative(n):
    if not isinstance(n, int) or isinstance(n, bool) or n < 0:
        raise ValueError("n doit être un entier positif ou nul")
    resultat = 1
    for facteur in range(2, n + 1):
        resultat *= facteur
    return resultat

print(factorielle_iterative(10))
print(factorielle_iterative(1000) == math.factorial(1000))

3628800
True

Nous affichons seulement le résultat de 10! et l’égalité pour 1000!, afin de garder une sortie lisible. Pour un programme courant, math.factorial fournit directement le calcul.

Choisir la bonne correction

Corrigez d’abord le cas d’arrêt et les arguments. Pour une structure très profonde, envisagez une pile explicite. Pour des sous-problèmes répétés, voyez l’exemple Fibonacci : relever la limite ne résout pas son coût de recalcul.

Une ressource pour poursuivre

Commencez par notre parcours de ressources Python gratuites et de livres par niveau. Les exemples de cette page peuvent être exécutés sans achat.

Programmer avec Python, Luciano Ramalho, édition française First / O’Reilly de 2019 — ISBN 9782412045145. Le livre déjà référencé ici vise un niveau intermédiaire à avancé et approfondit les fonctions et les structures du langage. Ce n’est pas un premier cours de programmation ; les API et versions de cette édition ancienne doivent être rapprochées de la documentation actuelle. Consulter la présentation et le sommaire.

Recommandation précisée à partir de la fiche de l’éditeur consultée le 14 septembre 2026 ; aucune lecture intégrale ni comparaison exhaustive n’est revendiquée.

Affiliation : le lien suivant est affilié. En tant que Partenaire Amazon, je réalise un bénéfice sur les achats remplissant les conditions requises.

Voir ce livre sur Amazon — lien affilié. Vérifiez l’édition, le format, le prix et la disponibilité auprès du vendeur.

Exemples exécutés et ressources vérifiées le 14 septembre 2026.