Fixing RecursionError: maximum recursion depth exceeded in Python

Python developers often encounter the error message:

RecursionError: maximum recursion depth exceeded

This error occurs when a recursive function calls itself too many times, exceeding the maximum call stack limit set by Python. In this article, we’ll explain what causes this error, how to fix or prevent it, and when it’s better to use iterative solutions instead of recursion.

 What Is Recursion?

Recursion is a programming technique where a function calls itself to solve a smaller subproblem of the original task. It’s often used for problems like:

• Calculating factorials
• Traversing trees
• Solving puzzles (e.g., Tower of Hanoi)

Example:

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

 What Causes the RecursionError?

Python has a recursion limit (usually 1000 calls by default) to prevent infinite loops from crashing the program or the system.

If your recursion goes too deep, you'll get:

RecursionError: maximum recursion depth exceeded

Common causes:

• Missing base case in recursion
• Incorrect recursive step
• Processing large data recursively instead of iteratively

 How to Fix RecursionError

1. Ensure a Proper Base Case

Every recursive function must have a stopping condition.

 Incorrect:

def countdown(n):
    print(n)
    countdown(n - 1)  # no base case!

 Correct:

def countdown(n):
    if n <= 0:
        return
    print(n)
    countdown(n - 1)

2. Use Iteration Instead of Recursion

If recursion is too deep, rewrite the function using a loop.

Recursive:

def sum_to_n(n):
    if n == 0:
        return 0
    return n + sum_to_n(n - 1)

Iterative:

def sum_to_n(n):
    total = 0
    for i in range(n + 1):
        total += i
    return total

3. Increase the Recursion Limit (Advanced)

You can manually increase the recursion depth using sys.setrecursionlimit():

import sys
sys.setrecursionlimit(2000)

 Warning: Use this with caution. Setting it too high may crash your program or your system.

4. Use Tail Recursion Optimization (Not Supported in CPython)

Some languages optimize tail-recursive functions, but CPython (the default Python interpreter) does not. So rewriting a function into tail recursion won’t avoid the RecursionError.

 Example: Fixing a Recursive Function

# Faulty recursive function
def bad_fib(n):
    return bad_fib(n - 1) + bad_fib(n - 2)  # No base case!

# Fixed version with base case
def good_fib(n):
    if n <= 1:
        return n
    return good_fib(n - 1) + good_fib(n - 2)

Summary

Solution	Description
Add base case	Prevent infinite recursion
Use iteration	Avoid stack overflow
Set higher recursion limit	With sys.setrecursionlimit() (advanced only)
Avoid deep recursion	Refactor large recursions into loops

Final Tips

• Debug by printing the recursion depth (e.g., by passing a depth parameter).
• Use memoization for recursive algorithms like Fibonacci to avoid repeated calls.
• Python’s default recursion depth limit is there for safety—design around it.