Python `yield` 詳細解説：ジェネレータを使いこなそう

def simple_greeting_generator():
    print("ジェネレータ開始！")
    yield "おはようございます"
    print("一つ目のyieldの後")
    yield "こんにちは"
    print("二つ目のyieldの後")
    yield "こんばんは"
    print("ジェネレータ終了！")

# ジェネレータ関数を呼び出すと、ジェネレータオブジェクトが返される
greeting_gen = simple_greeting_generator()

print(f"ジェネレータオブジェクト: {greeting_gen}")

# next()関数で値を取り出す
print("--- 1回目のnext() ---")
message1 = next(greeting_gen)
print(f"受け取った値: {message1}")

print("--- 2回目のnext() ---")
message2 = next(greeting_gen)
print(f"受け取った値: {message2}")

print("--- 3回目のnext() ---")
message3 = next(greeting_gen)
print(f"受け取った値: {message3}")

# # これ以上yieldする値がない状態でnext()を呼ぶと StopIteration 例外が発生する
# print("--- 4回目のnext() ---")
# try:
#     next(greeting_gen)
# except StopIteration:
#     print("StopIterationが発生しました！")
            

def count_up_to(n):
    print(f"1から{n}まで数えます。")
    i = 1
    while i <= n:
        yield i
        i += 1
    print("カウント終了。")

# forループでジェネレータを使う
print("--- forループ開始 ---")
for number in count_up_to(5):
    print(f"受け取った数字: {number}")
print("--- forループ終了 ---")
            

import sys

# リストを返す関数
def create_large_list(n):
    print("リストを作成中...")
    result = []
    for i in range(n):
        result.append(i)
    print("リスト作成完了！")
    return result

# ジェネレータ関数
def create_large_generator(n):
    print("ジェネレータが呼ばれました。")
    for i in range(n):
        # print(f"{i} をyieldします。") # コメントアウト解除すると、yieldのタイミングがわかる
        yield i
    print("ジェネレータ終了。")

num_elements = 1_000_000 # 100万要素

# リストの場合
print("--- リストのアプローチ ---")
large_list = create_large_list(num_elements)
print(f"リストのメモリサイズ: {sys.getsizeof(large_list) / 1024 / 1024:.2f} MB")
# # リストの最初の5要素にアクセス
# print("最初の5要素:", large_list[:5])

print("\\n--- ジェネレータのアプローチ ---")
large_gen = create_large_generator(num_elements)
print(f"ジェネレータオブジェクトのメモリサイズ: {sys.getsizeof(large_gen) / 1024:.2f} KB")
# # ジェネレータの最初の5要素にアクセス
# print("最初の5要素:")
# for _ in range(5):
#     print(next(large_gen), end=" ")
# print()

# メモリ使用量の比較（おおよその目安）
# 注意: 実際のメモリ使用量は環境によって異なります
list_memory = sys.getsizeof(create_large_list(num_elements))
gen_memory = sys.getsizeof(create_large_generator(num_elements)) # ジェネレータオブジェクト自体のサイズ

print(f"\\n比較:")
print(f"リスト ({num_elements}要素): {list_memory / 1024 / 1024:.2f} MB")
print(f"ジェネレータオブジェクト: {gen_memory / 1024:.2f} KB")
            

import csv
import time # 時間計測用
import os # ファイル作成用

# ダミーの巨大CSVファイルを作成する関数 (デモ用)
def create_dummy_csv(filename, rows):
    print(f"'{filename}' を作成中 ({rows}行)...")
    with open(filename, 'w', newline='') as f:
        writer = csv.writer(f)
        writer.writerow(['ID', 'Value', 'Timestamp']) # ヘッダー
        for i in range(rows):
            writer.writerow([i, f'Data-{i}', time.time()])
    print(f"'{filename}' 作成完了。")

# ジェネレータを使ってファイルを処理する関数
def process_csv_generator(filename):
    print(f"ジェネレータで '{filename}' を処理開始...")
    with open(filename, 'r', newline='') as f:
        reader = csv.reader(f)
        header = next(reader) # ヘッダー行をスキップ
        print(f"ヘッダー: {header}")
        for row in reader:
            # ここで各行に対する処理を行う (例: 特定の条件でフィルタリング、集計など)
            # 例としてIDが偶数の行だけをyieldする
            if int(row[0]) % 2 == 0:
                yield row
    print("ジェネレータ処理完了。")

# --- 実行 ---
dummy_file = 'large_data.csv'
num_rows = 500_000 # 50万行のダミーデータ

# # 初回実行時やファイルがない場合にダミーファイルを作成
# if not os.path.exists(dummy_file):
#     create_dummy_csv(dummy_file, num_rows)
# else:
#     print(f"'{dummy_file}' は既に存在します。")

# # ジェネレータを使って処理 (メモリ効率が良い)
# print("\\n--- ジェネレータによる処理 ---")
# start_time = time.time()
# processed_count = 0
# for processed_row in process_csv_generator(dummy_file):
#     # 処理された行に対する操作 (ここではカウントのみ)
#     processed_count += 1
#     if processed_count % 50000 == 0: # 5万行ごとに進捗表示
#         print(f"  {processed_count}行処理済み...")

# end_time = time.time()
# print(f"処理された行数: {processed_count}")
# print(f"処理時間: {end_time - start_time:.2f} 秒")

# # 参考：リストとして全行読み込む場合 (メモリ消費大)
# def process_csv_list(filename):
#     print(f"リストで '{filename}' を処理開始...")
#     with open(filename, 'r', newline='') as f:
#         reader = csv.reader(f)
#         header = next(reader)
#         all_rows = list(reader) # ここで全行をメモリに読み込む
#     print(f"全 {len(all_rows)} 行をメモリに読み込み完了。")
#     processed_rows = []
#     for row in all_rows:
#         if int(row[0]) % 2 == 0:
#             processed_rows.append(row)
#     print("リスト処理完了。")
#     return processed_rows

# print("\\n--- リストによる処理（比較用・実行注意） ---")
# # 大量データの場合、メモリ不足になる可能性あり
# try:
#     start_time_list = time.time()
#     processed_list = process_csv_list(dummy_file)
#     end_time_list = time.time()
#     print(f"処理された行数: {len(processed_list)}")
#     print(f"処理時間: {end_time_list - start_time_list:.2f} 秒")
# except MemoryError:
#      print("メモリ不足エラーが発生しました！")

# # 後片付け
# if os.path.exists(dummy_file):
#     print(f"\\n'{dummy_file}' を削除します。")
#     os.remove(dummy_file)
            

# 無限に自然数を生成するジェネレータ
def natural_numbers():
    n = 1
    while True:
        yield n
        n += 1

# フィボナッチ数列を生成するジェネレータ
def fibonacci_sequence():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

print("--- 自然数 (最初の10個) ---")
nat_gen = natural_numbers()
for _ in range(10):
    print(next(nat_gen), end=" ")
print("\\n")

print("--- フィボナッチ数列 (最初の15個) ---")
fib_gen = fibonacci_sequence()
for _ in range(15):
    print(next(fib_gen), end=" ")
print("\\n")
            

def simple_coroutine():
    print("コルーチン開始")
    received_value = yield # ここで値を受け取るのを待つ
    print(f"値 '{received_value}' を受け取りました")
    received_value2 = yield received_value * 2 # 受け取った値を2倍してyieldし、次の値を受け取るのを待つ
    print(f"値 '{received_value2}' を受け取りました")
    print("コルーチン終了")

# コルーチン（ジェネレータ）を作成
coro = simple_coroutine()

# 最初にnext()を呼び出して、最初のyield式まで進める（重要！）
print("--- 最初のnext() ---")
next(coro) # 出力: コルーチン開始

# send()を使って値を送り込む
print("\\n--- 1回目のsend() ---")
returned_value = coro.send("Hello") # "Hello" を送り込む
print(f"yieldされた値: {returned_value}") # 出力: yieldされた値: None (最初のyieldは値を返さないため) -> 訂正：最初のyieldからの再開時にNoneが渡され、2番目のyieldで `received_value * 2` が返る

print("\\n--- 2回目のsend() ---")
try:
    coro.send(100) # 100 を送り込む
except StopIteration:
    print("StopIteration: コルーチンが正常終了しました。")

# 実行結果の訂正・詳細解説
# 1. coro = simple_coroutine() : ジェネレータオブジェクト作成
# 2. next(coro) : 実行開始 -> "コルーチン開始" -> 最初の yield で停止。この時点では何も yield されていない。
# 3. coro.send("Hello") :
#    - "Hello"が最初の yield 式の結果として received_value に代入される。
#    - 処理再開 -> "値 'Hello' を受け取りました"
#    - 次の yield received_value * 2 (つまり yield "HelloHello") で停止。
#    - "HelloHello" が send() の戻り値となる。 -> 訂正：上記コード例では数値の乗算なので `yield 100 * 2` などを想定すべき。最初のsendで"Hello"を送るとエラーになる。
#    -> 再訂正：最初の next() の後、最初の send() で送った値は最初の yield 式の結果になる。その後の処理が進み、次の yield があればその値が send() の戻り値になる。
#    -> 上記コードで send("Hello") をすると、文字列を受け取った後の `received_value * 2` でエラーになる。数値を送るべき。
# 4. coro.send(100) :
#    - 100 が2番目の yield 式の結果として received_value2 に代入される。
#    - 処理再開 -> "値 '100' を受け取りました"
#    - "コルーチン終了"
#    - 関数の終わりに到達したので StopIteration が発生。

# 正しい実行例
def numeric_coroutine():
    print("コルーチン開始 (数値)")
    received = yield # 最初の値受け取り待ち
    print(f"数値 {received} を受け取りました")
    doubled = yield received * 2 # 2倍した値をyieldし、次の値待ち
    print(f"数値 {doubled} を受け取りました")
    print("コルーチン終了 (数値)")

coro_num = numeric_coroutine()
print("--- 最初のnext() [数値] ---")
next(coro_num) # 開始して最初のyieldで待機

print("\\n--- 1回目のsend() [数値] ---")
result1 = coro_num.send(10) # 10 を送る
print(f"yieldされた値: {result1}") # 10 * 2 = 20 が yield される

print("\\n--- 2回目のsend() [数値] ---")
try:
    coro_num.send(50) # 50 を送る
except StopIteration:
    print("StopIteration: 数値コルーチンが正常終了しました。")

            

# データのソース (例: 数値のストリーム)
def number_source(limit):
    print(f"[Source] 0から{limit-1}までの数値を生成")
    for i in range(limit):
        yield i

# フィルタリングするジェネレータ (例: 偶数のみ)
def even_filter(upstream_generator):
    print("[Filter] 偶数のみをフィルタリング")
    for value in upstream_generator:
        if value % 2 == 0:
            yield value

# 変換するジェネレータ (例: 2乗する)
def square_mapper(upstream_generator):
    print("[Mapper] 値を2乗に変換")
    for value in upstream_generator:
        yield value * value

# パイプラインを構築して実行
limit = 10
pipeline = square_mapper(even_filter(number_source(limit)))

print("\\n--- パイプライン実行 ---")
for result in pipeline:
    print(f"最終結果: {result}")

            

# サブジェネレータ
def sub_generator(name):
    print(f"  [Sub] '{name}' 開始")
    yield f"{name}: Part 1"
    yield f"{name}: Part 2"
    print(f"  [Sub] '{name}' 終了")
    return f"{name} 完了" # Python 3.3以降、ジェネレータはreturnで値を返せる

# メインジェネレータ (yield from を使用)
def main_generator_with_yield_from():
    print("[Main] 開始")
    result1 = yield from sub_generator("Sub A")
    print(f"[Main] '{result1}' を受け取りました")
    yield "--- Main बीच में ---" # बीच में = in between (Hindi)
    result2 = yield from sub_generator("Sub B")
    print(f"[Main] '{result2}' を受け取りました")
    print("[Main] 終了")

# 比較用: yield from を使わない場合
def main_generator_without_yield_from():
    print("[Main (no yield from)] 開始")
    # sub_generator("Sub A") の処理を手動で模倣
    sub_a = sub_generator("Sub A")
    try:
        while True:
            yield next(sub_a)
    except StopIteration as e:
        result1 = e.value # returnされた値を取得
        print(f"[Main (no yield from)] '{result1}' を受け取りました")

    yield "--- Main बीच में ---"

    # sub_generator("Sub B") の処理を手動で模倣
    sub_b = sub_generator("Sub B")
    try:
        while True:
            yield next(sub_b)
    except StopIteration as e:
        result2 = e.value
        print(f"[Main (no yield from)] '{result2}' を受け取りました")

    print("[Main (no yield from)] 終了")


print("--- yield from を使用 ---")
gen_yf = main_generator_with_yield_from()
for value in gen_yf:
    print(f"受け取った値: {value}")

print("\\n" + "="*30 + "\\n")

print("--- yield from を使用しない ---")
gen_noyf = main_generator_without_yield_from()
for value in gen_noyf:
    print(f"受け取った値: {value}")
            

def interactive_coroutine():
    print("インタラクティブコルーチン開始！名前を教えてください。")
    name = yield "名前待ち" # 最初のyield (値を返す & 受け取り準備)
    print(f"こんにちは、{name}さん！年齢は？")
    age = yield f"{name}さんの年齢待ち" # 2番目のyield
    print(f"{name}さんは{age}歳なんですね。")
    return f"{name}({age})さん、さようなら！"

coro_interactive = interactive_coroutine()

# 1. 最初のプロンプト（"名前待ち"）を受け取る
prompt1 = next(coro_interactive)
print(f"プロンプト1: {prompt1}")

# 2. 名前 ("Alice") を送信し、次のプロンプトを受け取る
prompt2 = coro_interactive.send("Alice")
print(f"プロンプト2: {prompt2}")

# 3. 年齢 (30) を送信し、終了メッセージを受け取る (StopIteration)
try:
    coro_interactive.send(30)
except StopIteration as e:
    final_message = e.value
    print(f"最終メッセージ: {final_message}")

            

def exception_handling_generator():
    print("[Gen] 開始")
    try:
        value = yield "初回yield"
        print(f"[Gen] '{value}' を受け取りました")
        value = yield "2回目yield"
        print(f"[Gen] '{value}' を受け取りました (ここは実行されないはず)")
    except ValueError as e:
        print(f"[Gen] ValueErrorをキャッチしました: {e}")
        yield "ValueError処理後"
    except TypeError:
        print(f"[Gen] TypeErrorをキャッチしました (処理せず再送出)")
        raise # キャッチした例外をそのまま再送出
    finally:
        print("[Gen] finallyブロック実行 (クリーンアップ)")
    print("[Gen] 正常終了") # 例外が発生しなければここに来る

gen_ex = exception_handling_generator()

# 1. 開始して最初のyieldまで進める
val1 = next(gen_ex)
print(f"[Main] 受け取り: {val1}")

# 2. ValueErrorを送出する
try:
    val2 = gen_ex.throw(ValueError, "テスト用のValueErrorです！")
    print(f"[Main] ValueError処理後の受け取り: {val2}")
except Exception as e:
    print(f"[Main] 予期せぬ例外をキャッチ: {type(e).__name__}: {e}")


# 3. 新しいジェネレータでTypeErrorを送出する (finallyも確認)
gen_ex2 = exception_handling_generator()
next(gen_ex2) # 開始
try:
    gen_ex2.throw(TypeError)
except TypeError:
    print("[Main] TypeErrorがジェネレータから再送出されたのをキャッチしました。")
except Exception as e:
    print(f"[Main] 予期せぬ例外をキャッチ: {type(e).__name__}: {e}")

            

def cleanup_generator():
    print("[Cleanup Gen] 開始")
    resource = "[リソース確保]" # 例: ファイルを開く、接続を確立するなど
    print(f"[Cleanup Gen] {resource}")
    try:
        i = 0
        while True:
             yield f"データ {i}"
             i += 1
    except GeneratorExit:
        print("[Cleanup Gen] GeneratorExitをキャッチしました。終了処理を行います。")
        # ここでクリーンアップ処理
        resource = "[リソース解放]"
        print(f"[Cleanup Gen] {resource}")
        # ここでさらに yield しようとすると RuntimeError になる
        # yield "終了後にyieldはできません"
    finally:
        # GeneratorExitが発生しなくても、正常終了や他の例外時にも呼ばれる
        print("[Cleanup Gen] finallyブロックが常に実行されます。")

gen_cleanup = cleanup_generator()

# いくつか値を取得
print(next(gen_cleanup))
print(next(gen_cleanup))

# ジェネレータを閉じる
print("[Main] close() を呼び出します...")
gen_cleanup.close()
print("[Main] close() の呼び出し後")

# close()後にnext()を呼ぶとStopIterationになる
try:
    next(gen_cleanup)
except StopIteration:
    print("[Main] close()後のnext()はStopIterationになります。")