【Python】イテラブル・イテレータ・ジェネレータの違いを整理する

Pythonの反復処理は、一見するとfor文だけで完結しているように見える。
しかし内部では明確な構造が存在する。

• イテラブル（Iterable）
• イテレータ（Iterator）
• ジェネレータ（Generator）

これらは別物である。
混同しやすいが、関係性は階層構造になっている。

Copy
Iterable
   └── Iterator
          └── Generator

• ジェネレータはイテレータの一種
• イテレータはイテラブルから生成される

また前提として、for文は内部的下記の構造で動いてる

Copy
it = iter(obj)
while True:
    try:
        value = next(it)
    except StopIteration:
        break

この仕組みを理解すると

• イテラブル（Iterable）
• イテレータ（Iterator）
• ジェネレータ（Generator）

を理解することができる

当記事では

• イテラブルとは何か
• イテレータとは何か
• ジェネレータとは何か
• yieldの役割
• 遅延評価との関係

について、反復モデルの内部構造という観点から整理する。

イテラブル(iterable)とは？

イテラブルとは反復可能なオブジェクトのこと。
具体的には

• list: [1, 2, 3]
• tuple: (1, 2, 3)
• set: {1, 2, 3}
• dict: {1: "A", 2: "B", 3: "C"}
• str: "ABC"

といった反復可能なオブジェクトがイテラブルとなる。

特徴

• for文で回すことができる
• 自身で値を返す機能は持たない
• iter()を呼ぶとイテレータを返す

つまりイテラブルは「材料」のこと

イテレータ(iterator)とは？

イテレータとは、イテラブルから生成される値を1つずつ返すオブジェクトである。
listを例にして説明すると

Copy
# イテラブル生成
list = [1, 2, 3]

# iter()を呼ぶとイテレータを返す
it = iter(list)

# イテレータから値を取得（next）
print(next(it)) # 1
print(next(it)) # 2
print(next(it)) # 3
print(next(it)) # StopIteration   

# イテラブル作成
tuple = (1, 2, 3)

# iter()を呼ぶとイテレータを返す
it = iter(tuple)

# イテレータから値を取得(for文)
for value in it:
    print(value)    # 1
                    # 2
                    # 3

• iter()を呼ぶとイテレータを返す
• next()を呼ぶと値を返す
• 末尾まで到達したらStopIteration例外を発生させる
• 一方方向にしか進めない

つまりイテレータは「取り出し装置」である。

ジェネレータ(generator)とは？

yieldによって作られるイテレータのこと。
つまりジェネレータはイテレータの一種である。 ※ジェネレータはイテレータに含まれる

ジェネレータの生成方法は

• ジェネレータ関数
• ジェネレータ式

の2種類ある

ジェネレータ関数

Copy
def generator():    
    yield 1
    yield 2
    yield 3

• yieldを含む関数を作る→ジェネレータ関数
• ジェネレータ関数を呼ぶとジェネレータを返す

ジェネレータ式

Copy
generator = (value for value in list([1, 2, 3]))

• ジェネレータ式という構文
• 暗黙的にyieldを使っている

yieldとは？

yieldは

• 値を返す
• そこで停止
• 状態を保持
• next()で再開

のように必要になった瞬間にだけ進む構造を実現する。

これを遅延評価と呼ぶ

つまりyieldは関数をジェネレータ関数に変える構文であり。 ジェネレータ関数が返すジェネレータは遅延評価を行うイテレータのことである。 ※遅延評価はイテレータの定義ではなく、ジェネレータの代表的な性質

遅延評価という概念

遅延評価とは、

• 値が実際に必要になるまで計算を実行しない評価戦略のこと。

Pythonではジェネレータが代表例である。

通常のリスト（即時評価）

Copy
# イテレータ生成
lst = [x for x in list([1, 2, 3])]
print(lst)  # [1, 2, 3]

このコードではリスト内包表記が実行された瞬間に
すべての要素が計算され
メモリ上にリストが生成される

つまり、必要になる前に全要素を生成している（即時評価）

ジェネレータ（遅延評価）

Copy
# ジェネレータ生成
gen = (x for x in [1, 2, 3])
print(gen)  # <generator object ...>

• この時点ではまだ、何も計算されていない
• ただ「計算方法」が保存されているだけ
• 値を返す“装置”を作っているイメージ

値とりだす時に初めて計算される

Copy
print(next(gen))  # 1
print(next(gen))  # 2
print(next(gen))  # 3

• 必要になったタイミングで1つずつ生成する（遅延評価）

まとめ

Pythonの反復処理は

• データを保持する構造（Iterable）
• 値を取り出す仕組み（Iterator）
• 状態を保持しながら生成する仕組み（Generator）

という役割分担の上に設計されている。

for 文は構文であり、その背後にはこの反復モデルが存在している。