まだ命令的にプログラミングをしていますか? Python 関数プログラミングを使用すると、コードがよりエレガントになります。

ラムダ式は Python 言語の重要な機能であり、単純な匿名関数を定義するために使用できます。ラムダ式は、高階関数、リスト内包表記、辞書内包表記、デコレータなどのシナリオでよく使用されます。ラムダ式は通常、単純な関数定義にのみ適しており、複雑な関数定義は通常、def ステートメントを使用して定義する必要があることに注意してください。

ラムダ式の定義

ラムダ式は、関数の使用が想定される単純な関数を定義する匿名関数です。ラムダ式の構文は次のとおりです。

lambda arguments: expression

このうち、引数は関数のパラメータリストを表し、カンマで区切って複数のパラメータを指定できます。式は関数の戻り値の式を表し、任意の式を指定できます。

ラムダ式を使用したサンプルコードは次のとおりです。

my_list = [1, 2, 3, 4, 5]
result = map(lambda x: x*2, my_list)
print(list(result))

上記のコードでは、ラムダ式を使用して匿名関数を定義し、それを map() 関数に渡しました。

ラムダ式の応用シナリオ

ラムダ式は、1 回限り使用する単純な関数を定義するためによく使用されます。たとえば、map()、reduce()、filter() などの高階関数を使用する場合、ラムダ式を使用してマッピング、リデュース、フィルタリングの関数を定義できます。

ラムダ式を使用したサンプルコードは次のとおりです。

my_list = [1, 2, 3, 4, 5]
result = filter(lambda x: x%2==0, my_list)
print(list(result))

上記のコードでは、ラムダ式を使用してリスト内の偶数の要素をフィルターする関数を定義し、それを filter() 関数に渡しました。

ラムダ式の制限

ラムダ式は通常、単純な関数定義にのみ適しており、複雑な関数定義は通常、def ステートメントを使用して定義する必要があります。ラムダ式には式を 1 つだけ含めることができ、その式の結果が関数の戻り値になります。ステートメント演算子または代入演算子はラムダ式では使用できません。

以下は、ラムダ式を使用できないサンプルコードです。

def my_function():
    print("My function")
    return 1

my_lambda = lambda: (print("My lambda"), 1)[1]
result = my_lambda()
print(result)

上記のコードでは、print ステートメントと return ステートメントを含む関数 my_function() を定義しました。ラムダ式を使用して同じ関数を定義しようとしましたが、ラムダ式には 1 つの式しか含めることができないため、三項式を使用して return ステートメントをシミュレートしました。

ラムダ式の高度な使用法

ラムダ式は、リスト内包表記、辞書内包表記、デコレータなどの他の Python 言語機能と組み合わせて使用できます。

ラムダ式とリスト内包表記を使用したコード例を次に示します。

my_list = [1, 2, 3, 4, 5]
result = [(lambda x: x*2)(x) for x in my_list]
print(result)

上記のコードでは、ラムダ式とリスト内包表記を使用して、元のリストの 2 倍の数の要素を含む新しいリストを作成します。

第二に、Python の高階関数

高階関数は Python 関数プログラミングにおける重要な概念であり、コードをより柔軟にし、コードの重複を減らすことができます。Python で一般的に使用される高階関数には、map()、reduce()、filter() などが含まれます。関数は、他の関数に引数として渡すことも、戻り値として呼び出し元に返すこともできます。高階関数は通常、ラムダ式を使用して関数を定義する必要があり、ラムダ式を使用して単純な匿名関数を定義できることに注意してください。

高階関数の定義

高階関数とは、関数を引数として受け取ったり、結果として関数を返したりできる関数です。Python には、map()、reduce()、filter() などのいくつかの高階関数が組み込まれています。

次に、map() 関数を使用したサンプルコードを示します。

my_list = [1, 2, 3, 4, 5]
result = map(lambda x: x*2, my_list)
print(list(result))

上記のコードでは、map() 関数を使用してリストの要素を 2 で乗算し、list() 関数を使用して結果をリストに変換しています。

よく使われる高階関数

Python で一般的に使用される高階関数には次のものがあります。

map() 関数: 関数とシーケンスをパラメータとして受け取り、その関数をシーケンス内の各要素に適用して、新しいシーケンスを返します。

次に、map() 関数を使用したサンプルコードを示します。

my_list = [1, 2, 3, 4, 5]
result = map(lambda x: x*2, my_list)
print(list(result))

上記のコードでは、map() 関数を使用してリストの要素を 2 で乗算し、list() 関数を使用して結果をリストに変換しています。

reduce() 関数: 関数とシーケンスをパラメータとして受け取り、その関数を使用してシーケンス内の要素を単一の値に削減します。

以下は、reduce() 関数を使用したコード例です。

from functools import reduce

my_list = [1, 2, 3, 4, 5]
result = reduce(lambda x, y: x+y, my_list)
print(result)

上記のコードでは、reduce() 関数を使用してリスト内の要素を蓄積し、蓄積された結果を返します。

filter() 関数: 関数とシーケンスをパラメーターとして受け取り、その関数を使用してシーケンス内の適格な要素をフィルターで除外し、新しいシーケンスを返します。

filter() 関数を使用したサンプルコードを次に示します。

my_list = [1, 2, 3, 4, 5]
result = filter(lambda x: x%2==0, my_list)
print(list(result))

上記のコードでは、filter() 関数を使用してリスト内の偶数要素をフィルターし、list() 関数を使用して結果をリストに変換しました。

パラメータとして機能する

Python では、関数を引数として他の関数に渡すことができます。この使用法により、コードがより柔軟になり、コードの重複が減ります。

関数を引数として使用するサンプルコードを次に示します。

def my_function(x):
    return x*2

def apply_function(f, lst):
    return [f(x) for x in lst]

my_list = [1, 2, 3, 4, 5]
result = apply_function(my_function, my_list)
print(result)

上記のコードでは、数値を 2 で乗算する関数 my_function() を定義しました。次に、関数とリストをパラメータとして受け取り、その関数をリスト内の各要素に適用して、新しいリストを返す関数 apply_function() を定義します。最後に、my_function() 関数と my_list リストを apply_function() 関数に渡し、その結果を result 変数に保存します。

戻り値としての関数

Python では、関数を戻り値として呼び出し元に返すこともできます。この使用法によりコードがより柔軟になり、さまざまな状況に応じてさまざまな関数を返すことができます。

関数を戻り値として使用するコード例を次に示します。

def get_math_function(operation):
    if operation == '+':
        return lambda x, y: x+y
    elif operation == '-':
        return lambda x, y: x-y
    elif operation == '*':
        return lambda x, y: x*y
    elif operation == '/':
        return lambda x, y: x/y

my_function = get_math_function('*')
result = my_function(2, 3)
print(result)

上記のコードでは、パラメーターに応じて異なる関数を返す関数 get_math_function() を定義しました。次に、パラメータ '*' を渡して get_math_function() 関数を呼び出し、返された関数を my_function 変数に保存します。最後に、my_function() 関数を呼び出し、パラメータとして 2 と 3 を渡し、結果を result 変数に保存します。

3.Functoolsモジュール

functools モジュールは、いくつかの高階関数と関数プログラミングツールを提供する Python 標準ライブラリのモジュールです。このモジュールを使用して、関数のカリー化、部分関数、キャッシュなどの関数を実装できます。functools モジュールで一般的に使用される関数には、partial() 関数、lru_cache() 関数、wraps() 関数、cmp_to_key() 関数などが含まれます。通常、より複雑な機能を実現するには、functools モジュール内の関数を他の関数と一緒に使用する必要があることに注意してください。

functools モジュールの概要

functools モジュールは、いくつかの高階関数と関数プログラミングツールを提供する Python 標準ライブラリのモジュールです。このモジュールを使用して、関数のカリー化、部分関数、キャッシュなどの関数を実装できます。

functools モジュールを使用したコード例を次に示します。

import functools

def my_function(x, y):
    return x*y

my_partial = functools.partial(my_function, y=2)
result = my_partial(3)
print(result)

上記のコードでは、functools モジュールのpartial() 関数を使用して部分関数 my_partial を作成し、my_function 関数の 2 番目のパラメーターを 2 に固定します。次に、my_partial() 関数を呼び出し、my_function() 関数の最初のパラメータとして 3 を渡し、結果を result 変数に保存します。

部分関数()

Partial() 関数は、部分関数を作成するための functools モジュール内の関数です。部分関数とは、関数の一部のパラメーターを修正して新しい関数を返すことを指します。

以下は、partial() 関数を使用したサンプルコードです。

import functools

def my_function(x, y):
    return x*y

my_partial = functools.partial(my_function, y=2)
result = my_partial(3)
print(result)

上記のコードでは、partial() 関数を使用して部分関数 my_partial を作成し、my_function 関数の 2 番目のパラメーターを 2 に固定します。次に、my_partial() 関数を呼び出し、my_function() 関数の最初のパラメータとして 3 を渡し、結果を result 変数に保存します。

lru_cache() 関数

lru_cache() 関数は functools モジュールの関数であり、キャッシュの作成に使用されます。これにより、関数呼び出しの結果をキャッシュして計算の繰り返しを回避できます。

以下は、lru_cache() 関数を使用したサンプルコードです。

import functools

@functools.lru_cache()
def my_function(x):
    print("Calculating...")
    return x*x

result = my_function(2)
print(result)

result = my_function(2)
print(result)

上記のコードでは、lru_cache() 関数を使用して、my_function() 関数呼び出しの結果をキャッシュするキャッシュを作成します。次に、引数として 2 を渡して my_function() 関数を呼び出し、結果を result 変数に保存します。my_function() 関数が 2 回目に呼び出されるときは、以前に計算されているため、結果はキャッシュから直接取得され、計算は実行されません。

ラップ()関数

Wraps() 関数は functools モジュール内の関数で、デコレータを定義するために使用されます。デコレータは、デコレータ関数の __name__、doc、__module__ およびその他の属性をデコレータ関数にコピーするために使用されます。

以下は、wraps() 関数を使用したサンプルコードです。

import functools

def my_decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print("Before...")
        result = func(*args, **kwargs)
        print("After...")
        return result
    return wrapper

@my_decorator
def my_function(x):
    """
    This is my function.
    """
    return x*x

result = my_function(2)
print(result)
print(my_function.__name__)
print(my_function.__doc__)

上記のコードでは、デコレーター my_decorator を定義します。これは、装飾された関数の実行の前後に情報を出力するために使用されます。次に、wraps() 関数を使用して、装飾された関数のプロパティをデコレータ関数にコピーします。最後に、関数 my_function を my_decorator で修飾し、その関数を呼び出します。

cmp_to_key() 関数

cmp_to_key() 関数は、古いスタイルの比較関数を key 関数に変換する functools モジュール内の関数です。Python 2.x では、比較関数は 2 つの要素のサイズを比較するために使用されますが、Python 3.x では、比較関数は削除され、key 関数に置き換えられました。

以下は cmp_to_key() 関数を使用したサンプルコードです。

import functools

def my_compare(x, y):
    if x < y:
        return -1
    elif x > y:
        return 1
    else:
        return 0

my_list = [5, 3, 2, 8, 7]
my_key = functools.cmp_to_key(my_compare)
my_list.sort(key=my_key)
print(my_list)

上記のコードでは、2 つの要素のサイズを比較する古いスタイルの比較関数 my_compare を定義します。次に、 cmp_to_key() 関数を使用して、この関数をキー関数 my_key に変換します。最後に、my_list.sort() 関数を使用し、my_key をパラメータとして渡して my_list を並べ替えます。

4. Python ジェネレーター

ジェネレーターは、データを動的に生成できる特別な種類のイテレーターであり、関数またはジェネレーター式を通じて作成できます。ジェネレーターには、遅延コンピューティング、無限シーケンス、ストリーム処理などの利点があり、大量のデータの処理、無限シーケンスの生成、コルーチンや非同期プログラミングの実装などに使用できます。ジェネレーターは 1 回しか反復できず、スライス操作は使用できず、時間内に閉じる必要があることに注意してください。

ジェネレーターの定義

ジェネレーターは、最初にすべてのデータを生成するのではなく、ループ内でデータを動的に生成する特別な種類のイテレーターです。ジェネレーターは、関数またはジェネレーター式を使用して作成できます。

ジェネレーター式を使用してジェネレーターを作成するコードの例を次に示します。

my_generator = (x*x for x in range(10))
print(list(my_generator))

上記のコードでは、ジェネレーター式を使用して、0 から 9 までの正方形を動的に生成し、list() 関数を使用してリストに変換できるジェネレーター my_generator を作成します。

発電機の仕組み

ジェネレーターの動作原理は、次のように簡単に説明できます。ジェネレーターの __next__() メソッドが呼び出されるたびに、次の yield ステートメントまで実行され、ステートメントの値が返されます。すべての yield ステートメントが実行されると、ジェネレーターは自動的に StopIteration 例外をスローし、反復の終了を示します。

以下は、yield ステートメントを使用してジェネレーターを作成するコード例です。

def my_generator():
    for i in range(10):
        yield i*i

gen = my_generator()
print(list(gen))

上記のコードでは、yield ステートメントを使用して関数内にジェネレーターを作成しました。ジェネレーターの __next__() メソッドが呼び出されるたびに、次の yield ステートメントまで実行され、そのステートメントの値が返されます。最後に、list() 関数を使用してジェネレーターをリストに変換します。

発電機の利点

ジェネレーターには次の利点があります。

遅延計算: ジェネレーターは最初にすべてのデータを生成するのではなく、必要な場合にのみデータを生成するため、メモリ領域を大幅に節約できます。
無限シーケンス: ジェネレーターを使用して、フィボナッチ数列、素数シーケンスなどの無限シーケンスを生成できます。
ストリーミングに使用可能: ジェネレーターは、大きなファイルやネットワークデータなどの読み取りなど、大量のデータのストリーミングに使用できます。

ジェネレーターを使用して大きなファイルを処理するコード例を次に示します。

def read_file(file_path):
    with open(file_path) as f:
        for line in f:
            yield line.strip()

for line in read_file("large_file.txt"):
    process(line)

上記のコードでは、ジェネレーター read_file() を定義します。これは、大きなファイルを読み取り、毎回 1 行のデータを返すために使用されます。次に、for ループを使用してジェネレーターを走査し、データの各行を処理します。

発電機の応用シナリオ

ジェネレーターは次のシナリオで使用できます。

大きなファイル、ネットワークデータなどの大量のデータを処理します。
フィボナッチ数や素数などの無限数列を生成します。
asyncio ライブラリを使用して非同期 IO 操作を実装するなど、コルーチンと非同期プログラミングを実装します。
ジェネレーターを使用して、パイプとフィルターのパターンを実装することもできます。たとえば、ジェネレーターを使用して Unix パイプを実装することもできます。

ジェネレーターに関する注意事項

ジェネレーターには多くの利点がありますが、次の点にも注意する必要があります。

ジェネレーターは 1 回のみ反復可能: 反復が完了すると StopIteration 例外が自動的にスローされるため、ジェネレーターは 1 回のみ反復できます。
ジェネレーターはスライス操作を使用できません。ジェネレーターは遅延評価されるため、スライス操作は使用できません。使用しないと、ジェネレーターが途中で終了します。
ジェネレーターは時間内に閉じる必要があります。ジェネレーターは使用後に時間内に閉じる必要があります。そうしないと、リソースリークやメモリリークなどの問題が発生する可能性があります。

5. Python デコレータ

デコレーターは、関数またはクラスの機能を変更または拡張するために使用される Python 言語の糖衣構文です。デコレータ自体は関数をパラメータとして受け取り、新しい関数を返す関数であり、新しい関数は元の関数の呼び出しの前後にいくつかの追加の演算を実行し、最終的に元の関数の戻り値を返します。デコレータは、ログ、タイマー、キャッシュ、権限制御、再試行メカニズム、その他のシナリオを記録するために使用できます。デコレータを使用する場合は、関数の定義と呼び出し規則、デコレータのパラメータ、ネストされた使用、元の関数のメタ情報の保持に注意する必要があります。

デコレータの定義

デコレーターは、関数またはクラスの機能を変更または拡張するために使用される Python 言語の糖衣構文です。デコレーターは、元の関数またはクラスを変更することなく、追加の機能を動的に追加できます。

以下は、デコレータを使用して関数の機能を強化するサンプルコードです。

def my_decorator(func):
    def wrapper():
        print("Before function call")
        func()
        print("After function call")
    return wrapper

@my_decorator
def my_function():
    print("Inside function")

my_function()

上記のコードでは、関数呼び出しの前後に情報を出力するデコレーター my_decorator を定義しています。次に、 @my_decorator 構文シュガーを使用して、デコレーターを関数 my_function に適用します。

デコレーターの仕組み

デコレータの動作原理は次のように簡単に説明できます。デコレータ自体は関数であり、パラメータとして関数を受け取り、新しい関数を返します。新しい関数は元の関数の呼び出しの前後に追加の操作を実行します。最後に元の関数の戻り値を返します。

以下は、デコレータを使用して関数の機能を強化するサンプルコードです。

def my_decorator(func):
    def wrapper():
        print("Before function call")
        func()
        print("After function call")
    return wrapper

@my_decorator
def my_function():
    print("Inside function")

my_function()

上記のコードでは、デコレータ my_decorator は関数を引数として受け取り、新しい関数ラッパーを返します。my_function() 関数が呼び出されると、実際にはwrapper() 関数が呼び出され、元の関数の呼び出しの前後に情報を出力し、元の関数を実行します。最後に、wrapper() 関数は元の関数の戻り値を返します。

デコレータの適用シナリオ

デコレータは次のシナリオで使用できます。

ログ: デコレーターを使用して、関数のパラメーター、戻り値、実行時間などの記録など、関数の呼び出しログを記録できます。
タイマー: デコレーターを使用してタイマーを実装し、関数の実行時間を計算できます。
キャッシュ: デコレータを使用してキャッシュを実装し、関数呼び出しの結果をキャッシュして計算の繰り返しを避けることができます。
アクセス制御: デコレーターを使用してアクセス制御を実装し、関数の呼び出しを特定のユーザーまたはロールのみに制限できます。
再試行メカニズム: デコレータを使用して再試行メカニズムを実装でき、関数呼び出しが失敗すると、自動的に複数回再試行されます。

以下は、デコレータを使用してキャッシュを実装するサンプルコードです。

import functools

def cache(func):
    cache_dict = {}
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        key = args + tuple(kwargs.items())
        if key not in cache_dict:
            cache_dict[key] = func(*args, **kwargs)
        return cache_dict[key]
    return wrapper

@cache
def my_function(x, y):
    print("Calculating...")
    return x*y

print(my_function(2, 3))
print(my_function(2, 3))

上記のコードでは、関数呼び出しの結果をキャッシュするキャッシュデコレータを定義します。次に、@cache 構文シュガーを使用してデコレーターを関数 my_function に適用します。

デコレータに関する注意事項

デコレータを使用する場合は、次の点に注意してください。

デコレーター自体も関数であるため、関数の定義と呼び出し規則に従う必要があります。
デコレータはパラメータを受け取ることができますが、パラメータを受け取るにはデコレータ内に別の関数層を定義する必要があります。
デコレータはネストできますが、関数呼び出しの順序に注意する必要があります。
デコレーターは functools.wraps() 関数を使用して、関数名、ドキュメント文字列などの元の関数のメタ情報を保存できます。

6. Python のリスト内包と辞書内包

リスト内包表記と辞書内包表記は、新しいリストと辞書を生成するための簡潔で強力な Python 構文です。どちらも、for ループを通じて反復可能なオブジェクトを反復処理し、各要素を操作し、結果を新しいリストまたは辞書に追加することで機能します。これらは、データのフィルタリング、データの変換、新しいリストや辞書の生成などに使用できます。リスト内包表記と辞書内包表記を使用する場合は、コードの読みやすさ、if 文の位置と条件、for 文の順序に注意する必要があります。

リスト内包の定義

リスト内包表記は、新しいリストを生成するための簡潔で強力な Python 構文です。リスト内包表記では、多くの場合、1 行のコードで複雑なリスト操作を実行できます。

以下は、リスト内包表記を使用して新しいリストを生成するコード例です。

my_list = [x*x for x in range(10)]
print(my_list)

上記のコードでは、リスト内包表記を使用して、0 から 9 までの正方形を含む新しいリストを生成します。

リスト内包表記の仕組み

リスト内包の動作原理は、for ループを通じて反復可能なオブジェクトを反復処理し、各要素を操作し、その結果を新しいリストに追加する、と簡単に説明できます。

以下は、リスト内包表記を使用して新しいリストを生成するコード例です。

my_list = [x*x for x in range(10)]
print(my_list)

上記のコードでは、for ループは 0 から 9 までの整数を繰り返し、各整数を 2 乗して、結果を新しいリストに追加します。

リスト内包表記の応用シナリオ

リスト内包表記は次のシナリオで使用できます。

データのフィルター: リスト内包表記を使用して、条件に基づいてリスト内のデータをフィルターできます。
データの変換: リスト内包表記を使用して、文字列のリストを整数のリストに変換するなど、リスト内のデータを変換できます。
新しいリストの生成: リスト内包表記を使用して、フィボナッチ数列や素数列などの新しいリストを生成できます。

以下は、リスト内包表記を使用して文字列のリストを整数に変換するコード例です。

my_list = ["1", "2", "3", "4", "5"]
new_list = [int(x) for x in my_list]
print(new_list)

上記のコードでは、リスト内包表記を使用して文字列リスト my_list 内の要素を整数に変換し、結果を新しいリスト new_list に保存します。

辞書理解の定義

辞書内包表記は、新しい辞書を生成するための簡潔で強力な Python 構文です。辞書内包表記は通常、1 行のコードで複雑な辞書操作を実行できます。

以下は、辞書内包表記を使用して新しい辞書を生成するコード例です。

my_dict = {x: x*x for x in range(10)}
print(my_dict)

上記のコードでは、辞書内包表記を使用して、0 ～ 9 の整数とその 2 乗を含む新しい辞書を生成します。

辞書内包の仕組み

辞書理解の動作原理は、for ループを通じて反復可能なオブジェクトを反復処理し、各要素を操作し、その結果を新しい辞書に追加する、と簡単に説明できます。

以下は、辞書内包表記を使用して新しい辞書を生成するコード例です。

my_dict = {x: x*x for x in range(10)}
print(my_dict)

上記のコードでは、for ループが 0 から 9 までの整数を繰り返し、各整数を 2 乗して、結果を新しい辞書に追加します。

辞書理解の応用シナリオ

辞書内包表記は、次のシナリオで使用できます。

データのフィルター: 辞書内包表記を使用して、条件に基づいて辞書内のデータをフィルターできます。
データの変換: 辞書内包表記を使用して、辞書内の文字列値を整数値に変換するなど、辞書内のデータを変換できます。
新しい辞書の生成: 辞書内包表記を使用して、リストを辞書に変換するなど、新しい辞書を生成できます。リストの要素は辞書のキーとして使用され、別の反復可能なオブジェクトの要素は値として使用されます。辞書の。

以下は、辞書内包表記を使用して辞書内の文字列値を整数値に変換するコード例です。

my_dict = {"a": "1", "b": "2", "c": "3", "d": "4", "e": "5"}
new_dict = {k: int(v) for k, v in my_dict.items()}
print(new_dict)

上記のコードでは、辞書内包表記を使用して、辞書 my_dict 内の文字列値を整数値に変換し、結果を新しい辞書 new_dict に保存します。

リスト内包表記と辞書内包表記に関する注意事項

リスト内包表記と辞書内包表記を使用する場合は、次の点に注意してください。

リスト内包表記と辞書内包表記はネストできますが、コードの読みやすさに注意する必要があります。
リスト内包表記と辞書の導出は、if ステートメントを使用してフィルター処理できますが、if ステートメントの位置と条件に注意する必要があります。
リスト内包表記と辞書内包表記は、複数の for ステートメントを使用してネストすることができ、for ステートメントの順序に注意する必要があります。

7. Python の関数型プログラミングライブラリ

Python には関数型プログラミングライブラリが多数あり、各ライブラリには独自の特徴と適用可能なシナリオがあります。このうち、functools と itertools は Python 標準ライブラリの一部であり、直接インポートして使用でき、関数は比較的単純ですが、toolz、fn.py、および PyMonad はインストールする必要があり、いくつかの高度な関数型プログラミング機能を提供します。いくつかの複雑な関数型プログラミングのシナリオ向け。関数型プログラミングライブラリを使用する場合、最適なプログラミング効果を実現するには、特定のシナリオに応じて適切なライブラリを選択する必要があります。

以下に、一般的に使用される関数型プログラミングライブラリとその機能、使用法の違い、使用シナリオ、利点と欠点などを示します。

関数ツール

機能的な役割: 関数を簡単に操作できる、partial、reduce、wraps などのいくつかの高次関数を提供します。
使用上の違い: functools は Python 標準ライブラリの一部であり、インストールせずに直接インポートして使用できます。
使用シナリオ: 関数のカリー化、関数のデコレーター、関数のメタ情報の保存などのシナリオで使用できます。
メリット：インストール不要、使いやすく、機能が豊富。
短所: この関数は比較的単純なので、一部の複雑な関数プログラミングシナリオには適していません。

イターツール

機能的な役割: 積、順列、組み合わせなど、反復子を簡単に生成できるいくつかの反復子関数を提供します。
使用上の違い: itertools は Python 標準ライブラリの一部であり、インストールせずに直接インポートして使用できます。
使用シナリオ: 順列と組み合わせ、デカルト積、ループ反復、その他のシナリオを生成するために使用できます。
メリット：インストール不要、使いやすく、機能が豊富。
欠点: 一部のイテレータ関数のみが提供されているため、一部の複雑な関数プログラミングシナリオには適していません。

ツールズ

機能的な役割: 関数を簡単に操作できる、curry、compose、pipe などのいくつかの高次関数を提供します。
使用上の違い: tools をインストールする必要がありますが、pip install tools などの pip コマンドを使用してインストールできます。
使用シナリオ: 関数のカリー化、関数の組み合わせ、遅延計算などのシナリオで使用できます。
利点: 一部の複雑な関数プログラミングシナリオに適した、いくつかの高度な関数プログラミング関数を提供します。
短所: インストールする必要があり、使用するのが少し複雑です。

fn.py

機能的な役割: 関数を簡単に操作できる、curry、compose、zip_with などのいくつかの高次関数を提供します。
使用上の違い: fn.py をインストールする必要がありますが、pip install fn などの pip コマンドを使用してインストールできます。
使用シナリオ: 関数のカリー化、関数の組み合わせ、遅延計算、遅延シーケンスなどのシナリオで使用できます。
利点: 一部の複雑な関数プログラミングシナリオに適した、いくつかの高度な関数プログラミング関数を提供します。
短所: インストールする必要があり、使用するのが少し複雑です。

ピモナド

機能的役割: モナドパターンを簡単に実現できる、Maybe、Either、State などのいくつかの基本的なモナド型を提供します。
使用上の違い: PyMonad をインストールする必要があります。pip install PyMonad などの pip コマンドを使用してインストールできます。
使用シナリオ: モナディックパターン、関数型プログラミングの例外処理、状態管理などのシナリオを実装するために使用できます。
利点: モナドパターンの実装を容易にするために、いくつかの基本的なモナド型を提供します。
短所: この関数は比較的単純なので、一部の複雑な関数プログラミングシナリオには適していません。