PythonBeginner.help

RecursionError in Python: Causes and Fixes

RecursionError happens when a function keeps calling itself too many times.

In Python, recursion means a function calls itself to solve a smaller version of the same problem. This can be useful, but the function must have a clear way to stop. If it never stops, or if it goes too deep, Python raises RecursionError.

Quick fix #

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

countdown(5)

Output:

5
4
3
2
1

Most RecursionError problems happen because the function has no base case or the base case is never reached.

What this error means #

  • Recursion happens when a function calls itself.
  • Python stops very deep recursion and raises RecursionError.
  • This usually means the function keeps calling itself too many times.

A common error message looks like this:

RecursionError: maximum recursion depth exceeded

If you are new to functions, see Python functions explained first.

Why it happens #

This error usually happens for one of these reasons:

  • There is no base case to stop the recursion.
  • The base case exists but the code never reaches it.
  • The recursive step does not move toward the stopping condition.
  • The input is too large for a recursive solution in Python.

If you want a simple definition of recursion, read what recursion is in Python.

Example that causes the error #

Here is a minimal example that causes RecursionError:

def greet():
    print("Hello")
    greet()

greet()

Why this fails #

The line below keeps repeating forever:

greet()

The function calls itself, then calls itself again, then again, with no stopping condition.

After enough calls, Python stops the program and raises RecursionError.

▶Traceback (most recent call last):File "example.py", line 3, in greetgreet()RecursionError: maximum recursion depth exceededWhere it happened — file and lineWhat went wrong — the exception typeWhy — the detailed message
Read this bottom-up: greet() calls itself with no base case, so the calls never stop.

Fix 1: Add a base case #

A base case is the condition that stops the function.

Put the base case before the recursive call, and make sure it returns or exits.

Broken version #

def count_up(n):
    print(n)
    count_up(n + 1)

count_up(1)

This never stops.

Fixed version #

def count_up(n):
    if n > 5:   # base case
        return
    print(n)
    count_up(n + 1)

count_up(1)

Output:

1
2
3
4
5

The important part is that the function checks the stopping condition before making the next recursive call.

Fix 2: Move toward the base case #

Even if you have a base case, the function still fails if the values do not move toward it.

Wrong direction #

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

countdown(3)

This has a base case, but n moves away from 0 instead of toward it.

Correct version #

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

countdown(3)

Output:

3
2
1

When writing recursive code:

  • Change the argument on each call.
  • Make the problem smaller each time.
  • Check that the value really gets closer to the stopping condition.

Fix 3: Use a loop instead #

Some tasks are easier with a for loop or while loop.

Loops do not build up recursive calls in the same way, so they avoid deep recursion problems.

Recursive version #

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

countdown(5)

Loop version #

n = 5

while n > 0:
    print(n)
    n -= 1

Output:

5
4
3
2
1

If recursion is not necessary, iteration is often simpler. You can learn more in Python while loops explained.

Debugging checklist #

If your recursive function is failing, try this checklist:

  • Print the function argument before the recursive call.
  • Check whether the value changes on each call.
  • Confirm the base case can actually become true.
  • Test with a very small input first.

Useful debugging examples:

def countdown(n):
    print("calling with:", n)

    if n <= 0:
        return

    countdown(n - 1)

countdown(3)

Output:

calling with: 3
calling with: 2
calling with: 1
calling with: 0

You can also inspect Python’s current recursion limit:

import sys

print(sys.getrecursionlimit())

If you are still stuck, see this beginner guide to debugging Python code.

About increasing the recursion limit #

Python has a recursion limit to protect your program from crashing due to infinite or very deep recursion.

You can change the limit with sys.setrecursionlimit(), like this:

import sys

sys.setrecursionlimit(2000)
print(sys.getrecursionlimit())

But this is usually not the first fix.

For beginners, the better solution is normally to fix the recursive logic:

  • Add a base case
  • Make sure the function moves toward that base case
  • Use a loop if recursion is not needed

Raising the limit can hide a bug instead of solving it.

Common mistakes #

These are the most common causes of RecursionError:

  • Missing base case
  • Wrong comparison in the base case
  • Recursive call uses the same value every time
  • Value changes in the wrong direction
  • Using recursion for very large input

For a broader overview of Python exceptions, read Python errors and exceptions explained.

FAQ #

What is a base case in recursion? #

It is the condition that stops the function from calling itself again.

Can I fix RecursionError by increasing the recursion limit? #

Sometimes, but usually the better fix is to correct the recursive logic or use a loop.

Why does my recursive function never stop? #

Usually because the stopping condition is missing, incorrect, or never reached.

Is recursion bad in Python? #

No, but Python is not ideal for very deep recursion. Simple recursion is fine when the stopping condition is clear.

See also #

Press Esc to close