Recursion & Scope Rules
Overview
Recursion happens when a function calls itself to break down problems into smaller steps.
Learning Objectives
- Define recursion base cases and recursive steps.
- Prevent recursion stack overflow errors.
- Use nonlocal declarations to update variables in nested closures.
Concept Explanation
A recursive function calls itself to solve sub-problems. It requires a base case to terminate execution. Nested functions searching for variables in enclosing functions require using nonlocal to modify them.
Code Examples
Example 1 — Basics
This example introduces the fundamental syntax and concepts.
def countdown(n):
if n <= 0: return
print(n)
countdown(n - 1)
Example 2 — Everyday Usage
This example demonstrates a realistic scenario handling business parameters.
# Sum values of nested list structures
def list_sum(items):
total = 0
for item in items:
if isinstance(item, list):
total += list_sum(item) # Recursive call
else:
total += item
return total
print(list_sum([1, [2, 3], 4]))
Example 3 — Advanced Example
This example shows clean, production-grade code structure following senior development standards.
# Nested tracker counter closure using nonlocal variable binding
def create_tracker():
count = 0
def track():
nonlocal count
count += 1
return count
return track
tracker = create_tracker()
print(tracker(), tracker())
Visual Flow
The following execution flow represents the step-by-step evaluation inside the interpreter:
Invoke function → Recursive step checks base case → Call next step → Base case matched → Return results up the stack
Common Mistakes
Review these common pitfalls when working with this topic:
- Forgetting base cases, causing RecursionError (stack overflow).
- Using recursion where a simple linear loop would consume less memory.
- Confusing the nonlocal scope modifier with the global keyword.
- Modifying global variables recursively without safe wrappers.
Best Practices
Enforce these Pythonic best practices in your codebase:
def sum_nums(n):
if n == 1: return 1
return n + sum_nums(n-1) # Stack overflow if n is large
def sum_nums(n):
return sum(range(1, n + 1)) # Fast built-in math function
Quick Revision
Use these key summaries for last-minute revision:
- Recursive functions call themselves.
- Base cases prevent infinite recursion loops.
- Python does not optimize tail-end recursion calls.
- Default recursion depth is limited to 1000 frames.
- nonlocal updates variables in enclosing scopes.
DataPlayArena Technical Editorial Board
Curated & maintained by enterprise data platform engineers with 10+ years in distributed systems.
Runtime Verification Standards: Every code example, query, and architecture diagram in this tutorial is compiled and verified against real runtimes (Apache Spark 3.5, Python 3.11, PostgreSQL, and DuckDB). If you spot any errata or want to suggest improvements, please submit feedback.