RecursionError

Q: Why does my error say "while calling a Python object" or "while getting the repr of an object"?

The suffix names the C-level operation that noticed the limit. Python 3.13 prints plain "maximum recursion depth exceeded" for a recursive def; repr(), json.dumps() and comparisons of deeply nested data add "while getting the repr of an object", "while encoding a JSON object", "in comparison". "while calling a Python object" is what older versions (Python 3.10, for example) print when the limit is hit during a call that goes through C — instantiating a class inside its own __init__, a recursive __call__, an lru_cache-wrapped function; 3.13 prints the plain message for those. The fix is the same.

Q: Should I just increase sys.setrecursionlimit()?

Only for recursion you know is bounded and only slightly deeper than 1000. The limit protects the real C stack: set it too high and deep recursion can crash the interpreter with a segmentation fault instead of a catchable exception. For infinite recursion, raising the limit only delays the same error.

Q: Does Python do tail-call optimization?

No. CPython keeps a frame for every call, including return f(n - 1), so a recursion of depth 10 000 needs 10 000 frames regardless of style. Convert such functions to loops.

Q: What is the default recursion limit?

1000, returned by sys.getrecursionlimit(). The frames already on the stack (the REPL, your caller, a test runner) count too, so the depth your function reaches before the error is a little under 1000 and varies by context.

Python caps stack depth (1000 frames by default) instead of crashing; hitting the cap nearly always means a base case your input never reaches.

InheritsBaseException›Exception›RuntimeError›RecursionError

Runtime exceptionPython 3.5+Live demo

RecursionError(*args)

Raised by

recursion with no reachable base case; self-referencing __getattr__/property; very deep nested data

Message

maximum recursion depth exceeded

Quick fix

fix the base case, or rewrite as a loop

Watch out

raising the limit only moves the crash

Demo

Live evaluation

Count digits by recursing on n // 10 until n == 0. Try a negative number.

Try:

Inputs

nintnumber to measure

Code

def digits(n):
    if n == 0:
        return 0
    return 1 + digits(n // 10)
digits(2024)

Result

Positive numbers shrink to 0 in a few steps. Negative ones never do: // rounds toward minus infinity, so -5 // 10 is -1 and -1 // 10 is -1 again — the function calls itself forever until the 1000-frame limit stops it. The base case exists; the input just cannot reach it. The fix is in the pitfalls below.

Constructor

Name	Type	Required	Description
*args	object	no	The message. The interpreter passes one string; str(e) is that string.

Attributes

Attribute	Type	Meaning
args	tuple	The message tuple — e.g. ('maximum recursion depth exceeded',).
__traceback__	traceback	Very long: the same frame repeated. Python collapses it to "[Previous line repeated N more times]" when printing.

Common patterns

Rewrite as a loop

Tail-style recursion becomes a while loop with no depth limit at all.

def digits(n):
    n = abs(n)
    count = 1
    while n >= 10:
        n //= 10
        count += 1
    return count

Explicit stack for tree walks

Deep trees (nested JSON, file trees, linked structures) walked with your own list instead of the call stack.

def walk(root):
    stack = [root]
    while stack:
        node = stack.pop()
        yield node
        stack.extend(node.children)

Raise the limit (with care)

For legitimately deep but bounded recursion only. Too high a value can crash the process with a real C stack overflow instead of a clean exception.

import sys
sys.setrecursionlimit(5000)

Examples

1. No base case at all

def countdown(n): return countdown(n - 1) countdown(3)

Returns

RecursionError: maximum recursion depth exceeded

2. The default limit

import sys sys.getrecursionlimit()

Returns

1000

3. Property that reads itself

class User: @property def name(self): return self.name # should be self._name User().name

Returns

RecursionError: maximum recursion depth exceeded

4. Deeply nested data: repr

data = [] for _ in range(100_000): data = [data] repr(data)

Returns

RecursionError: maximum recursion depth exceeded while getting the repr of an object

5. Deeply nested data: json

import json data = [] for _ in range(100_000): data = [data] json.dumps(data)

Returns

RecursionError: maximum recursion depth exceeded while encoding a JSON object

6. It is a RuntimeError

issubclass(RecursionError, RuntimeError)

Returns

True

7. Catch it and carry on

def f(): return f() try: f() except RecursionError as e: msg = str(e) msg

Returns

'maximum recursion depth exceeded'

Pitfalls

1. A base case the input can skip

n == 0 is never hit for negative n with floor division (or for odd n when stepping by 2). Make the base case cover everything the input can be.

n == 0

def digits(n):
    if n == 0:
        return 0
    return 1 + digits(n // 10)
digits(-5)

RecursionError: maximum recursion depth exceeded

Normalize first

def digits(n):
    n = abs(n)
    if n < 10:
        return 1
    return 1 + digits(n // 10)
digits(-5)

2. __getattr__ that touches a missing attribute

__getattr__ runs for every failed lookup — including the ones it makes itself. Read from self.__dict__ directly inside it.

self.data

class Config:
    def __getattr__(self, name):
        return self.data[name]
Config().port

RecursionError: maximum recursion depth exceeded

self.__dict__

class Config:
    def __getattr__(self, name):
        data = self.__dict__.get('data', {})
        if name in data:
            return data[name]
        raise AttributeError(name)
c = Config()
c.data = {'port': 80}
c.port

3. __setattr__ that assigns through itself

self.x = v inside __setattr__ calls __setattr__ again. Delegate to object.__setattr__ (or super()).

setattr(self, …)

class Point:
    def __init__(self):
        self.x = 0
    def __setattr__(self, name, value):
        setattr(self, name, value)
Point()

RecursionError: maximum recursion depth exceeded

super().__setattr__

class Point:
    def __init__(self):
        self.x = 0
    def __setattr__(self, name, value):
        super().__setattr__(name, value)
Point().x

When to use

Use it

Catching it at a boundary to report "input too deeply nested" for untrusted data
Recognising it in a traceback as "this recursion has no reachable end"

Reach for something else

Using the exception as control flow for normal inputs
Silencing it with sys.setrecursionlimit(10**6) — the process can segfault instead
Recursion over unbounded input (linked lists, user-provided nesting) → loop with an explicit stack

Notes

CPython impl

Since 3.12 sys.getrecursionlimit() applies only to Python code; C-level recursion (repr, json, comparisons of nested data) is guarded by a separate mechanism

Catch via

except RuntimeError also catches it (RecursionError subclasses RuntimeError)

No TCO

CPython does not eliminate tail calls, so return f(n - 1) still uses one frame per step

FAQ

How do I fix "RecursionError: maximum recursion depth exceeded"? ▾

Find the frame that repeats in the traceback and ask why the base case is not reached for this input: a missing base case, a step that does not move toward it (negative numbers, odd numbers stepping by 2), or an attribute hook (__getattr__, __setattr__, a property) that calls itself. If the recursion is genuinely deep but finite — walking a big tree or deeply nested data — rewrite it as a loop with an explicit stack.

Why does my error say "while calling a Python object" or "while getting the repr of an object"? ▾

Should I just increase sys.setrecursionlimit()? ▾

Does Python do tail-call optimization? ▾

What is the default recursion limit? ▾

History

3.5

Added. Previously a plain RuntimeError was raised.

RecursionError

Demo

Constructor

Attributes

Common patterns

Examples

Pitfalls

When to use

Notes

Related

FAQ

History