Das Iterator-Protokoll

class Countdown:
    """Counts down from start to 1, one number per next()."""

    def __init__(self, start: int) -> None:
        self.current = start

    def __iter__(self) -> "Countdown":
        return self

    def __next__(self) -> int:
        # Raise StopIteration when the count is used up;
        # otherwise return the current number and step down.
        raise StopIteration


if __name__ == "__main__":
    print(list(Countdown(3)))

from main import Countdown


def test_counts_down():
    """Countdown(3) liefert 3, 2, 1"""
    got = list(Countdown(3))
    assert got == [3, 2, 1], f"list(Countdown(3)) lieferte {got!r}, erwartet: [3, 2, 1]"


def test_next_by_hand():
    """next() liefert pro Aufruf eine Zahl"""
    c = Countdown(2)
    got = next(c), next(c)
    assert got == (2, 1), f"zwei next()-Aufrufe lieferten {got!r}, erwartet: (2, 1)"


def test_is_its_own_iterator():
    """iter() eines Countdown ist der Countdown selbst"""
    c = Countdown(2)
    assert iter(c) is c, "iter(c) lieferte nicht c selbst: __iter__ muss self zurückgeben"


def test_stays_exhausted():
    """Nach der letzten Zahl löst next() weiter StopIteration aus"""
    c = Countdown(1)
    list(c)
    for _ in range(2):
        try:
            got = next(c)
        except StopIteration:
            continue
        raise AssertionError(f"next() auf einem verbrauchten Countdown lieferte {got!r}, statt StopIteration auszulösen")


def test_zero():
    """Countdown(0) liefert nichts"""
    got = list(Countdown(0))
    assert got == [], f"list(Countdown(0)) lieferte {got!r}, erwartet: []"

class Sentence:
    """The words of a text; loop over it as often as you like."""

    def __init__(self, text: str) -> None:
        self.words = text.split()
        self.index = 0

    def __iter__(self) -> "Sentence":
        return self

    def __next__(self) -> str:
        if self.index >= len(self.words):
            raise StopIteration
        word = self.words[self.index]
        self.index += 1
        return word


if __name__ == "__main__":
    s = Sentence("to be or not")
    print(list(s))
    print(list(s))

from main import Sentence


def test_words():
    """Ein Sentence liefert seine Wörter in Reihenfolge"""
    got = list(Sentence("to be or not"))
    assert got == ["to", "be", "or", "not"], f"list(Sentence('to be or not')) lieferte {got!r}"


def test_two_loops():
    """Eine zweite Schleife liefert wieder alle Wörter"""
    s = Sentence("to be or not")
    first, second = list(s), list(s)
    assert first == second == ["to", "be", "or", "not"], f"zwei list(s)-Aufrufe lieferten {first!r} und {second!r}"


def test_fresh_iterator():
    """iter(s) liefert einen neuen Iterator, nicht s selbst"""
    s = Sentence("a b")
    assert iter(s) is not s, "iter(s) lieferte s selbst: Ein Sentence sollte einen neuen Iterator herausgeben"


def test_nested_loops():
    """Zwei Schleifen über denselben Sentence können gleichzeitig laufen"""
    s = Sentence("x y")
    got = [a + b for a in s for b in s]
    assert got == ["xx", "xy", "yx", "yy"], f"die verschachtelten Schleifen ergaben {got!r}, erwartet: ['xx', 'xy', 'yx', 'yy']"

from collections.abc import Iterable


def take(iterable: Iterable[str], n: int) -> list[str]:
    """Return the first n items of iterable, or fewer if it runs out."""
    return list(iterable)[:n]


if __name__ == "__main__":
    print(take(["a", "b", "c"], 2))

from main import take


def test_first_two():
    """take(['a', 'b', 'c'], 2) ist ['a', 'b']"""
    got = take(["a", "b", "c"], 2)
    assert got == ["a", "b"], f"take(['a', 'b', 'c'], 2) lieferte {got!r}"


def test_runs_out():
    """Wer mehr Elemente verlangt, als es gibt, bekommt alle"""
    got = take("xyz", 5)
    assert got == ["x", "y", "z"], f"take('xyz', 5) lieferte {got!r}, erwartet: ['x', 'y', 'z']"


def test_leaves_the_rest():
    """take(it, 2) lässt das dritte Element im Iterator"""
    it = iter(["a", "b", "c", "d"])
    take(it, 2)
    got = next(it, None)
    assert got == "c", f"nach take(it, 2) lieferte next(it) {got!r}, erwartet: 'c'. take hat zu viele Elemente verbraucht"


def test_zero():
    """take(..., 0) ist eine leere Liste"""
    got = take(["a"], 0)
    assert got == [], f"take(['a'], 0) lieferte {got!r}, erwartet: []"