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】プログラミングガイド

lambda（ラムダ式、無名関数）

Pythonの lambda は、名前のない関数を簡単に作成するための構文です。名前がないため無名関数と呼ばれ、式として使えるためラムダ式とも呼ばれます。

lambda は、関数を第 1 級オブジェクトとして扱う関数型プログラミングのパラダイムに基づいており、Python はこの考え方を取り入れています。第 1 級オブジェクトとは、変数に代入したり、関数の引数や戻り値として使えるオブジェクトを言います。

lambda を使うメリットには以下の通りです。

• 小さな関数を def で宣言する必要がありません。
• 関数名の衝突を防げます。
• 1 行で記述ができ、コードがシンプルになります。
• 高階関数の引数として使用できます。

この記事では、lambda の使い方の基本を紹介していきます。

lambda の使い方

lambda は、以下のように定義して使用します。

lambda 引数1, 引数2, … : 返却値の計算式

lambda の後に受け取る引数を列挙し、: の後ろに返却値の計算式を記述します。例えば「lambda x, y: x + y」とすると x と y を足した結果を返すことを意味します。

基本的な使用方法

以下の簡単な使用例で lambda の使い方を確認しましょう。

# lambda function
func = lambda val1, val2: val1 * 2 + val2 * 2

print(type(func))
print(func(1, 2))
print(func(3, 4))

【実行結果】
<class 'function'>
6
14

上記の lambda は、val1 と val2 をそれぞれ 2 倍して足した値を返却する関数です。

lambda の返却値の func は <class 'function'> であり function クラスのオブジェクトです。このように Python では、関数も 1 つのオブジェクトとして扱います。

function オブジェクトである func は「func(1, 2)」のように () で引数を受け取ることで、関数を実行した値を返却することができます。

lambda を使用するメリット

lambda の使い方を紹介しましたが def で定義しても同じと思うかもしれません。lambda のメリットの 1 つは小さな関数をシンプルにその場で作成できる点です。

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

def sum_func_value(val_list1, val_list2, func):
    ret = []
    for v1, v2 in zip(val_list1, val_list2):
        ret.append(func(v1, v2))
    return ret


def main():
    l1 = [1, 2, 3, 4, 5]
    l2 = [6, 7, 8, 9, 10]

    ret_list1 = sum_func_value(l1, l2, lambda val1, val2: val1 + val2)
    print(f'ret_list1 = {ret_list1}')

    ret_list2 = sum_func_value(l1, l2, lambda val1, val2: 2 * val1 + 2 * val2)
    print(f'ret_list2 = {ret_list2}')

    ret_list3 = sum_func_value(l1, l2, lambda val1, val2: 3 * val1 + 3 * val2)
    print(f'ret_list3 = {ret_list3}')


if __name__ == '__main__':
    main()

【実行結果】
ret_list1 = [7, 9, 11, 13, 15]
ret_list2 = [14, 18, 22, 26, 30]
ret_list3 = [21, 27, 33, 39, 45]

上記の sum_func_value 関数は、受け取った 2 つのリストの各要素に対して func で指定された関数を適用したリストを返却する関数です。

呼び出し時には lambda によってリストの各要素に対してどのような計算をさせるのかを定義して関数として渡しています。もし、この関数を def で定義する場合、似たような関数をたくさん定義し、それぞれに関数名をつける必要があります。

このような小さな関数をその場で定義して使用するには lambda は非常に有用です。なお、sum_func_value 関数のように引数に関数を受け取る関数を高階関数と呼びます。

リストのソート条件を lambda で指定する

lambda のよくある使用例は、リストのソート条件を lamba で指定する方法です。lambda を sort や sorted の key 引数に指定して、カスタムのソート条件を指定できます。

具体的には「リストのソート方法」内で紹介しているので参考にしてください。

まとめ

Python の lambda の使い方 の基本について解説しました。

lambda は、名前のない関数をその場で簡単に作成するための構文です。名前がないため無名関数と呼ばれ、式として使えるためラムダ式とも呼ばれます。

lambda は、小さな関数を宣言することなく使用できるため、コードをシンプルに記述できるメリットがあります。また、高階関数の引数として使用するなど便利な使い方ができます。ぜひ、lambda を使いこなせるようになってもらえたらと思います。

あわせて読みたい

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

ジェネレータ関数とジェネレータ

Pythonにおけるジェネレータ関数とは、yield 文を使って値を返却する関数であり、その実行によってジェネレータというオブジェクトが作成されます。ジェネレータはイテレータの一種であり、逐次的に値を生成して返すオブジェクトのことを言います。なお、イテレータについては「イテレータの基本」を参考にしてください。

このため、ジェネレータを使うとシーケンス全体をメモリ上に展開せず、無限のシーケンスであっても必要な時に必要な値だけを生成することができ、メモリ使用量を大幅に削減できます。

この記事では、ジェネレータ関数とジェネレータについて基本の使い方を紹介します。

ジェネレータ関数の定義方法

ジェネレータ関数は、通常の関数とほぼ同じ定義方法ですが、return 文の代わりに yield 文を使用します。

# ジェネレータ関数
def generate_char():
    yield "A"
    yield "B"
    yield "C"


if __name__ == "__main__":
    gen = generate_char()
    print(type(gen))

    # Aが出力される
    print(next(gen))
    # Bが出力される
    print(next(gen))
    # Cが出力される
    print(next(gen))

【実行結果】
<class 'generator'>
A
B
C

上記のgenerate_char関数は、"A"、"B"、"C"という文字列を順に返すジェネレータ関数です。genはジェネレータのオブジェクト（<class 'generator'>）となります。

ジェネレータはイテレータの一種であり、__next__()メソッドが実装されているため、next関数を使って順番に値を取り出せます。

ジェネレータ関数はyield文まで実行され、その位置を記憶します。次に呼び出されると、その位置から実行を再開します。例えば、最初の呼び出しではyield "A"が実行され、次の呼び出しではyield "B"が実行されます。

yield "C"までが実行され、さらに次の呼び出しで返す値がなくなると、ジェネレータは、StopIteration例外を送出します。

ジェネレータはイテレータの一種のためfor文で使用できます。

# ジェネレータ関数
def generate_char():
    yield "A"
    yield "B"
    yield "C"


if __name__ == "__main__":
    # for文でのジェネレータ関数の使用
    for s in generate_char():
        print(s)

【実行結果】
A
B
C

上記結果のようにジェネレータが生成する値（"A"、"B"、"C"）を順に取り出せていることが分かります。

range をジェネレータ関数で実現する

Pythonのfor文では、数値シーケンスの生成にrangeをよく使用します。rangeはジェネレータ関数として実現されています。

ジェネレータ関数の使用方法を覚えるためにrangeと同じ動作をするジェネレータ関数を作ってみましょう。

# ジェネレータ関数でrangeと同じ動作を実現
def sample_range(start=0, stop=10, step=1):
    num = start
    while num < stop:
        yield num
        num += step


if __name__ == "__main__":
    iter_range = sample_range(0, 5)
    print(type(iter_range))
    print(next(iter_range))
    print(next(iter_range))
    print(next(iter_range))

    print("======================")
    for i in iter_range:
        print(i)

【実行結果】
<class 'generator'>
0
1
2
======================
3
4

上記のsample_range関数は、rangeと同じ動作をするジェネレータ関数です。iter_rangeは、ジェネレータのオブジェクト（<class 'generator'>）となっています。

そのため、nextで値を順に取り出せていることが分かります。また、途中で「"==="」のようなprintの中断を入れていますが、次の呼び出しでは後続の値から取り出しができていることが分かります。

ジェネレータ関数を使用することで、一度にメモリ上に展開できないような無限に続くような数列なども実現可能になります。

ジェネレータ内包表記

ジェネレータは、ジェネレータ内包表記というシンプルな記載方法でも生成することができます。ジェネレータ内包表記については「ジェネレータ内包表記の使い方」を参考にしてください。

まとめ

Pythonのジェネレータ関数とジェネレータの基本について解説しました。

ジェネレータ関数は、yield 文を使って値を返却する関数であり、ジェネレータオブジェクトを作成します。ジェネレータはイテレータの一種なので逐次的に値を生成することができます。この記事では、ジェネレータ関数の定義方法の例とジェネレータの使用例を紹介しました。

ジェネレータは一度にメモリ上に展開できないような無限に続くシーケンスを扱うこともできて便利です。ぜひ、使い方を覚えてもらいたいと思います。

あわせて読みたい

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

ジェネレータ内包表記
（generator comprehension）

Pythonにおけるジェネレータ内包表記（generator comprehension）は、既存リスト等のイテラブルなオブジェクトから、ジェネレータのオブジェクトを作成する際にシンプルに記載するための定義方法です。なお、ジェネレータについては「ジェネレータ関数とジェネレータの基本」を参考にしてください。

この記事では、ジェネレータ内包表記の基本的な使い方について紹介します。

ジェネレータ内包表記の使い方

ジェネレータ内包表記の構文は以下になります。

(式 for 仮変数 in イテラブルなオブジェクト if 条件)

上記の意味合いとしては、イテラブルなオブジェクトから要素を順番に仮変数に取得し、条件に一致するものに対して式を適用した値を返却するようなジェネレータオブジェクトを作るということになります。

なお、(で始まるのでタプル内包表記のように思われるかもしれませんが、タプル内包表記というものはありません。タプルにする場合は、変換するという作業が必要です。

ジェネレータ内包表記を使う場合

ジェネレータ内包表記を使用するには以下のようにします。

gen = (i for i in range(10) if i % 2 == 0)

print(type(gen))
for i in gen:
    print(i)

【実行結果】
<class 'generator'>
0
2
4
6
8

上記例では、2で割り切れる数値を生成するジェネレータを作成しています。genは、ジェネレータのオブジェクト（<class 'generator'>）となります。

ジェネレータオブジェクトは、イテレータの一種のため例のようにfor文で繰り返しに使用したり、next(gen)のように順に値を取り出して使用したりできます。

タプルやリストに変換したい場合

ジェネレータ内包表記では、ジェネレータのオブジェクトを生成します。タプルやリストに変換したい場合は、以下のように変換することが可能です。

# ジェネレータからタプルに変換
gen = (i for i in range(10) if i % 2 == 0)
tpl_tmp = tuple(gen)
print(type(tpl_tmp), tpl_tmp)

# ジェネレータからリストに変換
gen = (i for i in range(10) if i % 2 == 0)
list_tmp = list(gen)
print(type(list_tmp), list_tmp)

【実行結果】
<class 'tuple'> (0, 2, 4, 6, 8)
<class 'list'> [0, 2, 4, 6, 8]

ジェネレータはメモリを節約しながら無限シーケンスを扱えるため、タプルやリストに変換する際は、その利点が失われることを考慮し、変換の必要性を十分検討しましょう。

ジェネレータ内包表記を使用しないで記載する場合

ジェネレータ内包表記は、ジェネレータ関数として書き換えることが可能です。

# ジェネレータ関数で定義
def generate_num():
    for g in range(10):
        if g % 2 == 0:
            yield g


gen = generate_num()
print(type(gen))
for i in gen:
    print(i)

ジェネレータ内包表記の特徴と注意点

ジェネレータ内包表記は、処理をシンプルに記述できる点が特徴です。また、ジェネレータ内包表記は、Python内部で最適化されているため、一般的に実行速度も速くなります。特に、大きなデータセットやメモリ効率が重要な場合に積極的に採用するのが良いでしょう。ただし、処理速度は状況によって異なり、必ずしも常に早いとは限らないため、その点には注意が必要です。

また、ジェネレータ内包表記がコードを複雑にする場合は、使用を慎重に検討してください。特にチーム開発では、ソースコードの可読性が重要ですので、シンプルさと可読性のバランスを保つことが重要です。

まとめ

Pythonのジェネレータ内包表記（generator comprehension）の使い方について解説しました。

ジェネレータ内包表記は、イテラブルなオブジェクトからジェネレータのオブジェクトを作成する際にシンプルに記載するための定義方法です。この記事では、ジェネレータ内包表記の基本的な使い方や特徴と注意点を紹介しました。

Pythonにおける内包表記は他にも「リスト内包表記」「辞書内包表記」「集合内包表記」といったものがあります。内包表記については「内包表記（まとめ）」を参考にしてください。

あわせて読みたい

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

Pythonにおける関数

関数とは、特定の処理を実行するためのコードのまとまりのことです。適切な関数定義を行うことで、再利用可能なコードブロックとして様々な場所から必要な時に呼び出して処理を実行することができるようになります。

この記事では、Pythonにおける関数定義の基本を紹介します。また、関数では引数の扱いが重要です。様々な引数の種類や使い方についても詳細に説明します。

基本的な関数宣言

関数は、defを使って以下のように定義します。def は「定義する」の意味の define を意味する略となっています。

# 関数定義の基本
def print_hello_world():
    print("hello world!")


if __name__ == "__main__":
    print_hello_world()

【実行結果】
hello world!

上記例では、"hello world!"と表示する関数print_hello_worldを定義しています。関数を呼び出す際には、print_hello_world()というように呼び出すことが可能です。

関数の引数と返り値の宣言

関数は、引数を受け取り処理を実行し、結果を返り値として呼び出し元へ返却します。引数は関数の()内に記載をし、返り値についてはreturnを使用して返却します。

# 関数定義 引数、返却値
def func_2(num):
    return 2 * num


if __name__ == "__main__":
    x1 = 5
    y1 = func_2(x1)
    print(f"x1 = {x1}, y1 = {y1}")

    x2 = 10
    y2 = func_2(x2)
    print(f"x2 = {x2}, y2 = {y2}")

【実行結果】
x1 = 5, y1 = 10
x2 = 10, y2 = 20

上記例のfunc_2関数は受け取った数値を2倍にして返却する関数です。

関数定義の()内に引数となる変数を列挙すると関数内で使用することができます。関数定義での引数は仮引数と呼ばれ、呼び出し時に渡される引数は実引数と呼ばれます。

返却値を呼び出し元に返す場合には、returnを使用します。変数を指定するか、式を直接指定した場合は式が評価された結果が返却されます。返り値がない場合は、returnを省略した関数とするか、return Noneを用いることが一般的です。

関数の呼び出し時には、y1 = func_2(x1)のように呼び出しができます。実引数x1の値が関数の仮引数numに渡され処理が実行されます。もちろんdef func_values(x1, x2):のように複数の引数を受け取る関数を定義することも可能です。

関数の基本的な部分は以上となります。関数の引数にはいくつかの種類があるため、以降では、関数の引数の種類と使い方についてより詳細に説明します。

関数の引数の種類と使い方

関数の引数にはいくつかの種類や考え方があります。以降では「位置引数」「キーワード引数」「引数のデフォルト値」「*args」「**kwargs」といったトピックスについて詳細を説明していきます。

位置引数

位置引数（positional arguments）とは、関数を呼び出す際に引数の順番に基づいて値を渡す方法です。位置引数では、関数定義時に指定されている引数の順番に値を渡す必要があります。

def make_profile(first, last, birth):
    return {"first name": first, "last name": last, "birthday": birth}


if __name__ == "__main__":
    first_name = "Taro"
    last_name = "Python"
    birthday = "2021/1/1"

    # 位置引数にて指定
    profile = make_profile(first_name, last_name, birthday)
    print(profile)

    profile = make_profile(last_name, first_name, birthday)
    print(profile)

【実行結果】
{'first name': 'Taro', 'last name': 'Python', 'birthday': '2021/1/1'}
{'first name': 'Python', 'last name': 'Taro', 'birthday': '2021/1/1'}

上記例は、入力された名前(first_name)、苗字(last_name)、誕生日(birthday)を受け取って辞書にして返却するmake_profile関数です。

位置引数を使用する場合には、引数の位置と順番が非常に重要です。例えば、上記例で2回目に呼び出した際には、fist_nameとlast_nameの変数の指定位置が入れ替わっています。結果として、名前であるTaroが苗字として処理されてしまっています。

位置引数では、呼び出し時の順序が重要です。呼び出し順序を間違えると予期しない動作をする可能性がありますので十分に注意しましょう。

キーワード引数

キーワード引数（keyword arguments）とは、関数を呼び出す際に引数名を指定して値を渡す方法です。関数定義で指定された引数名に基づいて値を渡すため、順番に依存せずに引数を指定できることが特徴です。

def make_profile(first, last, birth):
    return {"first name": first, "last name": last, "birthday": birth}


if __name__ == "__main__":
    first_name = "Taro"
    last_name = "Python"
    birthday = "2021/1/1"

    # キーワード引数にて指定
    profile = make_profile(birth=birthday, last=last_name, first=first_name)
    print(profile)

【実行結果】
{'first name': 'Taro', 'last name': 'Python', 'birthday': '2021/1/1'}

上記例は、位置引数の説明時と同様の関数です。キーワード引数の呼び出しでは、「仮引数名=」という形で指定します。

キーワード引数では呼び出し時に仮引数名を指定するため順番は関係がなくなります。上記例でいうと、make_profile(birth=birthday, last=last_name, first=first_name)のように関数定義時の順序とは異なる順序で指定しているにも関わらず、結果は正しくなっていることが分かります。

引数のデフォルト値

関数は、引数として定義したものを呼び出し元で全て設定しないとエラーとなってしまいます。ただし、引数のデフォルト値を定義しておくことで、呼び出し元で引数の指定がなかった場合に、デフォルト値を代わりに設定して関数を実行することができます。

# デフォルト値を指定
def make_profile(first=None, last=None, birth=None):
    return {"first name": first, "last name": last, "birthday": birth}


if __name__ == "__main__":
    first_name = "Taro"
    last_name = "Python"
    birthday = "2021/1/1"

    # キーワード引数にて指定
    profile = make_profile(first=first_name, birth=birthday)
    print(profile)

    profile = make_profile(first=first_name, last=last_name, birth=birthday)
    print(profile)

【実行結果】
{'first name': 'Taro', 'last name': None, 'birthday': '2021/1/1'}
{'first name': 'Taro', 'last name': 'Python', 'birthday': '2021/1/1'}

引数のデフォルト値は「仮引数=デフォルト値」という形で定義します。呼び出し元で引数が指定された場合は、その値が使用されますが、指定がない場合はデフォルト値が使用されます。

なお、デフォルト値を設定する引数は、デフォルト値が設定されていない引数の後に定義する必要があるので注意してください。例えば、def make_profile(first=None, last, birth):といった定義はエラーとなります。

*args による任意個の位置引数の受け取り

関数の引数として任意の個数の引数を渡したい場合には、関数の引数として*argsを定義します。なお、argsという名称の使用は必須ではありませんが、Pythonを使っている人は通例としてargumentsを意味するargsという名称を使用します。

基本的な使い方

*argsによる引数の受け取りは以下のようにします。

# *argsによる位置引数の受け取り
def print_input(*args):
    print(type(args))
    for i, arg in enumerate(args):
        print(f"arg[{i}] = {arg}")


if __name__ == "__main__":
    print_input(1, 2, "A", "B", [1, 2])

【実行結果】
<class 'tuple'>
arg[0] = 1
arg[1] = 2
arg[2] = A
arg[3] = B
arg[4] = [1, 2]

*argsとして引数を設定した場合には、受け取った引数はタプルとなります。上記例では、print_input(1, 2, "A", "B", [1, 2])のように合計5つの引数を受け取ることができています。

通常の引数との組み合わせ

＊argsは、以下のように通常の引数と組み合わせて使用することができます。

def print_input(input1, input2, *args):
    print(input1)
    print(input2)
    for i, arg in enumerate(args):
        print(f'arg[{i}] = {arg}')


if __name__ == '__main__':
    print_input(1, 2, 'A', 'B', 'C')

【実行結果】
1
2
arg[0] = A
arg[1] = B
arg[2] = C

上記例では、input1、input2は位置引数として指定された順で値が設定され、残りの引数がすべてargsにまとめられていることが分かります。これにより、関数として重要な引数は、位置引数として定義しておき、任意の引数をargsにまとめてしまうといったことができます。

なお、通常の引数は*argsの前に定義する必要があるため注意してください。

**kwargs による任意個のキーワード引数の受け取り

関数の引数として任意の個数のキーワード引数を渡したい場合には、関数の引数として**kwargsを定義します。なお、kwargsという名称は必須ではありませんが、Pythonを使っている人は通例としてkeyword argumentsを意味するkwargsという名称を使用します。

基本的な使い方

**kwargsによるキーワード引数の受け取りは以下のようにします。

# **kwargsによるキーワード引数の辞書受取
def print_input(**kwargs):
    print(type(kwargs))
    for k, v in kwargs.items():
        print(f"key: {k}, value:{v}")


if __name__ == "__main__":
    print_input(opt1=1, opt2=2, value="python")

【実行結果】
<class 'dict'>
key: opt1, value:1
key: opt2, value:2
key: value, value:python

**kwargsとして引数を指定した場合には、受け取った引数は辞書となります。上記例では、合計3つのキーワード引数を受け取ることができています。**kwargsの使用は、特に複数のオプションとなる引数を関数に渡す場合などに非常に便利です。

通常の引数や *args との組み合わせ

**kwargsは、以下のように通常の引数や*argsと組み合わせて使用することができます。

# 通常の位置引数や*argsとの組み合わせ
def print_input(in1, in2, *args, **kwargs):
    print(in1)
    print(in2)
    for i, arg in enumerate(args):
        print(f"arg[{i}] = {arg}")

    for k, v in kwargs.items():
        print(f"key: {k}, value:{v}")


if __name__ == "__main__":
    print_input(1, 2, "A", "B", "C", opt1=1, opt2=2, name="python")

【実行結果】
1
2
arg[0] = A
arg[1] = B
arg[2] = C
key: opt1, value:1
key: opt2, value:2
key: name, value:python

上記の例では、通常の位置引数であるin1, in2、任意個の引数の*args、任意個のキーワード引数の**kwargsをprint_input関数の引数にしています。このように組み合わせをすることで、非常に柔軟に関数の挙動を定義することが可能になってきます。

ただし、引数の順は、通常の引数、*args、**kwargsの順で定義する必要があるため注意してください。

関数の引数に関する注意事項

ここでは関数の引数に関する注意事項を説明します。

デフォルト値にはミュータブルな型を使うべきではない

関数の引数のデフォルト値にはミュータブル（mutable）な値を使うべきではありません。

デフォルト値にミュータブルな型を使用すると、同じインスタンスが再利用されてしまい、意図しない動作を引き起こすことがあります。以下の例で見てみましょう。

def sample_function(in1, tmp_list=[]):
    tmp_list.append(in1)
    return tmp_list


if __name__ == '__main__':
    result1 = sample_function('A')
    print(result1)

    result2 = sample_function('B')
    print(result2)

【実行結果】
['A']
['A', 'B']

上記例のsample_function関数は、値とリストを受け取ってリストに値を追加する関数です。デフォルト値として空リスト[]を設定しています。この時、前提としてプログラムを書いた人はリストが指定されていないときは新しくリストを作成することを想定しているとします。

関数の呼び出し結果を見てみましょう。2回呼び出しを行っており、いずれもtmp_listに渡すリストは指定していません。そのため、結果は1回目は['A']、2回目は['B']となってほしいわけです。しかし、2回目の呼び出しでは結果が['A', 'B']となってしまいました。

このような結果となるのは、Pythonでは関数のデフォルト値は最初に1回だけ評価されるためです。2回目以降の呼び出しでは既に'A'が追加されているリストを使ってしまうため、['A', 'B']となりました。

このように、ミュータブルな型をデフォルト値に使ってしまうと想定外の挙動をしてしまうため注意してください。

このように想定外の挙動をする可能性があるため、ミュータブルな型をデフォルト値に使用することは避けるようにしてください。

ミュータブルなデフォルト値を使いたい場合

上記では、ミュータブルな値を使うべきではないということで例を紹介しましたが、では実際にどのような解決策があるでしょうか。

このような場合は、以下のようにデフォルト値としてNoneを指定して起き、関数内でNoneであった場合に初期化する方法が適切です。この方法では、毎回新しいリストが作成されるため安全です。

def sample_function(in1, tmp_list=None):
    if tmp_list is None:
        tmp_list = []
    tmp_list.append(in1)
    return tmp_list


if __name__ == '__main__':
    result1 = sample_function('A')
    print(result1)

    result2 = sample_function('B')
    print(result2)

【実行結果】
['A']
['B']

上記結果では、想定した通り結果では、呼び出しの1回目は['A']、2回目は['B']という結果となりました。

まとめ

Python で関数を定義する方法について解説しました。また、関数定義では、色々な引数の種類や使い方について紹介しています。

関数の定義では def を使って、必要に応じて引数や返り値を設定して定義します。

引数では、位置引数、キーワード引数といった考え方があり、*args や **kwargs といった任意個の引数を渡す仕組みがあります。引数が渡されない時のデフォルト引数を設定することができますが、リスト、辞書などのミュータブルな型を設定するとバグにつながりやすいため注意しましょう。

関数の定義は、プログラミングでも重要なので基本をしっかり押さえましょう。パッケージなどを使う際にどのように呼び出すことができるかを調べる際にも関数定義の構造をしっかり理解しておくことが役に立ちます。

あわせて読みたい

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