Summary  
This chapter covers how to implement lazy iterators using generator functions with the `yield` keyword, allowing functions to pause and resume with automatic state management for memory-efficient, on-demand value production.

General domain of usage  
Simulating repeated random processes such as dice rolls.

ジェネレーターは、イテレーターを簡潔かつ可読性の高い方法で作成できるため、遅延評価を容易にする手段。イテレーターは `__iter__()` および `__next__()` メソッドを持つクラスとして実装されるのに対し、ジェネレーターは `yield` キーワードを使用する関数として実装され、値を一度に1つずつ生成。ジェネレーターは呼び出し間で状態を自動的に保持するため、多くの用途で直感的かつ効率的。

ジェネレーターは次の特徴を持つ特殊な関数：

1. `yield` キーワードを `return` の代わりに使用
2. yield が呼ばれると実行を一時停止し、状態を保持
3. 再度呼び出されると、停止した位置から実行を再開

def example_generator():
    yield "First value"
    yield "Second value"
    yield "Third value"

gen = example_generator()
print(next(gen))  # Output: First value
print(next(gen))  # Output: Second value
print(next(gen))  # Output: Third value

import random

def limited_dice_roller(num_rolls):
    for _ in range(num_rolls):
        yield random.randint(1, 6)

# Using the limited dice roller
print("Rolling the dice:")
for roll in limited_dice_roller(5):
    print(f"Rolled: {roll}")

### イテレーターとジェネレーターの違い


import unittest
import user_code
import ast
import re   
import importlib
import types
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def test_dice_roller_is_generator_function(self):
        import user_code
        importlib.reload(user_code)
        dice_roller = getattr(user_code, 'dice_roller', None)
        _dynamic_test(
            self,
            callable(dice_roller),
            "dice_roller is a callable function",
            "dice_roller is not defined as a function",
        )
        gen_obj = dice_roller()
        _dynamic_test(
            self,
            isinstance(gen_obj, types.GeneratorType),
            "dice_roller returns a generator object",
            f"dice_roller() did not return a generator object, got {type(gen_obj)}",
        )

    def test_dice_roller_yields_values_in_range(self):
        import user_code
        importlib.reload(user_code)
        dice_roller = getattr(user_code, 'dice_roller', None)
        gen_obj = dice_roller()
        values = [next(gen_obj) for _ in range(20)]
        valid = all(isinstance(v, int) and 1 <= v <= 6 for v in values)
        _dynamic_test(
            self,
            valid,
            "dice_roller yields only integers between 1 and 6",
            f"dice_roller yielded values outside 1-6: {values}",
        )

    def test_iteration_stops_after_10_rolls(self):
        import user_code
        importlib.reload(user_code)
        # Capture printed output
        f = io.StringIO()
        with redirect_stdout(f):
            dice_roller = getattr(user_code, 'dice_roller', None)
            dice_generator = dice_roller()
            count = 0
            for i, roll in enumerate(dice_generator):
                if i >= 10:
                    break
                print(f"Rolled: {roll}")
                count += 1
        _dynamic_test(
            self,
            count == 10,
            "Iteration stops after 10 rolls.",
            f"Expected 10 rolls, got {count}.",
        )
        output = f.getvalue()
        lines = [line for line in output.splitlines() if line.strip().startswith("Rolled: ")]
        _dynamic_test(
            self,
            len(lines) == 10,
            "Exactly 10 lines printed for rolls.",
            f"Expected 10 printed lines for rolls, got {len(lines)}.",
        )
        # Check all printed values are in correct range
        for line in lines:
            try:
                value = int(line.split(":")[1].strip())
            except Exception:
                _dynamic_test(
                    self,
                    False,
                    "Printed line can be parsed as integer.",
                    f"Could not parse value from line: {line}",
                )
            _dynamic_test(
                self,
                1 <= value <= 6,
                "Printed roll value is in the range 1-6.",
                f"Printed value out of range: {value}",
            )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()


test_main.py

Pythonのモジュールとインポートによる効率的なコード管理の実践的スキルを習得します。より信頼性の高いアプリケーションのための高度なエラーハンドリング技術をマスターし、ファイル操作の自動化をファイルハンドリングで実現し、PytestとUnittestによる堅牢なテスト戦略を学ぶことで、コードの完全性を確保します。

インポート文の扱いに悩んでいる方、モジュールとライブラリの違いが分からない方、またはPythonプロジェクトの構造管理に困っている方にとって、このセクションは明確な理解への鍵となります。

コードのデバッグを効果的に行い、さまざまなエラーを活用する力を理解したい方へ。このセクションでは、Pythonにおけるエラー処理を分かりやすく解説し、堅牢なアプリケーションを開発するために開発者がこれらのスキルを習得する重要性を紹介します。

プロジェクトでのファイル操作を自動化したい方に最適なセクションです。本セクションでは、Pythonにおけるファイル操作の基本を詳しく解説し、ファイルの読み書きや管理を効率的に行うためのツールを習得できます。これにより、よりスムーズで高機能なアプリケーション開発が可能となります。

Pytestを用いたテストの詳細およびテスト駆動開発（TDD）の基礎を学習します。このセクションでは、コードの信頼性を高め、開発プロセスを効率化する堅牢なテストの作成方法を案内します。

Unittestを使用した自動化テストの習得。セットアップ、ティアダウン、モックを活用し、さまざまなテストケースを効果的に網羅する方法を学習します。

Pythonにおいて、イテレータとジェネレータは効率的かつメモリ効率の高いデータ処理を可能にする重要な概念です。イテレータはデータへ逐次的にアクセスするための特定のプロトコルに従い、ジェネレータはyieldキーワードを用いて必要に応じて値を生成することでイテレーションを簡素化します。本セクションでは、これらの概念とその実践的な応用について解説し、メモリ効率の高いプログラミングの習得を支援します。

ジェネレーターの導入：効率的なイテレーションのための値の生成

イテレーターとジェネレーターの違い

解答