재귀함수 이해하기, 파이썬 팩토리얼·피보나치·재귀 한도 직접 해 보니

$ python3 - <<'PY'
def countdown(n):
    if n == 0:  # 종료 조건
        print("발사!")
        return
    print(n)
    countdown(n - 1)  # 자기 자신을 다시 부른다
countdown(3)
PY
3
2
1
발사!

$ python3 - <<'PY'
def factorial(n, depth=0):
    print("  " * depth + f"factorial({n}) 호출")
    if n <= 1:
        print("  " * depth + "→ 1 반환")
        return 1
    result = n * factorial(n - 1, depth + 1)
    print("  " * depth + f"→ {result} 반환")
    return result
print("결과:", factorial(4))
PY
factorial(4) 호출
  factorial(3) 호출
    factorial(2) 호출
      factorial(1) 호출
      → 1 반환
    → 2 반환
  → 6 반환
→ 24 반환
결과: 24

$ python3 - <<'PY'
import time
from functools import lru_cache
calls = 0
def fib(n):
    global calls
    calls += 1
    return n if n < 2 else fib(n - 1) + fib(n - 2)
for n in (10, 20, 25):
    calls = 0
    t = time.perf_counter()
    v = fib(n)
    print(f"fib({n}) = {v}, 호출 {calls:,}번, {time.perf_counter() - t:.3f}초")
@lru_cache(maxsize=None)
def fib2(n):
    return n if n < 2 else fib2(n - 1) + fib2(n - 2)
t = time.perf_counter()
v = fib2(25)
print(f"lru_cache fib(25) = {v}, 실제 계산 {fib2.cache_info().misses}번, {time.perf_counter() - t:.6f}초")
PY
fib(10) = 55, 호출 177번, 0.000초
fib(20) = 6765, 호출 21,891번, 0.001초
fib(25) = 75025, 호출 242,785번, 0.009초
lru_cache fib(25) = 75025, 실제 계산 26번, 0.000010초

$ python3 - <<'PY'
import sys
print("기본 재귀 한도:", sys.getrecursionlimit())
def forever(n):
    return forever(n + 1)  # 종료 조건이 없다
try:
    forever(0)
except RecursionError as e:
    print("RecursionError:", e)
def deep(n):
    return 0 if n == 0 else 1 + deep(n - 1)
print("깊이 900:", deep(900))
try:
    deep(5000)
except RecursionError as e:
    print("깊이 5000:", type(e).__name__)
sys.setrecursionlimit(10000)
print("한도를 10000으로 올린 뒤 깊이 5000:", deep(5000))
PY
기본 재귀 한도: 1000
RecursionError: maximum recursion depth exceeded
깊이 900: 900
깊이 5000: RecursionError
한도를 10000으로 올린 뒤 깊이 5000: 5000

$ python3 - <<'PY'
def factorial_loop(n):
    result = 1
    for i in range(2, n + 1):
        result *= i
    return result
def fib_loop(n):
    a, b = 0, 1
    for _ in range(n):
        a, b = b, a + b
    return a
print("factorial_loop(10):", factorial_loop(10))
print("fib_loop(25):", fib_loop(25))
print("fib_loop(90):", fib_loop(90))
PY
factorial_loop(10): 3628800
fib_loop(25): 75025
fib_loop(90): 2880067194370816120

$ mkdir -p notes/2026/10 notes/2026/11 notes/drafts && touch notes/a.md notes/2026/10/b.md notes/2026/10/c.md notes/2026/11/d.md notes/drafts/e.md && python3 - <<'PY'
import os
def count_files(path, depth=0):
    total = 0
    for entry in sorted(os.scandir(path), key=lambda e: e.name):
        if entry.is_dir():
            print("  " * depth + entry.name + "/")
            total += count_files(entry.path, depth + 1)
        else:
            print("  " * depth + entry.name)
            total += 1
    return total
print("파일 수:", count_files("notes"))
PY
2026/
  10/
    b.md
    c.md
  11/
    d.md
a.md
drafts/
  e.md
파일 수: 5

$ claude --model opus -p "중첩된 파이썬 리스트를 한 줄로 펼치는 재귀함수 flatten을 쓰고, 그 아래에 print(flatten([1, [2, [3, [4, 5]], 6], [[7]]]))를 넣은 코드만 출력해. 설명이나 코드 블록 표시는 붙이지 마." > flatten.py && cat flatten.py && python3 flatten.py
def flatten(lst):
    result = []
    for item in lst:
        if isinstance(item, list):
            result.extend(flatten(item))
        else:
            result.append(item)
    return result


print(flatten([1, [2, [3, [4, 5]], 6], [[7]]]))
[1, 2, 3, 4, 5, 6, 7]