【Python】再帰回数制限の確認と変更方法：RecursionErrorの対処法完全ガイド

Pythonで再帰関数を使っていると、「RecursionError: maximum recursion depth exceeded」というエラーに遭遇することがあります。この記事では、Pythonの再帰回数制限の確認方法、変更方法、そしてRecursionErrorを避けるための実践的な対処法について詳しく解説します。

Pythonの再帰回数制限とは？

Pythonには再帰関数の呼び出し回数に制限があります。これは無限再帰によるスタックオーバーフローを防ぐためのセーフティネットです。デフォルトでは1000回程度に設定されていますが、環境によって異なる場合があります。

RecursionErrorが発生する例

def infinite_recursion(n):
    """無限再帰の例（危険なコード）"""
    return infinite_recursion(n + 1)

# RecursionErrorが発生
try:
    infinite_recursion(0)
except RecursionError as e:
    print(f"RecursionError: {e}")

再帰回数制限の確認方法

1. sys.getrecursionlimit()を使用

import sys

# 現在の再帰回数制限を確認
current_limit = sys.getrecursionlimit()
print(f"現在の再帰回数制限: {current_limit}")

# 一般的な出力例: 現在の再帰回数制限: 1000

2. 実際の再帰回数をテスト

import sys

def test_recursion_depth(depth=0):
    """実際にどこまで再帰できるかテスト"""
    try:
        return test_recursion_depth(depth + 1)
    except RecursionError:
        return depth

# 実際の再帰可能回数をテスト
max_depth = test_recursion_depth()
print(f"実際の最大再帰回数: {max_depth}")
print(f"設定されている制限: {sys.getrecursionlimit()}")

3. 詳細な環境情報の確認

import sys
import platform

def check_recursion_environment():
    """再帰環境の詳細情報を表示"""
    print("=== Python再帰環境情報 ===")
    print(f"Pythonバージョン: {sys.version}")
    print(f"プラットフォーム: {platform.system()} {platform.release()}")
    print(f"現在の再帰制限: {sys.getrecursionlimit()}")
    
    # スタックサイズの確認（Unix系のみ）
    try:
        import resource
        stack_size = resource.getrlimit(resource.RLIMIT_STACK)
        print(f"スタックサイズ制限: {stack_size}")
    except (ImportError, AttributeError):
        print("スタックサイズ情報は取得できません（Windows環境など）")
    
    # 実際のテスト
    actual_limit = test_recursion_depth()
    print(f"実際の最大再帰回数: {actual_limit}")

check_recursion_environment()

再帰回数制限の変更方法

1. sys.setrecursionlimit()を使用

import sys

# 現在の制限を確認
print(f"変更前の制限: {sys.getrecursionlimit()}")

# 制限を変更（例：3000に設定）
sys.setrecursionlimit(3000)
print(f"変更後の制限: {sys.getrecursionlimit()}")

# 注意：あまり大きな値を設定すると危険

2. 安全な制限変更の例

import sys

def safe_set_recursion_limit(new_limit):
    """安全に再帰制限を変更する関数"""
    current_limit = sys.getrecursionlimit()
    
    # 制限値の妥当性チェック
    if new_limit < 100:
        print("警告: 制限値が小さすぎます（最低100を推奨）")
        return False
    
    if new_limit > 10000:
        print("警告: 制限値が大きすぎます（スタックオーバーフローの危険）")
        response = input("本当に設定しますか？ (y/N): ")
        if response.lower() != 'y':
            return False
    
    # 制限を変更
    sys.setrecursionlimit(new_limit)
    print(f"再帰制限を変更: {current_limit} → {new_limit}")
    return True

# 使用例
safe_set_recursion_limit(2000)

3. 一時的な制限変更

import sys
from contextlib import contextmanager

@contextmanager
def temporary_recursion_limit(new_limit):
    """一時的に再帰制限を変更するコンテキストマネージャー"""
    original_limit = sys.getrecursionlimit()
    try:
        sys.setrecursionlimit(new_limit)
        print(f"一時的に再帰制限を変更: {original_limit} → {new_limit}")
        yield
    finally:
        sys.setrecursionlimit(original_limit)
        print(f"再帰制限を復元: {new_limit} → {original_limit}")

# 使用例
with temporary_recursion_limit(2000):
    # この範囲内でのみ制限が変更される
    result = some_recursive_function()
# ここで元の制限に戻る

実践的な再帰関数の例

1. フィボナッチ数列（制限に引っかかる例）

import sys

def fibonacci_naive(n):
    """ナイーブなフィボナッチ実装（非効率）"""
    if n <= 1:
        return n
    return fibonacci_naive(n - 1) + fibonacci_naive(n - 2)

def fibonacci_recursive(n):
    """シンプルな再帰実装"""
    if n <= 1:
        return n
    return fibonacci_recursive(n - 1) + fibonacci_recursive(n - 2)

# 再帰制限に注意して実行
def test_fibonacci():
    current_limit = sys.getrecursionlimit()
    print(f"現在の再帰制限: {current_limit}")
    
    try:
        # 大きな値では RecursionError が発生する可能性
        result = fibonacci_recursive(35)
        print(f"fibonacci_recursive(35) = {result}")
        
        # さらに大きな値でテスト
        result = fibonacci_recursive(100)  # これは制限に引っかかる
        print(f"fibonacci_recursive(100) = {result}")
    
    except RecursionError:
        print("RecursionError: 再帰制限に達しました")

test_fibonacci()

2. 階乗計算（制限対応版）

import sys

def factorial_recursive(n):
    """再帰による階乗計算"""
    if n <= 1:
        return 1
    return n * factorial_recursive(n - 1)

def safe_factorial(n, max_recursion=None):
    """安全な階乗計算（制限チェック付き）"""
    if max_recursion is None:
        max_recursion = sys.getrecursionlimit() - 100  # 安全マージン
    
    if n > max_recursion:
        raise ValueError(f"入力値が大きすぎます。最大値: {max_recursion}")
    
    return factorial_recursive(n)

# 使用例
try:
    result = safe_factorial(500)
    print(f"500! = {result}")
except (RecursionError, ValueError) as e:
    print(f"エラー: {e}")

3. 二分探索（効率的な再帰例）

def binary_search_recursive(arr, target, left=0, right=None):
    """再帰による二分探索"""
    if right is None:
        right = len(arr) - 1
    
    if left > right:
        return -1  # 見つからない
    
    mid = (left + right) // 2
    
    if arr[mid] == target:
        return mid
    elif arr[mid] > target:
        return binary_search_recursive(arr, target, left, mid - 1)
    else:
        return binary_search_recursive(arr, target, mid + 1, right)

# 使用例（大きな配列でも効率的）
large_array = list(range(0, 10000, 2))  # 偶数のリスト
target = 5000
result = binary_search_recursive(large_array, target)
print(f"インデックス: {result}, 値: {large_array[result] if result != -1 else 'Not found'}")

RecursionErrorの対処法

1. 反復的な実装への変換

def fibonacci_iterative(n):
    """反復的なフィボナッチ実装（推奨）"""
    if n <= 1:
        return n
    
    a, b = 0, 1
    for _ in range(2, n + 1):
        a, b = b, a + b
    return b

def factorial_iterative(n):
    """反復的な階乗実装"""
    result = 1
    for i in range(1, n + 1):
        result *= i
    return result

# パフォーマンス比較
import time

def compare_implementations():
    n = 30
    
    # 再帰版の測定
    start = time.time()
    result_recursive = fibonacci_recursive(n)
    time_recursive = time.time() - start
    
    # 反復版の測定
    start = time.time()
    result_iterative = fibonacci_iterative(n)
    time_iterative = time.time() - start
    
    print(f"n = {n}")
    print(f"再帰版: {result_recursive} ({time_recursive:.4f}秒)")
    print(f"反復版: {result_iterative} ({time_iterative:.4f}秒)")
    print(f"速度差: {time_recursive / time_iterative:.1f}倍")

compare_implementations()

2. メモ化による最適化

from functools import lru_cache

@lru_cache(maxsize=None)
def fibonacci_memoized(n):
    """メモ化されたフィボナッチ実装"""
    if n <= 1:
        return n
    return fibonacci_memoized(n - 1) + fibonacci_memoized(n - 2)

# 手動メモ化の例
def fibonacci_manual_memo(n, memo=None):
    """手動メモ化のフィボナッチ実装"""
    if memo is None:
        memo = {}
    
    if n in memo:
        return memo[n]
    
    if n <= 1:
        result = n
    else:
        result = fibonacci_manual_memo(n - 1, memo) + fibonacci_manual_memo(n - 2, memo)
    
    memo[n] = result
    return result

# パフォーマンステスト
def test_memoization():
    n = 100
    
    try:
        # メモ化版（高速）
        start = time.time()
        result_memo = fibonacci_memoized(n)
        time_memo = time.time() - start
        print(f"メモ化版 fibonacci({n}) = {result_memo} ({time_memo:.4f}秒)")
        
        # 手動メモ化版
        start = time.time()
        result_manual = fibonacci_manual_memo(n)
        time_manual = time.time() - start
        print(f"手動メモ化版 fibonacci({n}) = {result_manual} ({time_manual:.4f}秒)")
        
    except RecursionError:
        print(f"RecursionError: fibonacci({n})は再帰制限に引っかかります")

test_memoization()

3. スタックを使った疑似再帰

def factorial_stack_based(n):
    """スタックを使った疑似再帰実装"""
    if n <= 1:
        return 1
    
    stack = [n]
    result = 1
    
    while stack:
        current = stack.pop()
        if current <= 1:
            continue
        
        result *= current
        if current > 2:
            stack.append(current - 1)
    
    return result

def tree_traversal_stack(node):
    """スタックを使った木の探索（再帰なし）"""
    if not node:
        return []
    
    result = []
    stack = [node]
    
    while stack:
        current = stack.pop()
        result.append(current.value)
        
        # 子ノードをスタックに追加（右から左の順で）
        if hasattr(current, 'children'):
            for child in reversed(current.children):
                if child:
                    stack.append(child)
    
    return result

深い再帰が必要な場合の対策

1. 制限を適切に設定

import sys
import platform

def configure_recursion_for_deep_processing():
    """深い処理のための再帰設定"""
    current_limit = sys.getrecursionlimit()
    system = platform.system()
    
    # システム別の推奨設定
    if system == "Windows":
        recommended_limit = min(5000, current_limit * 3)
    elif system == "Darwin":  # macOS
        recommended_limit = min(8000, current_limit * 4)
    else:  # Linux
        recommended_limit = min(10000, current_limit * 5)
    
    print(f"システム: {system}")
    print(f"現在の制限: {current_limit}")
    print(f"推奨制限: {recommended_limit}")
    
    sys.setrecursionlimit(recommended_limit)
    return recommended_limit

# 深い再帰処理の例
def deep_tree_processing(depth):
    """深い木構造の処理例"""
    configure_recursion_for_deep_processing()
    
    def create_deep_tree(current_depth):
        if current_depth <= 0:
            return {"value": 0, "children": []}
        
        return {
            "value": current_depth,
            "children": [create_deep_tree(current_depth - 1)]
        }
    
    def process_tree(node, depth=0):
        if not node or not node.get("children"):
            return depth
        
        max_depth = depth
        for child in node["children"]:
            child_depth = process_tree(child, depth + 1)
            max_depth = max(max_depth, child_depth)
        
        return max_depth
    
    try:
        tree = create_deep_tree(depth)
        max_depth = process_tree(tree)
        print(f"処理完了: 最大深度 {max_depth}")
        return tree
    
    except RecursionError:
        print(f"RecursionError: 深度 {depth} は処理できません")
        return None

# テスト実行
deep_tree_processing(2000)

2. プロファイリングとモニタリング

import sys
import functools
import time

def recursion_monitor(func):
    """再帰回数をモニタリングするデコレータ"""
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        if not hasattr(wrapper, 'call_count'):
            wrapper.call_count = 0
            wrapper.max_call_count = 0
            wrapper.start_time = time.time()
        
        wrapper.call_count += 1
        wrapper.max_call_count = max(wrapper.max_call_count, wrapper.call_count)
        
        # 制限に近づいた場合の警告
        current_limit = sys.getrecursionlimit()
        if wrapper.call_count > current_limit * 0.8:
            print(f"警告: 再帰回数が制限の80%に達しました ({wrapper.call_count}/{current_limit})")
        
        try:
            result = func(*args, **kwargs)
            return result
        finally:
            wrapper.call_count -= 1
            
            # 最上位の呼び出しが終了した場合
            if wrapper.call_count == 0:
                elapsed_time = time.time() - wrapper.start_time
                print(f"再帰完了: 最大深度 {wrapper.max_call_count}, 実行時間 {elapsed_time:.4f}秒")
    
    return wrapper

# 使用例
@recursion_monitor
def monitored_factorial(n):
    if n <= 1:
        return 1
    return n * monitored_factorial(n - 1)

# テスト
result = monitored_factorial(500)
print(f"500! = {result}")

デバッグとトラブルシューティング

1. RecursionErrorの詳細分析

import sys
import traceback

def analyze_recursion_error():
    """RecursionErrorの詳細分析"""
    
    def problematic_function(n):
        if n <= 0:
            return 1
        return n + problematic_function(n - 1)
    
    try:
        # 意図的にRecursionErrorを発生させる
        result = problematic_function(2000)
    
    except RecursionError as e:
        print("=== RecursionError分析 ===")
        print(f"エラーメッセージ: {e}")
        print(f"現在の再帰制限: {sys.getrecursionlimit()}")
        
        # スタックトレースの分析
        tb = traceback.format_exc()
        lines = tb.split('\n')
        
        # 再帰呼び出しの回数を概算
        recursion_calls = len([line for line in lines if 'problematic_function' in line])
        print(f"推定再帰回数: {recursion_calls}")
        
        # スタックトレースの一部を表示
        print("\n=== スタックトレース（抜粋）===")
        for i, line in enumerate(lines[:10]):
            if line.strip():
                print(f"{i+1}: {line}")
        
        print("...")
        
        for i, line in enumerate(lines[-10:]):
            if line.strip():
                print(f"{len(lines)-10+i+1}: {line}")

analyze_recursion_error()

2. 再帰深度の可視化

import sys

def visualize_recursion_depth(max_depth=50):
    """再帰深度を可視化"""
    
    def recursive_visualizer(current_depth, max_depth):
        indent = "  " * current_depth
        print(f"{indent}深度 {current_depth}")
        
        if current_depth >= max_depth:
            print(f"{indent}→ 最大深度に到達")
            return current_depth
        
        try:
            return recursive_visualizer(current_depth + 1, max_depth)
        except RecursionError:
            print(f"{indent}→ RecursionError発生！")
            return current_depth
    
    print(f"=== 再帰深度可視化（最大{max_depth}）===")
    print(f"現在の制限: {sys.getrecursionlimit()}")
    
    final_depth = recursive_visualizer(0, max_depth)
    print(f"\n最終到達深度: {final_depth}")

# 可視化実行（小さな値で）
visualize_recursion_depth(10)

パフォーマンス比較とベンチマーク

再帰 vs 反復のベンチマーク

import time
import sys
from functools import lru_cache

# 各種実装
def benchmark_implementations():
    """各種実装のベンチマーク"""
    
    # 再帰版（ナイーブ）
    def fib_recursive(n):
        if n <= 1:
            return n
        return fib_recursive(n - 1) + fib_recursive(n - 2)
    
    # 再帰版（メモ化）
    @lru_cache(maxsize=None)
    def fib_recursive_memo(n):
        if n <= 1:
            return n
        return fib_recursive_memo(n - 1) + fib_recursive_memo(n - 2)
    
    # 反復版
    def fib_iterative(n):
        if n <= 1:
            return n
        a, b = 0, 1
        for _ in range(2, n + 1):
            a, b = b, a + b
        return b
    
    # ベンチマーク実行
    test_cases = [10, 20, 30, 35]
    
    print("=== フィボナッチ数列実装比較 ===")
    print(f"現在の再帰制限: {sys.getrecursionlimit()}")
    print()
    
    for n in test_cases:
        print(f"n = {n}")
        
        # 反復版（常に実行）
        start = time.time()
        result_iter = fib_iterative(n)
        time_iter = time.time() - start
        print(f"  反復版:     {result_iter:>10} ({time_iter:.6f}秒)")
        
        # メモ化再帰版
        fib_recursive_memo.cache_clear()  # キャッシュクリア
        start = time.time()
        result_memo = fib_recursive_memo(n)
        time_memo = time.time() - start
        print(f"  再帰メモ版: {result_memo:>10} ({time_memo:.6f}秒)")
        
        # ナイーブ再帰版（小さな値のみ）
        if n <= 30:
            start = time.time()
            result_naive = fib_recursive(n)
            time_naive = time.time() - start
            print(f"  ナイーブ再帰: {result_naive:>8} ({time_naive:.6f}秒)")
        else:
            print(f"  ナイーブ再帰: スキップ（時間がかかりすぎるため）")
        
        print()

benchmark_implementations()

まとめ

Pythonの再帰回数制限について、重要なポイントをまとめます：

再帰制限の基本

• デフォルトは通常1000回程度
• sys.getrecursionlimit()で確認
• sys.setrecursionlimit()で変更可能

RecursionErrorの対処法

• 反復的実装: 最も確実で効率的
• メモ化: 重複計算を避けて効率化
• スタック利用: 疑似再帰で制限回避
• 制限調整: 必要に応じて適切に設定

ベストプラクティス

• 深い再帰が必要な場合は反復的実装を検討
• メモ化で効率を向上
• 制限変更は慎重に（スタックオーバーフローのリスク）
• エラーハンドリングを適切に実装

注意点

• 制限を大きくしすぎるとシステムクラッシュの危険
• 環境によって安全な制限値は異なる
• パフォーマンスを考慮して実装方法を選択

これらの知識を活用することで、Pythonでの再帰処理をより安全で効率的に実装できます。

■プロンプトだけでオリジナルアプリを開発・公開してみた！！

■AI時代の第一歩！「AI駆動開発コース」はじめました！

テックジム東京本校で先行開始。

■テックジム東京本校

「武田塾」のプログラミング版といえば「テックジム」。
講義動画なし、教科書なし。「進捗管理とコーチング」で効率学習。
より早く、より安く、しかも対面型のプログラミングスクールです。

＜短期講習＞5日で5万円の「Pythonミニキャンプ」開催中。

＜月1開催＞放送作家による映像ディレクター養成講座

＜オンライン無料＞ゼロから始めるPython爆速講座