関数型プログラミングとは

関数型プログラミングとは、数学的な関数の概念に基づき、副作用を避け、関数の合成や高階関数を中心としてプログラミングをするスタイルのことです。

プログラミング言語には、手続き型言語、オブジェクト指向言語、関数型言語といったものがあります。関数型プログラミング言語は、関数型プログラミングに特化した言語で、代表的な言語にHaskell、Scala、F#、Lispなどがあります。

Pythonはマルチパラダイム言語のため、手続き型やオブジェクト指向のプログラミングだけでなく、関数型スタイルのプログラミングにも対応しています。

本記事では、まず関数型プログラミングや関数型プログラミング言語全般の特徴を紹介し、Pythonにおける関数型プログラミングの方法について紹介しようと思います。Pythonでの関数型プログラミングの方法にのみ興味がある方は、関数型プログラミングの説明部分は読み飛ばしてもらっても構いません。

関数とは

関数型プログラミング言語に限らず、ほとんどのプログラミングでは関数が出てきます。では、関数型プログラミングでいうところの「関数」とはいったい何でしょうか。関数型プログラミングを勉強する際にはこの部分をしっかりと理解しておく必要があります。

関数型プログラミングでいうところの「関数」は、以下の特性を持つ数学的な概念を指します。

上記は、与えられた入力のみから出力が決まるということを意味しています。3つ目の特徴は、参照透過性として有名です。

Pythonをはじめ、多くのプログラミング言語では、引数を受け取らない、または返却値を返さない関数を作ることができますが、これは数学的な意味での関数とは厳密には異なります。

関数型プログラミングの特徴

関数型プログラミングでは、プログラムは「関数」であるという見方をし、プログラムは関数合成(function composition)したものと捉えます。

関数合成とは、ある関数$f$と関数$g$があった時に、入力$x$に対して$(f \circ g)=f(g(x))$とできることを言います。$g$の値域(出力の取り得る値全体からなる集合)が、$f$の定義域(入力の取り得るの値全体からなる集合)におさまっていれば関数は合成できることになります。

関数型プログラミングでは、小さな関数から関数を合成していくことで大きなプログラムを実現していくことになるわけですが、以下のようないくつかの特徴があります。

• プログラムを手続きではなく関数合成で表現する
• 関数を変数として扱うことができる
• 関数は入力値と返却値を持ち、返却値は入力にのみ依存する（参照透過性）
• 関数の副作用を許可しない
• 形式手法と定理証明でプログラムの数学的な証明ができる

以降では関数型プログラミングの上記の特徴について説明してみたいと思います。

プログラムを手続きではなく関数合成で表現する

関数型プログラミングがC言語などの手続き型言語と異なるのは、手続きを列挙するのではなく関数を順に適用した関数合成で宣言的に結果を実現する点です。

例えば、リストの中の数値をそれぞれ2乗して、すべてを足し合わせる問題を考えたとしましょう。Pythonで、手続き的にプログラミングする場合と、関数の合成でプログラミングする場合の例を以下に示します。

【手続きで書く場合】初期化、ループ、状態変更を用いる

target = [1, 2, 3, 4, 5]

# 手続きで書く場合
sum_value = 0
for d in target:
    sum_value += d**2
print(sum_value)

【実行結果】
55

【関数で書く場合】高階関数を用いてデータ変換と合成を行う

from functools import reduce


def add_nums(x, y):
    """値を足し算する"""
    return x + y


def square(x):
    """値を2乗する"""
    return x**2


target = [1, 2, 3, 4, 5]

# 関数で書く場合
sum_value = reduce(add_nums, map(square, target))
print(sum_value)

【実行結果】
55

上記のプログラムは、計算結果としてはどちらも55となります。

手続き的にプログラムを記載する場合には、合計用の変数sum_valueを0で初期化し、for文で、targetというリストの中の要素を順に変数dに取込み、dを2乗してsum_valueに足しこんでいくという書き方をしています。処理の過程で変数dやsum_valueの値が変化していくのが特徴です。

一方で、関数で記載する場合の例では、値を足し算するadd_nums関数と値を2乗するsquare関数を用意しています。関数型プログラミングでは「targetの各要素をsquareで2乗し、結果をadd_numsで足し込む」を関数合成の要領で「reduce(add_nums, map(square, target))」という1行で記載しています。

mapはリストの各要素に関数を適用するための関数で、reduceはリストの要素を使って関数で畳み込むための関数ですが、詳細は後に紹介します。

関数型の書き方では、状態を変化させるようなコードがないことが特徴的です。関数型プログラミングでは、入力に対する出力の性質を宣言的に書くことで、コードの見通しが良くなるという特徴があります。

関数を変数として扱うことができる

関数型プログラミングでは、値を変数に入れることと同じようにして関数を変数に入れて扱うことができます。変数の中身は値の場合もありますし、関数自体の場合もあります。

また、関数の引数として関数を渡したり、関数の返却値として関数を返すといったこともできます。このことは、高階関数やデコレータといった機能に関連します。

関数は入力値と返却値を持ち、返却値は入力にのみ依存する（参照透過性）

関数型プログラミングにおける関数は、数学的な意味での関数なので、引数として入力値と返却値を持ち、入力値にのみに依存します。このように入力値のみから返却値が決まる特徴を参照透過性と言い、関数型プログラミングで重要なものとなっています。

以下で参照透過である関数とそうでない関数を見てみましょう。

【参照透過である関数】

def square(x):
    """値を2乗する"""
    return x**2


if __name__ == "__main__":
    print(square(2))
    print(square(2))
    print(square(3))
    print(square(3))

【実行結果】
4
4
9
9

【参照透過ではない関数】

global_value = 0


def func():
    global global_value
    global_value += 1

    return global_value


if __name__ == "__main__":
    print(func())
    print(func())
    print(func())

【実行結果】
1
2
3

square関数は、引数として受け取ったxの値を2乗して返却する関数で、x=2であれば4ですし、x=3であれば9と常に同じ結果を返します。このような関数は参照透過であると言います。

一方で、参照透過ではないfunc関数は呼び出すたびに返却値の値が異なっています。このように呼び出しのたびに結果が変わるようなものは、数学的な意味での関数とは言えません。

関数の副作用を許可しない

プログラミングにおいて副作用というのは非常に重要な概念です。副作用とは、処理が外部の状態や環境に影響を与えるような変更を指します。変数の変更、ファイルの入出力、ネットワーク通信などは、代表的な副作用の例と言えます。例外送出も状態を変更することから一種の副作用と言えます。

関数型プログラミング言語では、こういった副作用を許可しないような仕組みが多く取り込まれています。関数型プログラミング言語では、変数に値を設定すると値を変更できないか、もしくは非常に限定されています。このような性質は値の不変性と言いますが、この特徴は副作用を避けるためのものと言えます。

関数型プログラミングでは、プログラミングの範囲を以下のように「副作用のないもの」「副作用のあるもの」で区別して考えることが重要です。副作用を持つような手続きは、数学的な意味での関数とは言えません。

どのように副作用のあるものを扱うかというと、例えば、純粋関数型言語のHaskellではモナドという仕組みを使って副作用を扱います。詳細は割愛しますが、ここでは関数型プログラミング言語では、副作用を許さないような仕組みで言語が成り立っているということを理解してもらえればと思います。

形式手法と定理証明でプログラムの数学的な証明ができる

関数型プログラミング言語に関連している事項として形式手法と定理証明というものがあります。

形式手法とは、プログラムやシステムを形式的なモデルや仕様で記述する手法で、抽象的なレベルで設計や検証を行うことで問題やバグを事前に特定できるような技術です。特に鉄道分野、航空分野、金融・セキュリティ分野など、システムの不具合が人命や人の生活に多大に影響を及ぼすような分野で使用されています。

一方、定理証明とは、形式手法で作成されたモデルや仕様を元に証明を行うための技術です。定理証明を使用してプログラムの性質を確認することにより、形式手法で設計されたモデルや仕様の妥当性が検証され、プログラムが正しい振る舞いを持つことをテストを行わずに示すことができます。ただし、テストが不要という極端なことを言っているわけではありませんので注意してください。

一般に定理証明は簡単ではなく、十分に行えるプログラマも多くはないと言われています。私もこの領域のレベルの技術領域については知っているだけで、十分な理解は得られていません。数学に基づく言語であるからこそ、こういったことに対応できるというのが関数型プログラミング言語の大きな特徴と言えます。興味がある方は勉強してみるといいでしょう。

Pythonで関数型プログラミング

Pythonはマルチパラダイム言語であるため、関数型プログラミングスタイルを使うことができます。

関数型プログラミングには、プログラムの見通しが良くなるなどの特徴があり、紹介してきたような特徴を活かすため、Pythonでも関数型プログラミングを意識したコーディングができるようになることは、プログラムの質を向上させるための役に立つと思います。

ただし、Pythonが厳密な意味で関数型プログラミングの制約を課すわけではないことに注意が必要です。Pythonで関数型プログラミングをしようとすると、例えば関数としての制約を満たせているか、関数の定義域と値域の関係性が問題ないかなどをプログラマが考慮する必要があります。

一方で、Haskellなどの関数型プログラミング言語では、言語としての学習コストが高いものの、関数型プログラミングとしてのチェックを言語がしてくれるためプログラマがその点を考える必要はありません。そのため、本当の意味で関数型プログラミングをしたい場合は、Haskellなどの関数型プログラミング言語を採用するのが適切でしょう。

Pythonによる関数型プログラミング

以降では、Pythonで関数型スタイルでプログラミングする方法を説明します。独立したページで詳しく整理しているため、関連ページへのリンクを中心に紹介します。

ラムダ関数（無名関数）

関数型プログラミングとラムダ関数は、非常に密接な関係性を持つ概念です。関数中心のプログラミングスタイルである関数型プログラミングにおいてラムダ関数は核となる概念ともいえます。なお、ラムダ関数は、関数名を持たないことから無名関数とも呼ばれます。

ラムダ関数は、関数を直接表現する手段として関数型プログラミングにおいて非常に重要です。ラムダ関数を変数に代入して使用したり、関数を引数に取る高階関数の引数として渡して使うことができます。

Pythonにおけるラムダ関数は「ラムダ（lambda）関数：無名関数の使い方」を参考にしてください。

高階関数の使用

高階関数とは、関数自体を引数／返却値として扱う関数を言います。関数型プログラミングの領域でよく使われる高階関数は、Python組み込み関数やfunctoolsモジュールで実装がされています。以降では、それらの関数について紹介します。

map関数

map関数は、関数と処理対象のイテラブルなオブジェクト(リスト等)を受け取って、イテラブルなオブジェクトの各要素に関数を適用した結果を返却するPythonの組み込み関数です。map関数は関数型プログラミング言語で特徴的で重要な関数です。

map関数の詳細な使い方は「map関数の使い方の基本 ~リスト要素への関数適用~」を参考にしてください。

filter関数

filter関数は、関数と処理対象のイテラブルなオブジェクト(リスト等)を受け取って、特定の条件を満たす要素を抽出するPythonの組み込み関数です。filter関数は、関数型プログラミング言語でも特徴的で重要な関数です。

filter関数の詳細な使い方は「filter関数の使い方の基本 ~リストから条件を満たす要素を抽出~」を参考にしてください。

reduce関数

reduce関数は、関数と処理対象のイテラブルなオブジェクト(リスト等)を受け取って、リストの要素を指定した関数を使って畳み込む関数です。

もともとreduce関数は、Python2でmap関数やfilter関数同様にPythonの組み込み関数でしたが、Python3からはfunctoolsモジュールに移動しています。

reduce関数の詳細な使い方は「reduce関数の使い方の基本 ~リスト要素の畳み込み~」を参考にしてください。

partial関数

関数の部分適用というのは、数学やプログラミングにおいて重要な概念です。部分適用は、ある関数に対して一部の引数を固定して新しい関数を作る手続きのことを言います。

partial関数は、関数と固定する引数の値を受け取ることで関数の部分適用をすることができる関数です。partial関数は、functoolsモジュールの中に含まれています。

partial関数の詳細な使い方は「partial関数の使い方の基本 ~関数の部分適用~」を参考にしてください。

デコレータ

Pythonのデコレータは、関数型プログラミングのアイデアを利用して関数を変更したり、拡張したりするための仕組みです。「@関数名」として使うのがデコレータの表記となっています。ここでの関数は、引数に関数を受け取って関数を返却するような高階関数です。

デコレータの使い方はデコレータ（decorator）の基本的な使い方を参考にしてください。

ジェネレータ

ジェネレータは、プログラム内で逐次的に値を生成するための仕組みです。値を一つずつ取得することができ、途中で停止したり再開したりすることが可能なため、無限のデータ列を表現できます。関数型プログラミングでもジェネレータが利用される点で関連があります。

Pythonでジェネレータを使う方法は「ジェネレータ（generator）関数 ~yieldによる返却~」を参考にしてください。また、ジェネレータは内包表記で表現することも可能です。ジェネレータ内包表記の使い方は「ジェネレータ（generator）内包表記の使い方」を参考にしてください。

型ヒント（型アノテーション）

関数型プログラミングをする場合には型の情報というのは重要なものです。関数型プログラミング言語には、型検査や型推論といったものがあることからも重要性が分かります。

Pythonは動的型付け言語であるため、型の指定は必要はありません。そのため、型が適切に使われているかといった判断をすることは難しいです。

しかし、Pythonではバージョン3.5から型ヒントがサポートされており、変数や関数に型アノテーションとして型情報を指定できるようになっています。また、この型ヒントを元にした型チェックを行うmypyというサードパーティ製のライブラリも存在します。これらをうまく使うことで関数型プログラミング言語のように型チェックを行うことが可能です。

型ヒントについては「型ヒント（変数・関数の型アノテーション）の基本」を参考にしてください。また、mypyについても「mypyを使用した型チェックの方法」にまとめていますので興味があれば参考にしてください。

まとめ

Pythonはマルチパラダイム言語のため、関数型スタイルのプログラミングにも対応しています。本記事では、関数型プログラミング概要を紹介するとともにPythonで関数型スタイルのプログラミングをする方法について解説しました。

関数型プログラミングは、プログラムの見通しが良くなるなどのメリットがあるため、Pythonでも関数型プログラミングを意識したコーディングをすることで、プログラムの質が向上する可能性があります。

ただし、Pythonが厳密な意味で関数型プログラミングの制約を全面的に課すことができるわけではないことに注意が必要です。本当の意味で関数型プログラミングを追求したい場合は、Haskellなどの関数型プログラミング言語を採用を検討することをおすすめします。

あわせて読みたい

【Python Tech】プログラミングガイド

reduce関数で要素を畳み込む

reduce 関数は、関数と処理対象のイテラブルを受け取り、そのイテラブルの要素を指定した関数を使って畳み込むための関数です。

このように引数に関数を受け取る関数は高階関数と言います。for 文で処理しても同じ処理ができますが、繰り返し処理を書かずにシンプルに記載できる点がメリットです。

reduce 関数は、Python 2 では map 関数や filter 関数同様に Python の組み込み関数でした。しかし、Python 3 からは functools モジュールに移動したため、この関数を使用する際には functools のインポートが必要となりました。

reduce 関数は関数型プログラミング言語でも中心的な関数です。一部の言語では fold という関数名が使われていることもあります。Python はマルチパラダイムの言語と言われているため、厳密ではありませんが関数型のプログラミングスタイルもサポートしており、reduce 関数が利用できます。

本記事では、リストを使った例を用いて、reduce 関数の使い方の基本を紹介します。

reduce 関数の基本的な使い方

reduce 関数の基本的な構文は以下のようになります。

from functools import reduce

result = reduce(関数, イテラブル)

reduce 関数は functools モジュール内にあるためインポートが必要です。

reduce 関数は、イテラブルの要素を 1 つずつ取得し、それらの要素に累積的に指定した関数を適用して結果を畳み込んでいきます。例えば、関数 func とリスト [a, b, c, d] というものがあった時に reduce(func, [a, b, c, d]) は、func(func(func(a, b), c), d) と同じです。

よく reduce 関数と一緒に紹介される map 関数や filter 関数は返却値としてイテレータを返すため無限に続くシーケンスでも動作させることができます。もちろん list 等に変換しようとしたり、for でループするようなことをすれば終了しなくなります。

一方で、reduce 関数は計算のためにイテラブル内の全ての要素を評価しないといけないため、無限のシーケンスでは利用することはできませんので注意しましょう。

基本的な使い方

reduce 関数の基本的な使い方を以下の例を用いて見ていきましょう。

from functools import reduce


def add_nums(x, y):
    """値を足し算する"""
    return x + y


def multiply_nums(x, y):
    """値を掛け算する"""
    return x * y


if __name__ == "__main__":
    tmp_list = [1, 2, 3, 4, 5]

    # reduce関数でadd_nums関数を適用する
    result = reduce(add_nums, tmp_list)
    print(result)

    # reduce関数でmultiply_nums関数を適用する
    result = reduce(multiply_nums, tmp_list)
    print(result)

【実行結果】
15
120

上記の例では、受け取った値を足し算する add_nums 関数と掛け算をする multiply_nums 関数を用意し、tmp_list の各要素に順に関数を適用しています。

reduce 関数を呼び出している部分では「reduce(add_nums, tmp_list)」というように関数と処理対象のリストを渡しています。ここでポイントは、関数を渡す際に () がないことです。関数は add_nums(1, 2) のように () で引数を指定すると関数を実行することを意味しますが、() がない場合は関数そのものを表します。reduce 関数は、受け取った add_nums や multiply_nums といった関数を内部で実行しているわけです。

reduce 関数で add_nums と tmp_list を実行した場合、具体的に計算している内容としては「((((1+2)+3)+4)+5) = 15」です。同様に multiply_nums の場合は、「((((1*2)*3)*4)*5) = 120」となります。

このような計算を畳み込みといい reduce 関数を用いることで、リストの要素に順に関数を適用して計算することができます。

ラムダ関数（無名関数）と組み合わせる場合

reduce 関数は、ラムダ関数（無名関数）と組み合わせることで、より手軽に畳み込み計算をすることができます。ラムダ関数は、関数定義を def で定義することなく、その場で作れるもので関数型プログラミングでは中核の概念です。

add_nums 関数や multiply_nums 関数をラムダ関数にして使う例を見てみましょう。

from functools import reduce

tmp_list = [1, 2, 3, 4, 5]

# reduce関数でラムダ関数を使って足し算を適用する
result = reduce(lambda x, y: x + y, tmp_list)
print(result)

# reduce関数でラムダ関数を使って掛け算を適用する
result = reduce(lambda x, y: x * y, tmp_list)
print(result)

【実行結果】
15
120

これまでの例で add_nums 関数を指定した部分で「lambda x, y: x + y」というラムダ関数で置き換えて指定しています。また、同様に multiply_nums の代わりに「lambda x, y: x * y」としています。結果は add_nums 関数や multiply_nums 関数を使った場合と同じです。

ラムダ関数は無名関数ともいわれる通り、関数名はありませんが、そのものが関数として扱われるため、reduce 関数に渡すことでリスト要素に対して畳み込みができます。

まとめ

Python で reduce 関数を使って要素を畳み込む方法を解説しました。

reduce 関数は、関数と処理対象のイテラブルを受け取り、そのイテラブルの要素を指定した関数を使って畳み込むための関数です。reduce 関数は関数型プログラミング言語でも中心的な関数ですが Python でも使用できます。

reduce 関数は、Python 3 からは functools モジュールに移動したため、この関数を使用する際には functools のインポートが必要になります。

reduce 関数は for 文を用いなくてもシンプルに関数の畳み込みができることが特徴です。非常に強力な機能ではありますが、reduce 関数の適用が常に最適な選択というわけではありません。

場合によっては for 文で書いた方が可読性が上がる可能性もあります。目的に応じて適切に方法を選択できるように reduce 関数の使い方を理解しておくようにしましょう。

あわせて読みたい

【Python Tech】プログラミングガイド

filter 関数で条件を満たす要素を抽出する

filter 関数は、関数と処理対象のイテラブルを受け取って、特定の条件を満たす要素を抽出する Python の組み込み関数です。

このように引数に関数を受け取る関数は高階関数と言います。for 文でも同じ処理ができますが、繰り返し処理を書かずともシンプルに記載できる点がメリットです。

filter 関数は、関数型プログラミング言語においてよく使用される代表的な関数です。Python はマルチパラダイムの言語と言われているため、厳密ではありませんが関数型プログラミングのスタイルもサポートしており、filter 関数が組み込み関数として利用できます。

この記事では、リストの要素を関数で評価してフィルタする例を用いて、filter 関数の使い方の基本を紹介します。

filter 関数の基本的な使い方

filter 関数の基本的な構文は以下の通りです。

result = filter(関数, イテラブル)

filter 関数は、イテラブル の各要素に 関数 を適用し、条件を満たす要素を抽出（フィルタ）した結果のイテレータを返却します。フィルタされた結果は next を用いることで順に取り出したり、for 文で繰り返し取り出して使用したりすることができます。

後述の例でも紹介しますが、list(filter(関数, イテラブル)) のようにすることでリストに変換して取得することも可能です。ただし、大きなサイズのフィルタ結果の場合は、リストに変換しない方が効率的である場合もあるので注意して使用してください。

filter 関数は条件を満たす要素の抽出が目的のため、引数に指定する関数 は「与えられた要素に対して真偽を評価できる値を返却する必要がある」点に注意してください。

基本的な使い方

filter 関数の基本的な使い方を以下の例を用いて見ていきましょう。

def is_even(num):
    """数値が偶数か判定する"""
    return num % 2 == 0


if __name__ == "__main__":
    tmp_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

    # filter関数を適用し、イテレータを取得
    result = filter(is_even, tmp_list)
    print(result, "\n")

    # nextで1要素ずつ結果データを取得
    print(next(result))
    print(next(result))
    print(next(result))
    print(next(result))
    print(next(result))

【実行結果】
<filter object at 0x000001FA10FB45E0> 

2
4
6
8
10

例では、受け取った数値が偶数かどうかを判定する is_even 関数が定義されており、tmp_list の各要素が偶数かどうかをフィルタしています。

filter 関数を呼び出している部分では「filter(is_even, tmp_list)」というように関数と処理対象のリストを渡しています。ここで、関数を渡す際には () をつけないことがポイントです。関数は is_even(2) のように () で引数を指定すると関数を実行することを意味しますが () がない場合は関数そのものを表します。filter 関数は、受け取った is_even という関数を内部で実行しているわけです。

また、filter 関数は条件を満たす要素を抽出することが目的であるため、フィルタの判定ができるように is_even 関数は True / False を返却しています。

filter 関数の返却値は「filter object」となっていますが、これはイテレータの一種です。next 関数を使用することで次の要素を順番に取得することができます。この例では、tmp_list の要素で偶数である数値が順に取得されていることが分かります。

【実行結果】
Traceback (most recent call last):
...(省略)...
StopIteration

リストやタプルで取得する方法

filter 関数の返却値はイテレータであるため、以下のように list や tuple に変換することができます。

def is_even(num):
    """数値が偶数か判定する"""
    return num % 2 == 0


if __name__ == "__main__":
    tmp_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

    # filter関数を適用し、リストで取得
    result = list(filter(is_even, tmp_list))
    print(result)

    # filter関数を適用し、タプルで取得
    result = tuple(filter(is_even, tmp_list))
    print(result)

【実行結果】
[2, 4, 6, 8, 10]
(2, 4, 6, 8, 10)

関数に None を指定する方法

filter 関数では、関数 として設定する引数に None を指定することが可能です。その場合は、フィルタ対象の要素が truthy である要素のみ抽出します。truthy とは、if 文で True と判定される値のことです。（None や 0、空文字列 ""、空のリスト [] などは False 扱いとなり抽出されません。）

以下の例で確認してみましょう。

tmp_list = [0, 1, "", "Hello", [], [1, 2, 3], None, True, False]

# None を指定すると要素の truthy/falsy で判定される
result = list(filter(None, tmp_list))
print(result)

【実行結果】
[1, 'Hello', [1, 2, 3], True]

例のように、関数として None を指定することで truthy となる値のみがフィルタできることが分かります。欠損値や空データをお手軽に取り除く方法として使用できます。

ラムダ関数（無名関数）と組み合わせる方法

filter 関数では、ラムダ関数（無名関数）と組み合わせることで、より手軽に条件を満たす要素を抽出することができます。ラムダ関数は、関数定義を def で定義することなく、その場で作れるもので関数型プログラミングでは非常によく使われる概念です。

is_even 関数をラムダ関数にして filter 関数で使う例を見てみましょう。

tmp_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# filter関数を適用し、リストで取得
result = list(filter(lambda x: x % 2 == 0, tmp_list))
print(result)

# filter関数を適用し、タプルで取得
result = tuple(filter(lambda x: x % 2 == 0, tmp_list))
print(result)

【実行結果】
[2, 4, 6, 8, 10]
(2, 4, 6, 8, 10)

これまでの例で is_even と関数を指定していた部分に「lambda x: x % 2 == 0」というラムダ関数を指定しています。結果は is_even 関数を使った場合と同じです。

ラムダ関数は無名関数ともいわれる通り、関数名はありませんが、そのものが関数として扱われるため、filter 関数に渡すことでリストの各要素に関数を適用してフィルタした結果を取得できます。

まとめ

Python の組み込み関数である filter 関数を使って条件を満たす要素を抽出する方法を解説しました。

filter 関数は、関数と処理対象のイテラブルを受け取って、特定の条件を満たす要素を抽出する Python の組み込み関数です。filter 関数は他の関数型プログラミング言語でもよく使用される代表的な関数で Python でも使用できます。

filter 関数は for 文を用いなくてもシンプルに関数で条件判定するフィルタ処理ができることが特徴です。

非常に強力な機能ではありますが、filter 関数の適用が常に最適な選択というわけではありません。場合によっては for 文で書いた方が可読性が上がる可能性もあります。目的に応じて適切に方法を選択できるよう filter 関数の使い方を理解しておくようにしましょう。

あわせて読みたい

【Python Tech】プログラミングガイド

map 関数で要素へ関数を適用する

map 関数は、関数と処理対象のイテラブルを受け取って、イテラブルの各要素に関数を適用した結果を返す Python の組み込み関数です。

このように引数に関数を受け取る関数は高階関数と言います。for 文で処理しても同じ処理ができますが、繰り返し処理を書かずにシンプルに記載できる点がメリットです。

map 関数は、関数型プログラミング言語において中心的な関数です。Python はマルチパラダイムの言語と言われているため、厳密ではありませんが関数型のプログラミングスタイルもサポートしており、map 関数が組み込み関数として利用できます。

本記事では、リストの要素へ関数を適用する例を用いて、map 関数の使い方の基本を紹介します。

map 関数の基本的な使い方

map 関数の基本的な構文は以下のようになります。

result = map(関数, イテラブル)

複数の引数を取る関数を指定する場合には、以下のようにイテラブルを列挙して指定することができます。

result = map(関数, イテラブル1, イテラブル2, ...)

map 関数では、イテラブルの各要素に関数を適用した結果のイテレータを返却します。イテレータは値を逐次取り出せるオブジェクトで、nextを用いることで順に関数を適用した値を取り出したり、for 文で使用したりすることができます。後述の例でも見ますが、list(map(関数, イテラブル)) のようにすることでリストに変換して取得することも可能です。

また、map(関数, イテラブル1, イテラブル2, ...)というように複数のイテラブルを渡す場合には、関数は引数としてイテラブルの数だけ受け取れる必要があります。

基本的な使い方

map 関数の基本的な使い方を以下の例を用いて見ていきましょう。

def square(x):
    """値を2乗する"""
    return x**2


if __name__ == "__main__":
    tmp_list = [1, 2, 3, 4, 5]

    # map関数を適用し、イテレータを取得
    result = map(square, tmp_list)
    print(result, "\n")

    # nextで1要素ずつ結果データを取得
    print(next(result))
    print(next(result))
    print(next(result))
    print(next(result))
    print(next(result))

【実行結果】
<map object at 0x0000018E82BC2A70> 

1
4
9
16
25

上記の例では、受け取った値を 2 乗する square という関数が定義されており、tmp_list の各要素に適用しています。

map 関数を呼び出している部分では「map(square, tmp_list)」というように関数と処理対象のリストを渡しています。ここでポイントは、関数を渡す際に () がないことです。関数は square(2) のように () で引数を指定すると関数を実行することを意味しますが、() がない場合は関数そのものを表します。map 関数は、受け取った square という関数を内部で実行しているわけです。

map 関数の返却値は「map object」となっていますが、これはイテレータの一種です。next 関数を使用することで次の要素を順番に取得することができます。この例では、tmp_list の要素それぞれを2乗した結果が順に取得されていることが分かります。

【実行結果】
Traceback (most recent call last):
...(省略)...
StopIteration

リストやタプルで取得する場合

map 関数の返却値はイテレータであるため、以下のように list や tuple に変換することができます。

def square(x):
    """値を2乗する"""
    return x**2


if __name__ == "__main__":
    tmp_list = [1, 2, 3, 4, 5]

    # map関数を適用し、リストで取得
    result_list = list(map(square, tmp_list))
    print(result_list)

    # map関数を適用し、タプルで取得
    result_tuple = tuple(map(square, tmp_list))
    print(result_tuple)

【実行結果】
[1, 4, 9, 16, 25]
(1, 4, 9, 16, 25)

複数イテラブルを指定する場合

map 関数は複数のイテラブルを受け取り、それらに対してまとめて関数を適用することができます。以下の例では、make_variable_set という関数が 3 つの引数を受け取り、それらをタプルとして返す動作をします。

def make_variable_set(x, y, z):
    """各引数を並べたタプルを返却する"""
    return x, y, z


if __name__ == "__main__":
    nums1 = [1, 2, 3]
    nums2 = [4, 5, 6]
    nums3 = [7, 8, 9]

    # map関数で複数のイテラブルを渡す
    # 関数側もイテラブルの数だけの引数を受け取れる必要がある
    result = list(map(make_variable_set, nums1, nums2, nums3))
    print(result)

【実行結果】
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]

この結果を見ると、3 つのリストの各要素が関数によってタプルとしてまとめられて返されていることが確認できます。

複数のイテラブルの要素数が異なる場合

map 関数を使用する際、複数のイテラブルを指定することができますが、それらの要素数が異なる場合の挙動に注意が必要です。

具体的には、map 関数は、最も短いイテラブルの要素数に合わせて処理を行います。これは最も短いイテラブルが終了した時点で、他のイテラブルの残りの要素は無視されることを意味します。

def make_variable_set(x, y, z):
    """各引数を並べたタプルを返却する"""
    return x, y, z


if __name__ == "__main__":
    nums1 = [1, 2, 3]
    nums2 = [4, 5, 6, 7, 8, 9]
    nums3 = [10, 11, 12, 13, 14]

    # map関数で複数のイテラブルを渡す
    # 最も短いイテラブルが消費されたら終了
    result = list(map(make_variable_set, nums1, nums2, nums3))
    print(result)

【実行結果】
[(1, 4, 10), (2, 5, 11), (3, 6, 12)]

この例では、3 つの要素を使用していますが、最も短いイテラブルである nums1 に合わせて処理が行われるため、nums2 の 7、8、9 や nums3 の 13、14 については結果に含まれていないことが分かります。

ラムダ関数（無名関数）と組み合わせる場合

map 関数は、ラムダ関数（無名関数）と組み合わせることで、より手軽に要素に対して関数を適用することができます。ラムダ関数は、関数定義を def で定義することなく、その場で作れるもので関数型プログラミングでは中核の概念です。

square 関数をラムダ関数にして map 関数で使う例を見てみましょう。

tmp_list = [1, 2, 3, 4, 5]

# map関数を適用し、リストで取得
result = list(map(lambda x: x**2, tmp_list))
print(result)

# map関数を適用し、タプルで取得
result = tuple(map(lambda x: x**2, tmp_list))
print(result)

【実行結果】
[1, 4, 9, 16, 25]
(1, 4, 9, 16, 25)

これまでの例で square と関数を指定していた部分に「lambda x: x**2」というラムダ関数を指定しています。結果は square 関数を使った場合と同じす。

ラムダ関数は無名関数ともいわれる通り、関数名はありませんが、そのものが関数として扱われるため、map 関数に渡すことでリストの各要素に関数を適用できます。

まとめ

Python の組み込み関数である map 関数を使って要素へ関数を適用する方法を解説しました。

map 関数は、関数と処理対象のイテラブルを受け取って、イテラブルの各要素に関数を適用した結果を返す Python の組み込み関数です。map 関数は他の関数型プログラミング言語でも中心的な関数で Python でも使用できます。

map 関数は for 文を用いなくてもシンプルに関数の適用ができることが特徴です。非常に強力な機能ではありますが、map 関数の適用が常に最適な選択というわけではありません。

場合によっては for 文で書いた方が可読性が上がる可能性もあります。目的に応じて適切に方法を選択できるよう map 関数の使い方を理解しておくようにしましょう。

あわせて読みたい

【Python Tech】プログラミングガイド

デコレータ（decorator）

デコレータとは、関数に機能を追加するための仕組みです。例えば、関数の実行時間を計測したり、ログを出力したりするなど、関数に依存しない汎用的な機能を簡単に付加できます。「飾る・装飾する」という意味から、デコレータは関数を装飾して機能を追加するものと理解してください。

この記事では、Python のデコレータの基本的な使い方について紹介します。また、理解を深めるために高階関数やクロージャについても説明します。

高階関数とクロージャ

デコレータは「高階関数での機能の拡張をシンプルに表現する記法」とも言えます。理解を助けるために、高階関数とクロージャについて説明します。

• 高階関数：関数を引数や戻り値として扱う関数
• クロージャ：上位のスコープの変数を保持する関数

以下の例では、高階関数を用いて、sum_range_value 関数に「実行時間を計測する機能」を追加しています。

import time


def measure_execution_time(func):
    def wrapper(*args, **kwargs):
        # 処理前の時刻を設定
        timer_start = time.time()
        # 対象関数の実行
        result = func(*args, **kwargs)
        # 処理後の時刻を設定
        timer_end = time.time()
        # 処理時間を計算
        elapsed_time = timer_end - timer_start
        print(f"処理実行時間: {elapsed_time} sec")
        return result

    return wrapper


def sum_range_value(start, end, step=1):
    result = 0
    for i in range(start, end + 1, step):
        result += i
    return result


def main():
    measure_func = measure_execution_time(sum_range_value)
    sum_value = measure_func(1, 1000000)
    print(sum_value)


if __name__ == "__main__":
    main()

【実行結果例】
処理実行時間: 0.044879913330078125 sec
500000500000

measure_execution_time 関数は、関数を引数として受け取り、wrapper 関数を返却します。このように、関数自体を引数や戻り値に持つ関数を高階関数と言います。

また、wrapper 関数は、measure_execution_time の引数である func を保持したまま返されるため、これをクロージャと呼びます。

呼び出しの流れでは measure_execution_time(sum_range_value) により sum_range_value が func に渡され、wrapper にセットされた状態で measure_func に返されます。measure_func は、wrapper 関数であり、その内部で func(*args, **kwargs) として元の sum_range_value が実行されます。

このように、高階関数によって関数の機能拡張を行うことができます。

デコレータの使い方

高階関数による機能拡張は、デコレータを使うことで簡単に実現できます。

import time
from functools import wraps


def measure_execution_time(func):
    """時間計測デコレータ関数

    Args:
        func: 対象関数

    Returns:
        wrapper関数
    """

    @wraps(func)
    def wrapper(*args, **kwargs):
        """内部ラッパー関数"""
        # 処理前の時刻を設定
        timer_start = time.time()
        # 対象関数の実行
        result = func(*args, **kwargs)
        # 処理後の時刻を設定
        timer_end = time.time()
        # 処理時間を計算
        elapsed_time = timer_end - timer_start
        print(f"処理実行時間: {elapsed_time} sec")
        return result

    return wrapper


@measure_execution_time
def sum_range_value(start, end, step=1):
    """範囲内の数値を合計する関数

    Args:
        start: 開始数値
        end: 終了数値
        step: ステップ値

    Returns:
        合計結果
    """
    result = 0
    for i in range(start, end + 1, step):
        result += i
    return result


def main():
    sum_value = sum_range_value(1, 1000000)
    print(sum_value)
    print(f"\ndocstring:\n{sum_range_value.__doc__}")


if __name__ == "__main__":
    main()

【実行結果例】
処理実行時間: 0.03454852104187012 sec
500000500000

docstring:
範囲内の数値を合計する関数

    Args:
        start: 開始数値
        end: 終了数値
        step: ステップ値

    Returns:
        合計結果

デコレータは関数定義の上に「@デコレータ名」と記述します。例えば @measure_execution_time とすることで sum_range_value 関数に実行時間の計測機能が付加されます。

このようにデコレータを使うことで関数の機能拡張が簡単に行えます。

デコレータ使用時の注意事項（メタ情報の保持）

デコレータを使用する際、オリジナル関数のメタ情報（docstringなど）が失われることがあります。この問題は functools の @wraps デコレータで解決できます。

@wraps(func)
def wrapper(*args, **kwargs):

@wraps デコレータを使用しない場合、メタ情報が以下のように wrapper 関数のものになってしまいますので注意が必要です。

【実行結果】
内部ラッパー関数

上記については「エキスパートPythonプログラミング」という書籍に記載があります。Python 応用編として色々な知見が得られますので参考にしてみてください。

複数のデコレータを重ねて使用する

デコレータは、複数重ねて使用ができます。以下は、measure_execution_time に加えて、関数名と引数情報を表示する show_function_info デコレータを追加した例です。

import time
from functools import wraps


def measure_execution_time(func):
    """時間計測デコレータ関数

    Args:
        func: 対象関数

    Returns:
        wrapper関数
    """

    @wraps(func)
    def wrapper(*args, **kwargs):
        """内部ラッパー関数"""
        # 処理前の時刻を設定
        timer_start = time.time()
        # 対象関数の実行
        result = func(*args, **kwargs)
        # 処理後の時刻を設定
        timer_end = time.time()
        # 処理時間を計算
        elapsed_time = timer_end - timer_start
        print(f"処理実行時間: {elapsed_time} sec")
        return result

    return wrapper


def show_function_info(func):
    """関数情報表示用デコレータ関数

    Args:
        func: 対象関数

    Returns:
        wrapper関数
    """

    @wraps(func)
    def wrapper(*args, **kwargs):
        """内部ラッパー関数"""
        print("--------------------------------------------------------------")
        print(f"Name: {func.__name__}")
        print(f"args: {args}")
        print(f"kwargs: {kwargs}")
        print("--------------------------------------------------------------")
        return func(*args, **kwargs)

    return wrapper


@measure_execution_time
@show_function_info
def sum_range_value(start, end, step=1):
    result = 0
    for i in range(start, end + 1, step):
        result += i
    return result


def main():
    sum_val = sum_range_value(1, 1000000)
    print(sum_val)


if __name__ == "__main__":
    main()

【実行結果例】
--------------------------------------------------------------
Name: sum_range_value
args: (1, 1000000)
kwargs: {}
--------------------------------------------------------------
処理実行時間: 0.044873714447021484 sec
500000500000

デコレータを複数適用する場合、上から順に適用され数学の合成関数のように measure_execution_time(show_func_info(sum_range_value)) となります。

このように、複数のデコレータを重ねることで関数の拡張が簡単に表現できます。

まとめ

Python のデコレータの基本的な使い方について解説しました。また、デコレータの理解の助けとなる高階関数とクロージャに関する考え方も紹介しています。

デコレータは「@デコレータ名」という表記を関数に付与するだけで簡単に関数に機能を付与することが可能です。ただし、functools の @wraps デコレータを使用しない場合、docstring などのメタ情報が内部関数のものになるので注意してください。

デコレータは、関数に対して汎用的な機能拡張を行う際に非常に便利な方法です。ぜひ使い方を覚えて活用してみてください。

あわせて読みたい

【Python Tech】プログラミングガイド