Python再帰関数の使い方10選

はじめに
●再帰関数とは
●再帰関数の基本
- ○基本的な構文
●再帰関数の使い方
●再帰関数の応用例
●再帰関数の注意点と対策
●再帰関数のカスタマイズ方法
まとめ

はじめに

Pythonのプログラミングの中で、再帰関数は非常に有用なツールです。

再帰関数は、同じ関数から自分自身を呼び出す関数のことを指し、これが繰り返されることで複雑な問題をシンプルに解決することが可能となります。

しかし、再帰関数の理解は一見簡単ではなく、正しく理解し使用するためには練習が必要です。

本記事では、Pythonで再帰関数を使用するための10の詳細な使い方をサンプルコード付きで解説します。

●再帰関数とは

再帰関数はプログラミングにおける重要な概念で、関数が自身を呼び出すことで定義されます。

そのため、再帰関数は、一つの大きな問題をより小さな部分問題に分割し、それぞれを解決することで全体の解を見つけるのに役立ちます。

具体的には、再帰関数は一連の計算をループ処理で行うのではなく、その処理を自身が再度実行することで計算を進めます。

再帰関数を理解するためには、まず2つの重要な部分を把握する必要があります。

一つはベースケース（基底条件）、もう一つは再帰ステップ（再帰処理）です。ベースケースは、再帰が停止する条件を定義する部分であり、再帰ステップは自分自身を呼び出す部分です。

●再帰関数の基本

○基本的な構文

Pythonでの再帰関数の基本的な形式は次のようになります。

まず、関数を定義し、その中にベースケースと再帰ステップを実装します。

def recursive_function(arguments):
    if base_case_condition(arguments):
        return base_case_value
    else:
        return recursive_step(arguments)

このコードでは、関数recursive_functionが定義されており、引数argumentsを持ちます。

if文の部分がベースケースで、これがTrueになると関数は基底値を返し終了します。

逆にFalseになると、再帰ステップが実行され、関数自体が再び呼び出されます。

●再帰関数の使い方

○サンプルコード1：ファクトリアルの計算

数学では、整数のファクトリアルはその数から1までの全ての数の積を表します。

例えば、5のファクトリアル（表記は5!）は5 * 4 * 3 * 2 * 1 = 120となります。

これは再帰関数を用いて容易に計算することができます。

Pythonでファクトリアルを計算する再帰関数を紹介します。

def factorial(n):
    if n == 1:
        return 1
    else:
        return n * factorial(n - 1)

このコードでは、引数nが1になったときに1を返すことでベースケースを定義しています。

それ以外の場合、つまりnが1より大きい場合には、nとその一つ小さい数のファクトリアル（factorial(n – 1)）の積を返します。

この例では、再帰的な呼び出しが行われ、nが1になるまで再帰が繰り返されます。

このコードを実行して5のファクトリアルを計算すると、次のような結果が得られます。

print(factorial(5))  # 出力: 120

これは5 * 4 * 3 * 2 * 1 = 120となることから、期待した通りの結果です。

このように再帰関数を使用することで、コードが読みやすくなり、複雑な計算を簡単に表現できます。

○サンプルコード2：フィボナッチ数列の生成

再帰関数を用いて、Pythonでフィボナッチ数列を生成することも可能です。

フィボナッチ数列とは、最初の2項が0と1で、それ以降の項が前の2項の和になるような数列を指します。

フィボナッチ数列は自然界にも頻繁に見られ、プログラミング教育でもよく利用される数列の一つです。

下記のコードでは、引数nを取り、そのn番目までのフィボナッチ数列を返す再帰関数を作成しています。

def fibonacci(n):
    # ベースケース
    if n <= 1:
        return n
    # 再帰ステップ
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)

このコードでは再帰関数の基本的な形式を利用しています。

ベースケースとして、nが1以下のときはそのままnを返します。

再帰ステップでは、関数自身を2回呼び出し、それらの結果を加算しています。

このようにすることで、任意のn番目までのフィボナッチ数列を生成することができます。

このコードを利用して、例えば10番目までのフィボナッチ数列を出力するには次のように実行します。

for i in range(10):
    print(fibonacci(i))

これにより、フィボナッチ数列の初めの10項が出力されます。

しかし、このコードは大きな数になると計算量が指数的に増加してしまい、計算速度が大幅に低下します。

このような問題に対処するための一つの手段として、メモ化と呼ばれるテクニックがあります。

これについては後述の「サンプルコード5: メモ化を用いた高速化」で詳しく説明します。

○サンプルコード3：リストの要素を再帰的に探索する

再帰関数を使用して、リストの要素を探索することも可能です。

再帰関数を用いた探索は、ツリー構造やグラフ構造などのデータ構造の探索に非常に役立ちます。

しかし、その原理を理解するためには、まずは単純なリストの要素探索から始めることをお勧めします。

下記のコードは、指定された値をリストから再帰的に探索するためのPythonコードです。

def recursive_search(lst, target):
    # ベースケース
    if lst == []:
        return False
    # 再帰ステップ
    if lst[0] == target:
        return True
    else:
        return recursive_search(lst[1:], target)

このコードでは、先頭の要素が目的の値であるか確認し、そうでなければリストの残りを引数として再帰的に関数を呼び出します。

ベースケースとしては、リストが空になったとき、つまり探索対象がなくなったときにFalseを返すようにしています。

これにより、リスト内に目的の値が存在しない場合に適切な結果が得られます。

このコードを利用してリストから特定の値を探すには、次のように実行します。

print(recursive_search([1, 2, 3, 4, 5], 3))  # Trueを返す
print(recursive_search([1, 2, 3, 4, 5], 6))  # Falseを返す

これにより、指定した値がリスト内に存在するかどうかを再帰的に探索し、結果を出力することができます。

このように再帰関数を用いることで、コードがシンプルかつ明瞭になりますが、探索対象が大規模になるとパフォーマンスが低下する可能性もあります。

そのため、使用する際には注意が必要です。

○サンプルコード4：ディレクトリの再帰的な探索

このコードでは、Pythonの再帰関数を用いて、特定のディレクトリとそのサブディレクトリ内の全ファイルを探索する手法を紹介します。

この例では、指定したディレクトリパスから始まり、その下層のディレクトリとファイルを再帰的に辿ります。

import os

def 探索ディレクトリ(パス):
    for 名前 in os.listdir(パス):
        完全なパス = os.path.join(パス, 名前)

        if os.path.isdir(完全なパス):
            探索ディレクトリ(完全なパス)
        else:
            print(完全なパス)

探索ディレクトリ('/指定ディレクトリパス')

このコードは、引数としてディレクトリパスを受け取り、そのディレクトリ内のすべてのファイルとサブディレクトリの名前をリスト化します。

次に、各名前に対して、それがディレクトリであるかどうかを確認します。ディレクトリであれば、再帰的にそのディレクトリを探索します。

それがディレクトリでない場合（つまりファイルである場合）、そのパスを表示します。

このコードを実行すると、指定したディレクトリとそのすべてのサブディレクトリ内に存在するファイルの完全なパスが表示されます。

ただし、ここではデモンストレーションのために’/指定ディレクトリパス’というパスを使用していますが、実際には存在するディレクトリのパスを指定してください。

また、Pythonにはディレクトリやファイルを再帰的に探索するためのモジュール、globやpathlibが存在しますが、このコードはそのようなモジュールを使わずに、再帰関数の仕組みを理解するためのサンプルとしています。

●再帰関数の応用例

Pythonの再帰関数は、より高度なアルゴリズムを表現するためにも利用されます。

再帰関数の応用例として、メモ化を用いた高速化、バックトラック法、動的計画法、ツリー構造の深さ優先探索、分割統治法、マージソートの実装について解説していきます。

それぞれの応用例で、再帰関数の基本的な仕組みがどのように適用され、またどのように拡張されるのかを理解することで、Pythonで再帰関数を使ったプログラミングの可能性を広げることができます。

それぞれのサンプルコードを紹介する前に、一般的な再帰関数の特性として、再帰的な処理は同じ処理を繰り返すため、計算量が増大しやすいという点が挙げられます。

しかし、その特性をうまく利用し、計算結果を保存したり（メモ化）、無駄な計算を削減したり（バックトラック法、動的計画法）することで、効率的なアルゴリズムを作成することが可能です。

それでは、一つずつ詳しく見ていきましょう。

○サンプルコード5：メモ化を用いた高速化

再帰関数の実行時間を改善する方法として「メモ化」があります。

これは一度計算した結果をメモリに保存して再利用することで、同じ計算を繰り返すことを避けるテクニックです。

フィボナッチ数列の計算を行うPythonプログラムを紹介します。

このコードでは、計算済みのフィボナッチ数列の項を辞書に保存して、次回その項が必要になった時に再計算するのではなく辞書から取り出します。

# メモ化を行うための辞書を作成します
memo = {0: 0, 1: 1}

def fibonacci(n):
    # もしnが辞書に含まれていれば、その値を返します
    if n in memo:
        return memo[n]

    # nが辞書に含まれていなければ、計算して辞書に追加します
    memo[n] = fibonacci(n - 1) + fibonacci(n - 2)
    return memo[n]

print(fibonacci(10))

このコードでは、メモ化を使ってフィボナッチ数列を計算しています。

この例では、まず辞書memoを作成し、フィボナッチ数列の最初の二つの項をキーと値のペアとして格納しています。

次に、関数fibonacciを定義しています。

この関数は引数nを受け取り、nが辞書memoに含まれていればその値を直接返すようになっています。

もしnがmemoに含まれていなければ、フィボナッチ数列の計算を行い、その結果をmemoに保存します。最後に、引数に10を与えて関数を呼び出し、結果を出力しています。

このメモ化の技術を用いることで、フィボナッチ数列のように同じ計算が何度も繰り返される再帰関数の実行時間を大幅に短縮できます。

この例では10番目のフィボナッチ数を求めていますが、大きな数値になるほどメモ化の効果を実感できます。

ただし、メモ化を使うとプログラムがメモリを多く消費するので、メモリ容量に注意しながら使用することが重要です。

○サンプルコード6：再帰を使ったバックトラック法

次に、バックトラック法の例を見てみましょう。バックトラック法は、全ての解を試し、解が見つからない場合は一つ前の状態に戻る（つまり「バックトラック」する）という手法です。

この方法は、迷路の解を探すなど、全ての解候補を探索する必要がある問題に適しています。

バックトラック法を用いてN-クイーン問題を解くPythonプログラムを紹介します。

def solveNQueens(n):
    def can_place(pos, ocuppied_positions):
        for i in range(len(ocuppied_positions)):
            if ocuppied_positions[i] == pos or \
                    ocuppied_positions[i] - pos == i - len(ocuppied_positions) or \
                    ocuppied_positions[i] - pos == len(ocuppied_positions) - i:
                return False
        return True

    def placeQueen(n, index, ocuppied_positions):
        if index == n:
            return [ocuppied_positions]
        else:
            result = []
            for pos in range(n):
                if can_place(pos, ocuppied_positions):
                    result += placeQueen(n, index + 1, ocuppied_positions + [pos])
            return result

    return placeQueen(n, 0, [])

for solution in solveNQueens(4):
    print(solution)

このコードでは、N-クイーン問題を解くための関数solveNQueensを定義しています。

N-クイーン問題は、N×Nのチェス盤にN個のクイーンを互いに襲撃できないように配置するという問題です。

ここで「襲撃できない」とは、同じ行、列、対角線上に他のクイーンが存在しない状態を指します。

この問題を解くために、再帰関数placeQueenを定義し、その中で別のヘルパー関数can_placeを使って、クイーンを置くことが可能かどうかを判断しています。

placeQueen関数は再帰的に呼び出され、可能なクイーンの配置をすべて生成します。

引数には、チェス盤の大きさn、現在考えている列のインデックスindex、そして既に配置したクイーンの位置のリストocuppied_positionsを受け取ります。

indexがnと等しくなった場合、それは全てのクイーンが正しく配置されたことを意味し、その配置を結果に追加します。

そうでなければ、現在の列について可能な全ての位置を試し、その位置にクイーンを配置できるかどうかをcan_place関数で確認します。

配置できる場合は、その位置をocuppied_positionsに追加して次の列に進みます。

配置できない場合は、その位置はスキップします。

この処理を全ての位置について行い、得られた全ての可能な解を結果に追加します。

このプログラムを実行すると、4クイーン問題の全ての解が出力されます。

各解はクイーンの位置のリストとして表示され、リストのインデックスがチェス盤の行、値が列を表します。

たとえば、[1, 3, 0, 2]は、最初のクイーンが1列目、2番目のクイーンが3列目、3番目のクイーンが0列目、最後のクイーンが2列目に配置されていることを意味します。

このようにして、バックトラック法を用いて全ての可能な解を見つけることができます。

バックトラック法は再帰を使って簡単に実装できますが、全ての可能な解を試すため、問題の大きさによっては時間がかかる可能性があります。

しかし、早期に解が見つからないことがわかった場合には、その部分の探索を打ち切ることができるため、全ての解候補を調べる必要がない場合には効率的です。

○サンプルコード7：再帰を使った動的計画法

Pythonで再帰関数を利用した動的計画法（DP）の手法を説明します。

動的計画法は、大きな問題を小さな部分問題に分解し、それぞれの部分問題の結果を保存しながら全体の解を導き出す手法です。

動的計画法を用いて「ナップサック問題」を解くPythonのサンプルコードを紹介します。

ナップサック問題とは、ナップサックに入る重量の上限と各品物の重さと価値が与えられたときに、ナップサックに入れる品物の価値の合計を最大化する組み合わせを見つけるという問題です。

def knapsack(W, wt, val, n):
    # メモ化用のテーブルを作成します
    K = [[0 for w in range(W+1)] for i in range(n+1)]

    for i in range(n+1):
        for w in range(W+1):
            if i == 0 or w == 0:
                K[i][w] = 0
            elif wt[i-1] <= w:
                K[i][w] = max(val[i-1] + K[i-1][w-wt[i-1]], K[i-1][w])
            else:
                K[i][w] = K[i-1][w]

    return K[n][W]

val = [60, 100, 120]
wt = [10, 20, 30]
W = 50
n = len(val)
print(knapsack(W, wt, val, n))  # 220

このコードでは、knapsack関数を用いてナップサック問題を解いています。

引数にはナップサックの重量制限W、各品物の重量のリストwt、各品物の価値のリストval、品物の総数nを受け取ります。

まずKという二次元リストを作成しています。このリストはメモ化のためのテーブルで、n+1行W+1列の二次元リストになります。

次に、2つのネストしたループを使って、品物とナップサックの重量に対してそれぞれ何を選択するかを決定します。

各品物について、その品物がナップサックに入るか（その品物の重量がナップサックの現在の重量制限以下であるか）どうかを確認します。

入る場合、その品物を選んだときの価値と選ばなかったときの価値の大きい方をK[i][w]に保存します。

入らない場合、その品物は選択肢から外れ、K[i][w]はその前の行、つまりその品物を除いた場合の最大価値が保存されます。

このプロセスを繰り返すことで、全ての品物と全ての重量制限について最適な選択を行い、最終的な最大価値をK[n][W]から得ることができます。

コードを実行すると、220と出力されます。

これは、与えられた品物のリストとナップサックの重量制限から得られる最大の価値を意味します。

このように動的計画法は、計算結果をメモ化しながら再帰的に問題を解決します。

これにより、重複する計算を省くことができ、計算効率を大幅に向上させることが可能です。

ただし、メモ化用のテーブルに必要なメモリ量は問題の大きさに比例するため、大規模な問題に対しては注意が必要です。

○サンプルコード8：ツリー構造の深さ優先探索

Pythonの再帰関数の使い方を理解する上で、非常に重要な応用例となるのが深さ優先探索（DFS）です。

深さ優先探索は、ツリーやグラフのようなデータ構造において、ある節点から始めて可能な限り深く探索し、進むことができなくなったら一つ前の節点に戻るという探索方法です。

特にツリー構造に対しては、前順（根→左の子→右の子）、中順（左の子→根→右の子）、後順（左の子→右の子→根）といった様々な訪問順序を用いることができます。

下記のコードでは、二分木の前順深さ優先探索を再帰関数で実行する例を示しています。

class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

def print_preorder(node):
    if node:
        print(node.data, end=' ')
        print_preorder(node.left)
        print_preorder(node.right)

root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)
root.left.right = Node(5)

print_preorder(root)  # 1 2 4 5 3

このコードではまず、Nodeというクラスを定義しています。

このクラスはツリーの節点を表現するためのもので、data（節点の値）、left（左の子）、right（右の子）の3つの属性を持ちます。

次にprint_preorder関数を定義しています。

この関数は節点を引数に取り、その節点から始まる部分木を前順で探索して各節点の値を出力します。

節点が存在する限り、まずその節点の値を出力し、次に左の子、右の子に対して同様の処理を再帰的に行います。

最後に、Nodeクラスを使って具体的なツリーを作成し、そのツリーに対してprint_preorder関数を適用しています。

具体的には、根節点（値は1）とその左右の子（それぞれ値は2と3）、さらに左の子の下に2つの子（それぞれ値は4と5）を持つツリーを作成し、このツリーに対して前順探索を行っています。

コードを実行すると、「1 2 4 5 3」と出力されます。

これは、前順探索の結果得られる節点の値の順序を示しています。

このように、Pythonの再帰関数を用いると、深さ優先探索といった複雑な探索アルゴリズムを簡潔に実装することができます。

しかしながら、再帰の深さが深くなるとスタックオーバーフローのリスクがあるため、大規模なデータ構造に対しては非再帰的な方法を検討する必要があるでしょう。

○サンプルコード9：再帰を使った分割統治法

再帰関数を用いて解くことが可能な問題の一つに分割統治法があります。

分割統治法とは、大きな問題を小さな部分問題に分割して解き、それらの結果を統合して元の問題の解を求めるという方法です。再帰関数は分割統治法にとても適しています。

なぜなら、分割統治法は自然に再帰的な形を持つからです。

ここでは、リストの最大値を見つけることを目的とした分割統治法を実装するコードを見ていきましょう。

def find_max(nums, left, right):
    if left == right:  # リストの要素が一つだけの場合
        return nums[left]

    mid = (left + right) // 2  # 中央のインデックスを求める
    max_left = find_max(nums, left, mid)  # 左半分の最大値を再帰的に求める
    max_right = find_max(nums, mid + 1, right)  # 右半分の最大値を再帰的に求める

    return max(max_left, max_right)  # 左右の最大値の大きい方を返す

nums = [1, 3, 5, 7, 6, 4, 2]
print(find_max(nums, 0, len(nums) - 1))  # 7

このコードではfind_max関数を定義しています。

この関数はリストnumsとその範囲を指定するleft、rightを引数にとり、その範囲内の最大値を返します。

リストの要素が一つだけの場合（left == rightの場合）、その要素が最大値であるためそのまま返します。

リストの要素が複数ある場合、リストを中央で二つに分割し、左半分と右半分のそれぞれの最大値を再帰的に求めます。

そして、それらの最大値のうち大きい方を返すことで、元のリスト全体の最大値を求めます。

最後に、具体的なリストnumsを用意し、その最大値をfind_max関数で求めています。

このリストは1から7までの整数を含んでおり、その最大値である7が正しく出力されます。

分割統治法はリストの長さを半分ずつに分割していくため、計算量はO(log n)となり、非常に効率的です。

しかしながら、再帰の深さが深くなるとスタックオーバーフローのリスクがあるため、その点は注意が必要です。

○サンプルコード10：マージソートの実装

分割統治法の一つであるマージソートも再帰関数を使って実装することができます。

マージソートは大きなリストを半分ずつ小さなリストに分割し、それぞれをソートした後、マージ（統合）するという手法です。

def merge_sort(nums):
    if len(nums) <= 1:  # リストの長さが1以下ならそのまま返す
        return nums

    mid = len(nums) // 2  # 中央のインデックスを求める
    left = merge_sort(nums[:mid])  # 左半分を再帰的にソート
    right = merge_sort(nums[mid:])  # 右半分を再帰的にソート

    return merge(left, right)  # ソート済みの左半分と右半分をマージ


def merge(left, right):
    result = []  # 結果を格納するリスト
    i, j = 0, 0  # 左右のリストを走査するインデックス

    # 左右のリストがどちらも走査を終えるまでループ
    while i < len(left) and j < len(right):
        if left[i] < right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1

    # 左右のリストのどちらかが先に走査を終えた場合、残った要素を結果に追加
    while i < len(left):
        result.append(left[i])
        i += 1
    while j < len(right):
        result.append(right[j])
        j += 1

    return result  # ソート済みのリストを返す

nums = [6, 4, 8, 9, 2, 1, 7, 5, 3]
print(merge_sort(nums))  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

上記のコードでは、まずmerge_sort関数を定義しています。

この関数はリストnumsを引数にとり、そのリストをマージソートでソートした結果を返します。

リストの長さが1以下の場合、すでにソート済みであると考え、そのままリストを返します。

リストの長さが2以上の場合、リストを中央で二つに分割し、それぞれを再帰的にソートします。

そして、ソート済みの左半分と右半分をmerge関数でマージします。

次にmerge関数を定義しています。

この関数はソート済みのリストleftとrightを引数にとり、これらをマージした結果を返します。

leftとrightの先頭から要素を比較し、小さい方を結果のリストに追加します。

どちらかのリストが先に走査を終えた場合、残ったリストの要素をすべて結果に追加します。

最後に、具体的なリストnumsを用意し、そのリストをmerge_sort関数でソートしています。

このリストは1から9までの整数を含んでおり、それらが正しく昇順にソートされて出力されます。

マージソートは最悪でも平均でもO(n log n)の計算量で動作します。

しかし、空間計算量はO(n)となり、リストの長さに比例して追加のメモリが必要となることを注意する必要があります。

●再帰関数の注意点と対策

再帰関数は強力なツールであり、多くの複雑な問題を解決するのに役立ちます。

しかし、適切に扱わないとパフォーマンスの問題を引き起こす可能性があります。

その主な理由の一つが「スタックオーバーフロー」です。

プログラムが再帰呼び出しを行うと、それぞれの呼び出し情報（ローカル変数、戻りアドレスなど）がスタックに積まれます。

再帰が深くなるとスタックが一杯になり、最終的にはスタックオーバーフローが発生します。

これはプログラムのクラッシュを引き起こす可能性があるため、注意が必要です。

ここで、再帰呼び出しの深さをチェックし、ある深さを超えた場合にエラーメッセージを出力するサンプルコードを紹介します。

def recursive_function(n, max_depth=5):
    if n > max_depth:
        raise ValueError(f"再帰の深さが最大値{max_depth}を超えました。")
    else:
        print(f"再帰の深さ: {n}")
        recursive_function(n+1, max_depth)

try:
    recursive_function(0, 5)
except ValueError as e:
    print(e)

上記のコードでは、再帰関数recursive_functionを定義しています。

引数nは現在の再帰の深さを表し、max_depthは再帰の深さの最大値を表します。

関数内部で、現在の再帰の深さが最大値を超えた場合にはValueErrorを発生させています。

このコードを実行すると、”再帰の深さが最大値5を超えました。”というエラーメッセージが表示されます。

このように、再帰の深さが許容値を超えた時にエラーを出力することで、スタックオーバーフローを防ぐことができます。

次に、再帰関数による計算結果をキャッシュ化（メモ化）することで、同じ計算を繰り返し行う問題を解決する手法を紹介します。

ここでフィボナッチ数列を生成する再帰関数の例を挙げて説明します。

def fib(n, memo={0: 0, 1: 1}):
    if n not in memo:
        memo[n] = fib(n-1) + fib(n-2)
    return memo[n]

print(fib(10))  # 55

上記のコードでは、fibという再帰関数を定義し、フィボナッチ数列のn番目の値を計算しています。

ただし、この関数ではキャッシュmemoを用いて既に計算した結果を保存しています。

そのため、同じ計算を繰り返し行うことなく、効率的に結果を得ることができます。

これらの対策を適切に利用することで、再帰関数のパフォーマンス問題を大幅に軽減することが可能です。

●再帰関数のカスタマイズ方法

再帰関数はその特性上、様々な方法でカスタマイズすることが可能です。

具体的には、再帰関数の戻り値を操作することで、より高度な操作を行うことができます。

ここでは、再帰関数を用いてリスト内の全ての要素を平坦化する操作を行う方法を説明します。

ネストされたリストをフラットなリストに変換する再帰関数のサンプルコードを紹介します。

def flatten(lst):
    result = []
    for i in lst:
        if isinstance(i, list):
            result.extend(flatten(i))
        else:
            result.append(i)
    return result

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

上記のコードでは、flattenという再帰関数を定義しています。

この関数は引数としてネストされたリストlstを受け取り、その全ての要素をフラットなリストに変換して返します。

リスト内の各要素に対して、もし要素がリスト（つまりネストされている）であれば、再帰的にそのリストをフラット化します。そうでなければ、要素を結果のリストresultに直接追加します。

このコードを実行すると、[1, 2, 3, 4, 5, 6, 7]というフラットなリストが出力されます。

このように、再帰関数を用いて複雑なデータ構造を操作することが可能です。

以上のように、再帰関数は多様な問題に対応するための柔軟性を持っています。

適切な設計と実装によって、再帰関数を強力なツールとして活用することが可能です。