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.