Python RecursionError — Complete Fix Guide
Python RecursionError — Complete Fix Guide 🔄
Python developers ka classic error — RecursionError. Function ne khud ko bahut zyada baar call kiya! Missing base case, deep recursion, infinite recursion — sab reasons cover karenge with solutions. Real employee data examples, iterative alternatives, aur interview questions ke saath. Data Insights par.
📑 Is Blog Mein Kya Sikhenge:
- 🟢 Basic: RecursionError kya hai, kab aati hai
- 🟡 Medium: Common Causes — missing base case, deep recursion
- 🔴 Advanced: Tail recursion, memoization, iterative solutions
- 🛠️ Solutions: Base cases, limit increase, iteration, caching
- 🔍 Debugging: Kaise trace aur prevent karo
- 💬 Interview: Top asked questions
1. RecursionError — Kya Hai? 🟢
📘 Definition: RecursionError Python ka built-in exception hai jo tab raise hoti hai jab recursive function ki call stack MAXIMUM DEPTH exceed kar jaati hai. Python ki default recursion limit 1000 hai. Ye RuntimeError ki subclass hai. Recursion powerful hai but risky — infinite recursion ya bahut deep recursion crash kar deti hai program ko.
🎯 Samjho Hinglish Mein: Socho tumne mirror ke saamne mirror rakh diya — reflection ki reflection ki reflection... infinite chain! Same tarah recursion mein function khud ko call karta hai. Har call memory mein stack pe add hoti hai. Python bolta hai "bhai, 1000 baar tak allow kar sakta hoon, uske aage stack overflow ho jaayega — computer crash!". Base case (stopping condition) miss ho jaaye — infinite recursion — RecursionError! Real-world: employee hierarchy traversal, folder tree, JSON parsing — sab jagah recursion use hoti hai but base case zaroori.
📊 Sample Data (Employee Manager Hierarchy):
# Employee hierarchy — manager relationships
employees = {
101: {"name": "Aarav", "manager": 102},
102: {"name": "Ishita", "manager": 103},
103: {"name": "Kabir", "manager": 104},
104: {"name": "Diya", "manager": 105},
105: {"name": "Rohan", "manager": None} # CEO — no manager
}
# ❌ Recursive function to find CEO (topmost manager)
def find_ceo(emp_id):
manager_id = employees[emp_id]["manager"]
return find_ceo(manager_id) # ❌ No base case!
find_ceo(101) # ❌ RecursionError!❌ Error Output:
# ❌ ERROR OUTPUT:
# Traceback (most recent call last):
# File "hierarchy.py", line 15, in <module>
# find_ceo(101)
# File "hierarchy.py", line 13, in find_ceo
# return find_ceo(manager_id)
# File "hierarchy.py", line 13, in find_ceo
# return find_ceo(manager_id)
# File "hierarchy.py", line 13, in find_ceo
# return find_ceo(manager_id)
# [Previous line repeated 996 more times]
# RecursionError: maximum recursion depth exceeded• Missing base case — function never stops calling itself
• Wrong base case — condition kabhi TRUE nahi hoti
• Circular data — A → B → A (infinite loop)
• Legitimate deep recursion — 1000+ levels needed
• Python default limit:
sys.getrecursionlimit() = 10002. Cause 1 — Missing Base Case 🟡
📘 Cause: Sabse common mistake — recursive function mein STOPPING CONDITION (base case) nahi hai. Function khud ko infinitely call karta rehta hai. Har recursion function ke paas base case hona MANDATORY hai — jab function stop kare recursion.
❌ Wrong Code (Error):
# ❌ Missing base case — factorial
def factorial(n):
return n * factorial(n - 1) # Never stops!
factorial(5) # ❌ RecursionError
# ❌ Missing base case — count down
def countdown(n):
print(n)
countdown(n - 1) # Goes negative infinity!
countdown(10) # ❌ RecursionError
# ❌ Employee hierarchy — no CEO check
employees = {
101: {"name": "Aarav", "manager": 102},
102: {"name": "Ishita", "manager": None} # CEO
}
def get_hierarchy(emp_id):
manager_id = employees[emp_id]["manager"]
return [emp_id] + get_hierarchy(manager_id) # ❌ No stop!
get_hierarchy(101) # ❌ Crashes when manager is None✅ Fix — Add Base Case:
# ✅ Factorial with base case
def factorial(n):
# Base case
if n <= 1:
return 1
# Recursive case
return n * factorial(n - 1)
print(factorial(5)) # 120 ✅
# ✅ Countdown with base case
def countdown(n):
if n <= 0: # Base case
print("Done!")
return
print(n)
countdown(n - 1)
countdown(5)
# Output: 5, 4, 3, 2, 1, Done! ✅
# ✅ Employee hierarchy — proper base case
employees = {
101: {"name": "Aarav", "manager": 102},
102: {"name": "Ishita", "manager": 103},
103: {"name": "Kabir", "manager": None} # CEO
}
def get_hierarchy(emp_id):
# Base case: reached CEO
if emp_id is None:
return []
manager_id = employees[emp_id]["manager"]
return [employees[emp_id]["name"]] + get_hierarchy(manager_id)
print(get_hierarchy(101))
# Output: ['Aarav', 'Ishita', 'Kabir'] ✅
# ✅ Fibonacci with base cases
def fibonacci(n):
# Base cases
if n <= 0:
return 0
if n == 1:
return 1
# Recursive case
return fibonacci(n - 1) + fibonacci(n - 2)
print(fibonacci(10)) # 55 ✅• Every recursive function MUST have base case — non-negotiable
• Base case FIRST likho, phir recursive case
• Ensure recursive call MOVES TOWARDS base case
• Test with smallest inputs — recursion behavior verify karo
• Multiple base cases OK — Fibonacci needs 2 base cases
3. Cause 2 — Wrong Base Case Logic 🟡
📘 Cause: Base case hai but LOGIC galat hai — condition kabhi TRUE nahi hoti. Ya recursive call base case ke direction mein progress nahi karti. Ye subtle bug hai — code sahi lagta hai but infinite recursion hoti hai.
❌ Wrong Code (Error):
# ❌ Wrong base case — never reached
def countdown(n):
if n == 0: # Base case
return
print(n)
countdown(n + 1) # ❌ Wrong direction! (goes up)
countdown(5) # ❌ 5, 6, 7, 8... never reaches 0
# ❌ Wrong condition
def factorial(n):
if n == 1: # What if n is 0 or negative?
return 1
return n * factorial(n - 1)
factorial(0) # ❌ 0 * factorial(-1) * factorial(-2)... infinite!
factorial(-5) # ❌ Never reaches 1
# ❌ Employee hierarchy — circular reference
employees = {
101: {"name": "Aarav", "manager": 102},
102: {"name": "Ishita", "manager": 101} # ❌ Circular!
}
def get_ceo(emp_id):
manager_id = employees[emp_id]["manager"]
if manager_id is None:
return emp_id
return get_ceo(manager_id)
get_ceo(101)
# ❌ 101 → 102 → 101 → 102... RecursionError!✅ Fix — Correct Base Case Logic:
# ✅ Correct direction
def countdown(n):
if n <= 0: # Handle 0 and negatives
return
print(n)
countdown(n - 1) # ✅ Correct direction
# ✅ Robust factorial — handles edge cases
def factorial(n):
if n < 0:
raise ValueError("Factorial not defined for negatives")
if n <= 1: # Covers 0 and 1
return 1
return n * factorial(n - 1)
print(factorial(0)) # 1 ✅
print(factorial(5)) # 120 ✅
# ✅ Employee hierarchy — detect cycles
employees = {
101: {"name": "Aarav", "manager": 102},
102: {"name": "Ishita", "manager": 103},
103: {"name": "Kabir", "manager": None} # CEO
}
def get_ceo(emp_id, visited=None):
if visited is None:
visited = set()
# Cycle detection
if emp_id in visited:
raise ValueError("Circular reference detected!")
visited.add(emp_id)
manager_id = employees[emp_id]["manager"]
if manager_id is None:
return employees[emp_id]["name"] # Found CEO
return get_ceo(manager_id, visited)
print(get_ceo(101)) # Kabir ✅4. Cause 3 — Legitimate Deep Recursion 🔴
📘 Cause: Code sahi hai, base case bhi hai, but data itni deep hai ki 1000 recursion limit exceed ho jaati hai. Example: bahut large lists, deeply nested data, ya scientific calculations. Solution: recursion limit badhao ya iterative approach use karo.
❌ Scenario (Error):
import sys
# Check Python's default limit
print(sys.getrecursionlimit()) # 1000 (default)
# ❌ Factorial with large number
def factorial(n):
if n <= 1:
return 1
return n * factorial(n - 1)
factorial(2000) # ❌ RecursionError (needs 2000 depth)
# ❌ Sum of large list
def sum_list(lst):
if not lst:
return 0
return lst[0] + sum_list(lst[1:])
sum_list(list(range(1500))) # ❌ RecursionError
# ❌ Deep employee tree traversal (1000+ employees)
def count_reports(manager_id, employees):
if manager_id not in employees:
return 0
reports = employees[manager_id]["reports"]
return len(reports) + sum(count_reports(r, employees) for r in reports)
# ❌ Deep hierarchy = RecursionError✅ Solution 1 — Increase Recursion Limit:
import sys
# Get current limit
print(sys.getrecursionlimit()) # 1000
# ✅ Increase limit
sys.setrecursionlimit(5000) # Now 5000
# Now works for larger inputs
def factorial(n):
if n <= 1:
return 1
return n * factorial(n - 1)
result = factorial(2000) # ✅ Works now
print(f"2000! calculated")
# ⚠️ WARNING: Don't set too high!
# Too high = stack overflow = Python crash
sys.setrecursionlimit(10000) # Safe max
# sys.setrecursionlimit(1000000) # ❌ RISKY!✅ Solution 2 — Convert to Iteration (BETTER!):
# ✅ Iterative factorial — no recursion limit
def factorial_iterative(n):
if n < 0:
raise ValueError("Negative not allowed")
result = 1
for i in range(2, n + 1):
result *= i
return result
factorial_iterative(10000) # ✅ Works for very large!
# ✅ Iterative sum
def sum_list_iterative(lst):
total = 0
for item in lst:
total += item
return total
# Or use built-in sum() — even better!
total = sum(list(range(1000000))) # ✅ No limit issue
# ✅ Iterative employee hierarchy using while loop
employees = {
101: {"name": "Aarav", "manager": 102},
102: {"name": "Ishita", "manager": 103},
103: {"name": "Kabir", "manager": None}
}
def get_hierarchy_iterative(emp_id):
hierarchy = []
current_id = emp_id
while current_id is not None:
if current_id not in employees:
break
hierarchy.append(employees[current_id]["name"])
current_id = employees[current_id]["manager"]
return hierarchy
print(get_hierarchy_iterative(101))
# Output: ['Aarav', 'Ishita', 'Kabir'] ✅
# Works for any depth without RecursionError!5. Solution — Memoization & Caching 🔴
📘 Definition: Memoization is caching results of expensive function calls. Same input pe call kiya toh cached result return karo — recursion depth reduce ho jaata hai dramatically. Python mein functools.lru_cache built-in hai. Fibonacci jaise problems mein 1000x+ speedup!
❌ Without Memoization (Slow + Deep):
# ❌ Fibonacci without memoization
def fibonacci(n):
if n <= 1:
return n
return fibonacci(n - 1) + fibonacci(n - 2)
fibonacci(40) # Takes 30+ seconds!
fibonacci(100) # ❌ Would take YEARS (2^100 calls!)
# Reason: same calculations repeated exponentially
# fib(5) = fib(4) + fib(3)
# = (fib(3) + fib(2)) + (fib(2) + fib(1))
# = fib(2) called MULTIPLE times!✅ With Memoization (Fast + Efficient):
# ✅ Solution 1: Manual memoization with dict
cache = {}
def fibonacci(n):
if n in cache:
return cache[n]
if n <= 1:
return n
result = fibonacci(n - 1) + fibonacci(n - 2)
cache[n] = result
return result
print(fibonacci(100)) # ✅ Instant! 354224848179261915075
# ✅ Solution 2: functools.lru_cache (RECOMMENDED)
from functools import lru_cache
@lru_cache(maxsize=None)
def fibonacci(n):
if n <= 1:
return n
return fibonacci(n - 1) + fibonacci(n - 2)
print(fibonacci(100)) # ✅ Instant, elegant!
# View cache stats
print(fibonacci.cache_info())
# CacheInfo(hits=98, misses=101, maxsize=None, currsize=101)
# Clear cache if needed
fibonacci.cache_clear()
# ✅ Solution 3: @cache decorator (Python 3.9+)
from functools import cache
@cache
def fibonacci(n):
if n <= 1:
return n
return fibonacci(n - 1) + fibonacci(n - 2)
# ✅ Real-world: Employee salary calculation
from functools import lru_cache
employees = {
101: {"name": "Aarav", "salary": 55000, "manager": 102},
102: {"name": "Ishita", "salary": 72000, "manager": 103},
103: {"name": "Kabir", "salary": 65000, "manager": None}
}
@lru_cache(maxsize=128)
def get_total_hierarchy_salary(emp_id):
"""Cached: Sum salaries of all managers up the hierarchy"""
if emp_id is None or emp_id not in employees:
return 0
emp = employees[emp_id]
return emp["salary"] + get_total_hierarchy_salary(emp["manager"])
# First call — calculates and caches
print(get_total_hierarchy_salary(101)) # 192000
# Second call — instant from cache!
print(get_total_hierarchy_salary(101)) # 192000 (cached)• Speed — 1000x+ faster for overlapping subproblems
• Less recursion depth — cached calls don't recurse
• Simple — just add decorator, no code changes
• Configurable —
maxsize parameter controls cache size• Debuggable —
cache_info() shows hits/misses6. Recursion vs Iteration 🛠️
📘 Definition: Most recursive problems can be solved with ITERATION (loops) — no recursion limit issue. Python mein iteration generally faster hoti hai recursion se (function call overhead nahi). Modern practice: recursion for tree/graph problems, iteration for linear problems.
💻 Recursion vs Iteration Examples:
# ═══ FACTORIAL ═══
# Recursive (elegant but limited)
def factorial_rec(n):
if n <= 1:
return 1
return n * factorial_rec(n - 1)
# Iterative (fast, no recursion limit)
def factorial_iter(n):
result = 1
for i in range(2, n + 1):
result *= i
return result
# Built-in (BEST!)
from math import factorial
factorial(100) # ✅ Instant, unlimited
# ═══ FIBONACCI ═══
# Recursive (slow without memoization)
def fib_rec(n):
if n <= 1:
return n
return fib_rec(n - 1) + fib_rec(n - 2)
# Iterative (fast, no limit)
def fib_iter(n):
if n <= 1:
return n
a, b = 0, 1
for _ in range(n - 1):
a, b = b, a + b
return b
fib_iter(1000) # ✅ Instant, huge number
# ═══ EMPLOYEE HIERARCHY ═══
employees = {
101: {"name": "Aarav", "manager": 102},
102: {"name": "Ishita", "manager": 103},
103: {"name": "Kabir", "manager": None}
}
# Recursive
def hierarchy_rec(emp_id):
if emp_id is None:
return []
return [employees[emp_id]["name"]] + hierarchy_rec(
employees[emp_id]["manager"]
)
# Iterative
def hierarchy_iter(emp_id):
result = []
while emp_id is not None:
result.append(employees[emp_id]["name"])
emp_id = employees[emp_id]["manager"]
return result
print(hierarchy_iter(101)) # ['Aarav', 'Ishita', 'Kabir']📋 When to Use What:
| Scenario | Recursion | Iteration |
|---|---|---|
| Tree/Graph traversal | ✅ Natural fit | Complex with stack |
| Simple loops (sum, count) | Overkill | ✅ Better |
| Divide & conquer (sorting) | ✅ Elegant | Verbose |
| Very deep data (10000+) | RecursionError risk | ✅ Safe |
| Performance critical | Function call overhead | ✅ Faster |
| Recursive definition (fibonacci) | ✅ Elegant (with memo) | ✅ Efficient |
7. Debugging Tips 🔍
📋 Debugging Checklist:
| Step | Question | Solution |
|---|---|---|
| 1 | Base case exists? | Add stopping condition |
| 2 | Base case reachable? | Check direction of recursion |
| 3 | Edge cases handled? | Test with 0, 1, negative |
| 4 | Circular data? | Add cycle detection |
| 5 | Recursion too deep? | Convert to iteration |
| 6 | Repeated calculations? | Add memoization |
🔍 Debugging Techniques:
# Technique 1: Add depth tracking
def factorial(n, depth=0):
print(f"Depth {depth}: factorial({n})")
if n <= 1:
return 1
return n * factorial(n - 1, depth + 1)
factorial(5)
# Output shows recursion depth
# Technique 2: Check current recursion limit
import sys
print(f"Limit: {sys.getrecursionlimit()}") # 1000
# Technique 3: Get current recursion depth
import sys
def current_depth():
frame = sys._getframe()
depth = 0
while frame:
depth += 1
frame = frame.f_back
return depth
def my_recursive(n):
print(f"Depth: {current_depth()}")
if n <= 0:
return
my_recursive(n - 1)
# Technique 4: Traceback analysis
try:
factorial(2000)
except RecursionError as e:
print(f"Error: {e}")
import traceback
traceback.print_exc()
# Technique 5: Visualize call tree (small inputs)
def fib_verbose(n, indent=0):
prefix = " " * indent
print(f"{prefix}fib({n})")
if n <= 1:
return n
return fib_verbose(n-1, indent+1) + fib_verbose(n-2, indent+1)
fib_verbose(4) # See the recursion tree8. Interview Questions 💬
Q1: RecursionError kya hai aur kab aati hai?
Ans: RecursionError Python ki built-in exception hai jo tab raise hoti hai jab recursive function ki call stack MAXIMUM DEPTH exceed kar jaati hai. Python ki default limit 1000 hai. Ye RuntimeError ki subclass hai. Common causes: (1) Missing base case — function never stops. (2) Wrong base case — condition never TRUE. (3) Recursion moving wrong direction. (4) Circular data references. (5) Legitimate deep recursion needing 1000+ depth. Fix: add proper base case, use iteration for large data, memoization for overlapping subproblems, increase limit with sys.setrecursionlimit(). Real-world: JSON parsing, tree traversal, hierarchical data.
Q2: Recursion mein base case kya hota hai aur kyu zaroori hai?
Ans: Base case recursion ki STOPPING CONDITION hai — jab function stop kare khud ko call karna. Without base case = infinite recursion = RecursionError. Rules: (1) Har recursive function ke paas AT LEAST ONE base case hona chahiye. (2) Base case FIRST likho, phir recursive case. (3) Recursive call MOVE towards base case. (4) Multiple base cases OK (Fibonacci needs 2). Example structure: def func(n): if n <= 0: return; func(n-1). Bad base case: if n == 0 — negative numbers fail. Good: if n <= 0. Interview mein always check: base case correct hai? Reachable hai? Edge cases handle karti hai?
Q3: Python ki default recursion limit kya hai aur badha sakte hain?
Ans: Default 1000 — check with sys.getrecursionlimit(). Change: sys.setrecursionlimit(5000). But CAREFUL: (1) Too high = stack overflow = Python crashes. (2) Safe max ~10,000 (system dependent). (3) High limits mask design issues. Better solutions: (1) Convert to iteration — no limit issue. (2) Memoization — reduce actual recursion depth. (3) Refactor algorithm — divide & conquer approaches. Reason for limit: Python's C stack is finite — each recursion uses ~500 bytes. 1000 recursions = 500KB stack. Very high limits risk crashing entire Python process. Best practice: don't rely on limit increase — fix the root cause.
Q4: Memoization kya hai aur kaise recursion optimize karta hai?
Ans: Memoization caching technique hai — expensive function calls ke results cache karke store karo, same inputs pe cached result return karo. Recursion mein huge speedup deta hai — especially overlapping subproblems (Fibonacci). Fibonacci without memo: 2^n calls (exponential). With memo: n calls (linear). Implementation: (1) Manual dict — cache = {}, check before compute. (2) functools.lru_cache — decorator, one-liner: @lru_cache(maxsize=None). (3) functools.cache (Python 3.9+) — @cache. Benefits: 1000x+ speedup, reduces recursion depth (cached calls skip), simple to add. Real-world: dynamic programming, expensive computations, API caching. Interview mein Fibonacci with/without memo classic question hai.
Q5: Recursion vs Iteration — kaunsa better hai?
Ans: Depends on situation: Recursion better hai: (1) Tree/graph traversal — natural fit. (2) Divide & conquer (quicksort, mergesort). (3) Recursive definitions (Fibonacci, factorial). (4) Elegant code. (5) Backtracking problems. Iteration better hai: (1) Simple loops (sum, count). (2) Very large inputs (no RecursionError). (3) Performance-critical (no function call overhead). (4) Python specifically (no tail-call optimization). (5) Memory-constrained environments. Python-specific: iteration usually faster kyunki Python function calls expensive hain (frame creation, argument passing). Also, no tail-call optimization. Rule: recursive definition natural ho toh recursion + memoization. Simple iteration ho sake toh iteration. Interview mein both approaches jaano.
Q6: Tail recursion Python mein optimize hoti hai?
Ans: NO — Python mein tail-call optimization NAHI hai! Kuch languages (Scheme, Scala, Kotlin) tail recursion ko iteration mein convert kar dete hain — no stack growth. Python design decision: (1) Guido van Rossum ne deliberately reject kiya. (2) Reasoning: recursion should be intentional, not hidden optimization. (3) Stack traces intact rehte hain debugging ke liye. Consequence: even tail-recursive functions Python mein stack use karti hain — RecursionError still possible. Workaround: (1) Convert to iteration manually. (2) Use trampolining pattern (advanced). (3) Use sys.setrecursionlimit() if needed. Example tail recursion: def sum_tail(lst, acc=0): if not lst: return acc; return sum_tail(lst[1:], acc + lst[0]). Python mein iteration hi better. Interview mein Python's design choice explain karo — advanced knowledge dikhata hai.
Q7: Circular references se RecursionError kaise avoid karo?
Ans: Circular reference = A → B → A (infinite loop). Detection strategies: (1) Visited set — track already-processed nodes: if node in visited: raise CircularError. (2) Path tracking — current path maintain karo, cycle detect karo. (3) Iterative with depth limit — max depth counter. (4) Graph algorithms — DFS with color marking (white/gray/black). Example employee hierarchy: circular manager references (A → B → A). Solution: def find_ceo(emp_id, visited=None): if visited is None: visited = set(); if emp_id in visited: raise ValueError("Circular"); visited.add(emp_id); .... Real-world: (1) Database relationships. (2) File system symbolic links. (3) Object references in memory. (4) JSON with references. Best practice: always cycle detection when data structure could be circular. Data validation at input stage bhi karo — prevent bad data from entering system.
Q8: Production code mein RecursionError kaise prevent karte hain?
Ans: Multi-layered prevention: (1) Prefer iteration — default choice for production, unless recursion truly natural. (2) Memoization — cache expensive recursive calls. (3) Base case first — always base case before recursive call. (4) Input validation — check depth/size before recursion (max reasonable depth). (5) Cycle detection — for graph/tree data with potential loops. (6) Depth tracking — max_depth parameter with limit checks. (7) Iterative fallback — if depth exceeds threshold, switch to iteration. (8) Testing edge cases — very deep inputs in unit tests. (9) Monitoring — production errors alert setup for RecursionError. (10) Documentation — recursive functions ka max supported depth document karo. Real-world: JSON parsers, XML parsers, tree algorithms — sab careful implementation. Modern approach: use tested libraries (lxml, ijson) instead of custom recursion for known problems.
9. Quick Cheat Sheet 📋
# ══════════════════════════════════════
# COMMON CAUSES
# ══════════════════════════════════════
# 1. Missing base case
def fact(n):
return n * fact(n - 1) # ❌ Never stops
# 2. Wrong base case
def fact(n):
if n == 1: return 1
return n * fact(n - 1) # ❌ Fails for n=0
# 3. Wrong direction
def countdown(n):
if n == 0: return
countdown(n + 1) # ❌ Goes up, not down
# 4. Deep recursion
fact(2000) # ❌ Exceeds 1000 limit
# ══════════════════════════════════════
# SOLUTIONS
# ══════════════════════════════════════
# Solution 1: Add proper base case
def factorial(n):
if n <= 1: # Covers 0, 1, negative
return 1
return n * factorial(n - 1)
# Solution 2: Increase limit
import sys
sys.setrecursionlimit(5000)
# Solution 3: Convert to iteration (BEST!)
def factorial(n):
result = 1
for i in range(2, n + 1):
result *= i
return result
# Solution 4: Memoization
from functools import lru_cache
@lru_cache(maxsize=None)
def fibonacci(n):
if n <= 1: return n
return fibonacci(n-1) + fibonacci(n-2)
# ══════════════════════════════════════
# RECURSION LIMITS
# ══════════════════════════════════════
import sys
# Check limit
sys.getrecursionlimit() # 1000
# Set limit
sys.setrecursionlimit(5000) # Safe
# Don't go above 10,000!
# ══════════════════════════════════════
# MEMOIZATION PATTERNS
# ══════════════════════════════════════
# Pattern 1: Manual dict cache
cache = {}
def func(n):
if n in cache: return cache[n]
# ... compute ...
cache[n] = result
return result
# Pattern 2: lru_cache decorator
from functools import lru_cache
@lru_cache(maxsize=128)
def expensive_function(n):
pass
# Pattern 3: cache (Python 3.9+)
from functools import cache
@cache
def expensive_function(n):
pass
# ══════════════════════════════════════
# RECURSIVE PATTERN TEMPLATE
# ══════════════════════════════════════
def recursive_template(input):
# 1. Base case (STOP here)
if base_condition:
return base_value
# 2. Progress towards base
smaller_input = reduce(input)
# 3. Recursive call
smaller_result = recursive_template(smaller_input)
# 4. Combine
return combine(input, smaller_result)
# ══════════════════════════════════════
# CYCLE DETECTION
# ══════════════════════════════════════
def traverse(node, visited=None):
if visited is None:
visited = set()
if node in visited:
raise ValueError("Cycle detected")
visited.add(node)
# ... process ...
# ══════════════════════════════════════
# GOLDEN RULES
# ══════════════════════════════════════
# 1. Every recursion NEEDS base case
# 2. Base case FIRST, recursive call after
# 3. Ensure progress toward base case
# 4. Handle edge cases (0, 1, negative)
# 5. Test with small inputs first
# 6. Add memoization for overlapping subproblems
# 7. Convert to iteration for deep data
# 8. Detect cycles in graph-like data
# 9. Python has NO tail-call optimization
# 10. Prefer iteration for performance• 🔄 RecursionError = maximum recursion depth exceeded (default 1000)
• 🎯 Base case — MUST have stopping condition
• ✅ Fix: proper base case, correct direction, handle edge cases
• 💡 Memoization with
@lru_cache — 1000x+ speedup• 🔄 Iteration better for very deep data (no recursion limit)
• 🛡️ Cycle detection for graph/tree data
• ⚠️
sys.setrecursionlimit() — use cautiously• 💼 Python NO tail-call optimization — prefer iteration in production
Next: Data Insights Errors Fix Guide
Congratulations! Python errors series COMPLETE ho gayi! Ab shuru karte hain Pandas errors — Pandas KeyError Complete Fix Guide. DataFrame mein missing keys, column names, aur data access errors — sab detailed with employee data examples. Pandas errors series: KeyError, SettingWithCopyWarning, ValueError, ParserError, DtypeWarning, EmptyDataError — sab upcoming. Data Insights par!
Happy Debugging & Keep Coding! 🚀
💬 Comments (0)
Loading comments...