Pythonジェネレータ入門｜メモリを節約する便利な機能

みなさん、Pythonで大量のデータを処理する時「メモリが足りない」と困ったことはありませんか？

「1万件のデータを一度に読み込むとメモリがパンパン」 「もっと効率的にデータを処理したい」 「必要な分だけ少しずつ処理できたらいいのに」

こんな悩みを解決してくれるのがジェネレータという機能です。

でも大丈夫です！ジェネレータは思っているよりもずっと簡単で、覚えてしまえばとても便利な機能なんです。

この記事では、Python初心者の方でも理解できるように、ジェネレータの基本から実践的な使い方まで、わかりやすく解説していきます。 読み終わる頃には、メモリ効率の良いプログラムが書けるようになりますよ！

ジェネレータって何？まずは基本を理解しよう

ジェネレータの基本的な考え方

ジェネレータは、値を一つずつ生成する特殊な関数です。 普通の関数のように、すべての値を一度にメモリに作るのではありません。

簡単に言うと、「必要な時に必要な分だけ」値を作ってくれる仕組みなんです。

例えば、普通のリストだと1万個のデータを全部メモリに保存します。 でもジェネレータなら、1個ずつ順番に作って、使い終わったらメモリから消してくれます。

普通の関数との違いを見てみよう

まず、普通の関数とジェネレータの違いを実際のコードで確認してみましょう。

# 普通の関数（リストを返す）
def create_numbers_list(n):
    result = []
    for i in range(n):
        result.append(i * 2)
    return result

# ジェネレータ関数（yieldを使用）
def create_numbers_generator(n):
    for i in range(n):
        yield i * 2

# 使用例
n = 5

# 普通の関数
numbers_list = create_numbers_list(n)
print(f"リスト: {numbers_list}")
print(f"型: {type(numbers_list)}")

# ジェネレータ
numbers_gen = create_numbers_generator(n)
print(f"ジェネレータ: {numbers_gen}")
print(f"型: {type(numbers_gen)}")

# ジェネレータから値を取得
print("ジェネレータの値:")
for num in numbers_gen:
    print(f"  {num}")

このコードを実行すると、こんな結果になります。

普通の関数の場合 最初から[0, 2, 4, 6, 8]という完成したリストを作ります。 すべての値がメモリに保存されています。

ジェネレータの場合 <generator object>という特殊なオブジェクトを作ります。 値は実際に使う時まで作られません。

ここがジェネレータの大きな特徴です。 「必要になったら作る」という仕組みなんですね。

yield文の基本的な使い方

yieldってどんな機能？

yield文は、ジェネレータの核となる機能です。 普通のreturnとは違って、値を返した後も関数の実行を続けることができます。

実際にyield文の動作を見てみましょう。

def simple_generator():
    """シンプルなジェネレータの例"""
    print("最初の値を生成中...")
    yield 1
    
    print("2番目の値を生成中...")
    yield 2
    
    print("3番目の値を生成中...")
    yield 3
    
    print("ジェネレータ終了")

# ジェネレータの作成
gen = simple_generator()
print(f"ジェネレータオブジェクト: {gen}")

# 値を一つずつ取得
print("
値を順次取得:")
print(f"1番目: {next(gen)}")
print(f"2番目: {next(gen)}")
print(f"3番目: {next(gen)}")

# すべて取得後にnext()を呼ぶとStopIteration例外
try:
    print(f"4番目: {next(gen)}")
except StopIteration:
    print("ジェネレータが終了しました")

実行すると、このような結果になります。

1番目の値を取得する時：「最初の値を生成中...」が表示されて、1が返される 2番目の値を取得する時：「2番目の値を生成中...」が表示されて、2が返される 3番目の値を取得する時：「3番目の値を生成中...」が表示されて、3が返される

つまり、yieldのところで関数の実行が一時停止して、次に呼ばれた時に続きから実行されるんです。

forループでの使用方法

ジェネレータは、forループでも簡単に使えます。

# forループでの使用
print("
forループでの使用:")
gen2 = simple_generator()
for value in gen2:
    print(f"値: {value}")

forループを使うと、next()を手動で呼ぶ必要がありません。 自動的に最後まで値を取得してくれるので、とても便利です。

実用的なジェネレータの例

もう少し実用的な例を見てみましょう。

def fibonacci_generator(limit):
    """フィボナッチ数列のジェネレータ"""
    a, b = 0, 1
    count = 0
    
    while count < limit:
        yield a
        a, b = b, a + b
        count += 1

# フィボナッチ数列の生成
print("フィボナッチ数列（最初の10個）:")
for i, fib in enumerate(fibonacci_generator(10)):
    print(f"F({i}): {fib}")

この例では、フィボナッチ数列を一つずつ計算して返しています。 10個すべてを先に計算するのではなく、必要な時に計算するので効率的です。

def even_numbers(start, end):
    """指定範囲の偶数を生成"""
    current = start if start % 2 == 0 else start + 1
    while current <= end:
        yield current
        current += 2

# 偶数の生成
print("
10から30までの偶数:")
for num in even_numbers(10, 30):
    print(num, end=" ")
print()

指定した範囲の偶数だけを生成するジェネレータです。 範囲が大きくても、必要な分だけ計算するので無駄がありません。

メモリ効率の違いを実感してみよう

メモリ使用量を比較

ジェネレータとリストのメモリ使用量を実際に比較してみましょう。

import sys

def large_list(n):
    """大きなリストを作成"""
    return [x for x in range(n)]

def large_generator(n):
    """大きなデータのジェネレータ"""
    for x in range(n):
        yield x

# メモリ使用量の比較
n = 1000

# リストの場合
list_data = large_list(n)
list_size = sys.getsizeof(list_data)
print(f"リスト（{n}要素）のメモリ使用量: {list_size} bytes")

# ジェネレータの場合
gen_data = large_generator(n)
gen_size = sys.getsizeof(gen_data)
print(f"ジェネレータのメモリ使用量: {gen_size} bytes")

print(f"メモリ削減率: {(list_size - gen_size) / list_size * 100:.1f}%")

実行すると、ジェネレータの方が圧倒的にメモリ使用量が少ないことがわかります。

なぜこんなに違うの？

リストは、1000個すべてのデータをメモリに保存します。 ジェネレータは、「どうやって次の値を作るか」という情報だけを保存します。

つまり、データが多くなればなるほど、ジェネレータの方が有利になるんです。

実際の処理時間も確認

処理時間についても比較してみましょう。

import time

def time_comparison():
    """処理時間の比較"""
    n = 100000
    
    # リスト作成時間
    start = time.time()
    list_data = [x * 2 for x in range(n)]
    list_time = time.time() - start
    
    # ジェネレータ作成時間（実際は何も処理していない）
    start = time.time()
    gen_data = (x * 2 for x in range(n))
    gen_time = time.time() - start
    
    print(f"
リスト作成時間: {list_time:.6f}秒")
    print(f"ジェネレータ作成時間: {gen_time:.6f}秒")
    
    # 実際の処理時間（最初の1000個だけ使用）
    start = time.time()
    list_result = []
    for i, x in enumerate(list_data):
        if i >= 1000:
            break
        list_result.append(x)
    list_process_time = time.time() - start
    
    start = time.time()
    gen_result = []
    for i, x in enumerate(gen_data):
        if i >= 1000:
            break
        gen_result.append(x)
    gen_process_time = time.time() - start
    
    print(f"リスト処理時間（1000個）: {list_process_time:.6f}秒")
    print(f"ジェネレータ処理時間（1000個）: {gen_process_time:.6f}秒")

time_comparison()

この結果を見ると面白いことがわかります。

ジェネレータの作成はほぼ瞬時に終わります。 実際にはまだ計算していないからです。

必要な分だけ処理する時は、ジェネレータの方が効率的です。 無駄な計算をしないからですね。

ジェネレータ式で簡潔に書こう

リスト内包表記の兄弟分

Pythonには、リスト内包表記という便利な機能がありますよね。 実は、ジェネレータにも似たような機能があるんです。

# リスト内包表記
list_comp = [x * 2 for x in range(10)]
print(f"リスト内包表記: {list_comp}")
print(f"型: {type(list_comp)}")

# ジェネレータ式（括弧を使用）
gen_exp = (x * 2 for x in range(10))
print(f"ジェネレータ式: {gen_exp}")
print(f"型: {type(gen_exp)}")

# ジェネレータ式の値を取得
print("ジェネレータ式の値:")
for value in gen_exp:
    print(value, end=" ")
print()

ジェネレータ式は、リスト内包表記の[]を()に変えるだけです。 とても簡単ですよね！

条件付きジェネレータ式

条件を付けることもできます。

# 条件付きジェネレータ式
even_squares = (x**2 for x in range(20) if x % 2 == 0)
print(f"
偶数の平方: {list(even_squares)}")

# ネストしたジェネレータ式
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = (item for row in matrix for item in row)
print(f"平坦化: {list(flattened)}")

# 文字列処理のジェネレータ式
text = "Hello World Python"
word_lengths = (len(word) for word in text.split())
print(f"単語の長さ: {list(word_lengths)}")

これらの例を見ると、ジェネレータ式がとても柔軟だということがわかります。

偶数の平方では、偶数だけを選んで平方を計算します。 平坦化では、2次元のリストを1次元にします。 文字列処理では、各単語の長さを計算します。

どれも、必要な時に計算されるので効率的です。

実用的なジェネレータ式の例

もう少し実用的な例を見てみましょう。

# ファイル処理のシミュレーション
log_lines = [
    "2024-01-01 10:00:00 INFO Application started",
    "2024-01-01 10:05:00 ERROR Database connection failed",
    "2024-01-01 10:10:00 WARNING Low disk space",
    "2024-01-01 10:15:00 INFO User logged in",
    "2024-01-01 10:20:00 ERROR Network timeout"
]

# ERRORログだけを抽出
error_logs = (line for line in log_lines if "ERROR" in line)
print("エラーログ:")
for log in error_logs:
    print(f"  {log}")

# 時刻だけを抽出
timestamps = (line.split()[1] for line in log_lines)
print(f"
時刻一覧: {list(timestamps)}")

この例では、ログファイルからエラーだけを抜き出したり、時刻だけを取得したりしています。 実際のログファイル処理でも、同じような方法が使えます。

# データ変換のジェネレータ式
prices = [100, 200, 150, 300, 250]

# 税込み価格（10%）
prices_with_tax = (price * 1.1 for price in prices)
print(f"
税込み価格: {[int(p) for p in prices_with_tax]}")

# 割引価格（20%オフ）
discounted_prices = (price * 0.8 for price in prices)
print(f"割引価格: {[int(p) for p in discounted_prices]}")

# 複雑な変換
def process_price(price):
    """価格を処理する関数"""
    tax_included = price * 1.1
    if tax_included > 200:
        return tax_included * 0.9  # 10%割引
    return tax_included

processed_prices = (process_price(price) for price in prices)
print(f"処理後価格: {[int(p) for p in processed_prices]}")

価格の計算なども、ジェネレータ式で簡潔に書けます。 必要な分だけ計算するので、大量のデータでも効率的です。

実際の場面で使ってみよう

ファイル読み込みでの活用

大きなファイルを効率的に処理する例を見てみましょう。

def read_large_file_simulation():
    """大きなファイルの読み込みシミュレーション"""
    # 実際のファイルの代わりに模擬データを使用
    file_content = [
        "line 1: user_001,action_login,2024-01-01T10:00:00",
        "line 2: user_002,action_view,2024-01-01T10:01:00", 
        "line 3: user_001,action_logout,2024-01-01T10:05:00",
        "line 4: user_003,action_login,2024-01-01T10:06:00",
        "line 5: user_002,action_purchase,2024-01-01T10:07:00"
    ]
    return file_content

def parse_log_line(line):
    """ログ行を解析する関数"""
    try:
        parts = line.split(": ")[1].split(",")
        return {
            "user": parts[0],
            "action": parts[1], 
            "timestamp": parts[2]
        }
    except (IndexError, ValueError):
        return None

def process_logs_generator():
    """ログをジェネレータで処理"""
    file_lines = read_large_file_simulation()
    
    for line in file_lines:
        parsed = parse_log_line(line)
        if parsed and parsed['action'] == 'action_login':
            yield parsed

# ログイン操作だけを抽出
print("ログイン操作:")
for login_log in process_logs_generator():
    print(f"  {login_log['user']} at {login_log['timestamp']}")

このコードでは、ファイルの内容を一行ずつ処理しています。 全部をメモリに読み込むのではなく、必要な行だけを処理するので効率的です。

実際のファイル処理では、こんな感じで使います。

def csv_reader_generator(data):
    """CSVデータのジェネレータ"""
    lines = data.strip().split('
')
    header = lines[0].split(',')
    
    for line in lines[1:]:
        values = line.split(',')
        yield dict(zip(header, values))

# CSV処理の例
csv_data = """Name,Age,City
Alice,25,Tokyo
Bob,30,Osaka
Charlie,35,Kyoto"""

print(f"
CSVデータ処理:")
for row in csv_reader_generator(csv_data):
    print(f"  {row}")

CSVファイルの処理でも、一行ずつ辞書に変換して返しています。 大きなCSVファイルでも、メモリを節約しながら処理できます。

APIデータ処理での活用

APIからのデータをページネーションで処理する例も見てみましょう。

def api_data_generator():
    """APIデータのページネーション処理"""
    # 実際のAPIの代わりに模擬データを使用
    api_pages = [
        {"data": [{"id": 1, "name": "Alice"}, {"id": 2, "name": "Bob"}], "has_next": True},
        {"data": [{"id": 3, "name": "Charlie"}, {"id": 4, "name": "Diana"}], "has_next": True},
        {"data": [{"id": 5, "name": "Eve"}], "has_next": False}
    ]
    
    page_num = 0
    while page_num < len(api_pages):
        page_data = api_pages[page_num]
        
        for item in page_data["data"]:
            yield item
        
        if not page_data["has_next"]:
            break
        page_num += 1

# APIデータの処理
print("APIデータ:")
for user in api_data_generator():
    print(f"  ID: {user['id']}, Name: {user['name']}")

この例では、APIから複数ページのデータを取得しています。 一度にすべてのページを取得するのではなく、必要な分だけ処理できます。

def batch_processor(iterable, batch_size):
    """データをバッチ処理するジェネレータ"""
    batch = []
    for item in iterable:
        batch.append(item)
        if len(batch) == batch_size:
            yield batch
            batch = []
    
    # 残りのアイテムがあれば返す
    if batch:
        yield batch

# バッチ処理の例
numbers = range(1, 16)  # 1から15まで
print(f"
バッチ処理（サイズ5）:")
for batch in batch_processor(numbers, 5):
    print(f"  バッチ: {batch}")

バッチ処理では、データを指定したサイズごとにまとめて返します。 大量のデータを小分けにして処理したい時に便利です。

無限ジェネレータも作れる

理論的に無限のデータを生成するジェネレータも作れます。

def counter(start=0):
    """無限カウンター"""
    current = start
    while True:
        yield current
        current += 1

def take(iterable, n):
    """ジェネレータから指定個数だけ取得"""
    count = 0
    for item in iterable:
        if count >= n:
            break
        yield item
        count += 1

# 無限カウンターの使用
print("無限カウンター（最初の10個）:")
for num in take(counter(1), 10):
    print(num, end=" ")
print()

無限ジェネレータは、終わりのないデータを扱う時に便利です。 実際には、必要な分だけ取得して使います。

def cycle_generator(items):
    """要素を無限に循環"""
    while True:
        for item in items:
            yield item

# 循環ジェネレータ
colors = ["red", "green", "blue"]
print(f"
色の循環（最初の10個）:")
for color in take(cycle_generator(colors), 10):
    print(color, end=" ")
print()

循環ジェネレータは、要素を繰り返し使いたい時に便利です。 色の指定やパターンの繰り返しなどで使えます。

ジェネレータ使用時の注意点

一度しか使えない特徴

ジェネレータには、知っておくべき注意点があります。

def generator_caveats():
    """ジェネレータの注意点"""
    
    # 注意点1: 一度しか使用できない
    gen = (x for x in range(5))
    
    print("1回目の使用:")
    for x in gen:
        print(x, end=" ")
    print()
    
    print("2回目の使用:")
    for x in gen:  # 何も出力されない
        print(x, end=" ")
    print("（空）")
    
    # 注意点2: len()が使えない
    gen2 = (x for x in range(10))
    try:
        print(f"長さ: {len(gen2)}")
    except TypeError as e:
        print(f"エラー: {e}")
    
    # 注意点3: インデックスアクセスできない
    gen3 = (x for x in range(10))
    try:
        print(f"最初の要素: {gen3[0]}")
    except TypeError as e:
        print(f"エラー: {e}")

generator_caveats()

一度しか使えないという特徴は、最初は戸惑うかもしれません。 でも、「必要な時に作る」という仕組みを考えれば理解できますよね。

使い終わったら、新しくジェネレータを作り直す必要があります。

使い分けのポイント

どんな時にジェネレータを使うべきでしょうか？

def when_to_use_generators():
    """ジェネレータを使うべき場面"""
    
    print("
=== ジェネレータが有効な場面 ===")
    
    # 1. 大量のデータ処理
    def large_data_example():
        # メモリ効率的な処理
        return (x ** 2 for x in range(1000000))
    
    # 2. ファイル処理
    def file_lines(filename):
        # 実際の実装では with open() を使用
        lines = ["line1", "line2", "line3"]  # 模擬データ
        for line in lines:
            yield line.strip()
    
    # 3. 無限シーケンス
    def fibonacci():
        a, b = 0, 1
        while True:
            yield a
            a, b = b, a + b
    
    print("✓ 大量データ、ファイル処理、無限シーケンス")
    
    print("
=== リストの方が良い場面 ===")
    
    # 1. 小さなデータ
    small_data = [1, 2, 3, 4, 5]
    
    # 2. 複数回アクセスが必要
    data_for_multiple_use = list(range(10))
    
    # 3. ランダムアクセスが必要
    indexed_data = [x for x in range(100)]
    
    print("✓ 小さなデータ、複数回使用、ランダムアクセス")

when_to_use_generators()

ジェネレータが有効な場面

• 大量のデータを処理する時
• ファイルを一行ずつ読む時
• 無限に続くデータを扱う時

リストの方が良い場面

• データが少ない時
• 同じデータを何度も使う時
• 特定のインデックスにアクセスしたい時

この使い分けを覚えておくと、より効率的なプログラムが書けるようになります。

パフォーマンスを上げるコツ

ジェネレータを効果的に使うコツもあります。

def performance_tips():
    """パフォーマンスのコツ"""
    
    print("
=== パフォーマンスのコツ ===")
    
    # 1. チェーン化
    def process_chain(data):
        # 複数のジェネレータを連鎖
        filtered = (x for x in data if x > 0)
        doubled = (x * 2 for x in filtered)
        squared = (x ** 2 for x in doubled)
        return squared
    
    test_data = [-2, -1, 0, 1, 2, 3]
    result = list(process_chain(test_data))
    print(f"チェーン処理結果: {result}")
    
    # 2. 早期終了
    def find_first_match(data, condition):
        for item in data:
            if condition(item):
                yield item
                break  # 最初の一致で終了
    
    numbers = range(1000)
    first_big = list(find_first_match(numbers, lambda x: x > 500))
    print(f"最初の大きな数: {first_big}")

performance_tips()

チェーン化では、複数の処理を連続して行います。 それぞれが必要な時だけ計算するので、とても効率的です。

早期終了では、条件に合うものが見つかったらすぐに終了します。 無駄な計算をしないので、時間を節約できます。

まとめ：ジェネレータでメモリ効率アップ

Pythonのジェネレータについて詳しく学んできました。 最後に、重要なポイントをまとめておきましょう。

ジェネレータの基本

yield文の仕組み ジェネレータはyield文で値を一つずつ生成します。 必要な時に必要な分だけ作るので、メモリ効率が抜群です。

メモリ効率の良さ リストと比べて大幅にメモリ使用量を削減できます。 大量のデータを扱う時は、特に効果を実感できるでしょう。

ジェネレータ式の便利さ (expression for item in iterable)の形で簡潔に書けます。 リスト内包表記の括弧を変えるだけなので、覚えやすいですね。

実用的な活用場面

ファイル処理 大きなファイルを一行ずつ処理する時に威力を発揮します。 メモリ不足を心配せずに済みます。

APIデータ処理 ページネーションやバッチ処理で効率的にデータを扱えます。 無駄な通信を減らせるのも嬉しいポイントです。

無限データの生成 理論的に無限のデータも扱えます。 数列の生成やパターンの繰り返しに便利です。

注意すべきポイント

一度しか使えない特性 同じジェネレータオブジェクトは一度しか使えません。 複数回使いたい場合は、新しく作り直しましょう。

適切な使い分け 小さなデータや複数回アクセスが必要な場合は、リストの方が適しています。 目的に応じて使い分けることが大切です。

次のステップ

ジェネレータをマスターしたら、以下にも挑戦してみてください。

• itertoolsモジュールの便利な機能
• 非同期処理での活用
• より高度なジェネレータパターン
• パフォーマンス最適化のテクニック

ジェネレータは、Pythonプログラミングの効率を大きく向上させる機能です。 最初は慣れないかもしれませんが、使い慣れるととても便利な機能だと実感できるはずです。

ぜひ、実際のプログラムでジェネレータを活用してみてください。 メモリ効率の良いプログラムが書けるようになりますよ！