maximum recursion depth exceeded
Python
Erreur courante
Explication
L'erreur `RecursionError: maximum recursion depth exceeded` survient quand une fonction s'appelle elle-même **trop de fois** (souvent à l'infini). Python limite la profondeur de récursion (1000 appels par défaut) pour éviter de saturer la pile. La cause est presque toujours un **cas de base manquant ou jamais atteint**.
```python
def factorielle(n):
return n * factorielle(n - 1) # aucun cas d'arrêt !
factorielle(5)
# RecursionError: maximum recursion depth exceeded
```
Causes courantes
- **Cas de base absent** : la fonction ne s'arrête jamais. - **Cas de base jamais atteint** : la valeur ne converge pas vers la condition d'arrêt. - **Récursion mutuelle** : deux fonctions qui s'appellent sans fin. - **Récursion profonde légitime** dépassant la limite (rare).
1. Ajoutez un cas de base
def factorielle(n):
if n <= 1: # ✅ cas d'arrêt
return 1
return n * factorielle(n - 1)
2. Vérifiez que le cas de base est atteignable
Chaque appel doit rapprocher de la condition d'arrêt (ici n - 1 qui décroît vers 1).
3. Convertissez en boucle pour les grandes profondeurs
def factorielle(n):
resultat = 1
for i in range(2, n + 1):
resultat *= i
return resultat
4. En dernier recours, augmentez la limite
À réserver à une récursion légitimement profonde, jamais pour masquer une boucle infinie :
import sys
sys.setrecursionlimit(5000)
Comment prevenir cette erreur
- **Écrivez le cas de base en premier**, avant l'appel récursif.
- **Préférez l'itération** pour les algorithmes à grande profondeur.
- Testez avec de petites valeurs et tracez les appels (`print(n)`) pour voir s'ils convergent.
- Référence : [docs.python.org — sys.setrecursionlimit](https://docs.python.org/fr/3/library/sys.html#sys.setrecursionlimit).
Besoin d'aide sur votre projet ?
Besoin d'aide sur un probleme technique ? Decrivez-le pour des recommandations.
Nous contacterQuestions frequentes
Pourquoi la limite est-elle de 1000 ?
Pour protéger le programme d'un débordement de pile (stack overflow) qui ferait planter l'interpréteur. C'est un garde-fou : si vous l'atteignez, c'est presque toujours le signe d'une récursion infinie à corriger, pas d'une limite à augmenter.
La récursion est-elle plus lente qu'une boucle en Python ?
Oui, généralement : chaque appel a un coût et Python n'optimise pas la récursion terminale (tail call). Pour les traitements profonds ou critiques en performance, préférez une boucle.