{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Объект в цикле for: __iter__\n",
    "\n",
    "__iter__ с yield делает объект итерируемым: for, list(), sum() и генераторы списков работают с ним сами. Итерируемый объект против итератора и итератор на один проход.\n",
    "\n",
    "Курс ООП в Python · урок `oop-iter` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/oop/iter).\n",
    "\n",
    "Выполняйте ячейки по порядку (Shift+Enter), начиная с первой — она готовит урок. После каждого упражнения идёт\n",
    "ячейка проверки: она печатает ✓ / ✗ и итог."
   ],
   "id": "intro"
  },
  {
   "cell_type": "code",
   "metadata": {
    "cellView": "form",
    "jupyter": {
     "source_hidden": true
    }
   },
   "source": [
    "# @title Подготовка урока — выполните эту ячейку первой\n",
    "# Проверяет версии пакетов, записывает файлы данных в папку data/ и определяет _check — проверку упражнений.\n",
    "import base64, os, zlib\n",
    "\n",
    "import sys\n",
    "\n",
    "if sys.version_info < (3, 10):\n",
    "    print(f\"Урок написан для Python 3.10 и новее, у вас {sys.version.split()[0]} — часть кода может не работать\")\n",
    "\n",
    "# ─── Проверка упражнений: тот же раннер, что у задач на сайте ───\n",
    "# ─── Запуск тестов ───────────────────────────────────────────────────────────\n",
    "\n",
    "_TIMEOUT = 2.0  # секунд на тест; отдельный тест может задать свой: test_x.timeout = 10\n",
    "\n",
    "\n",
    "def _call_with_timeout(target, seconds: float) -> bool:\n",
    "    \"\"\"Запускает target() в отдельном потоке. Возвращает False, если за seconds он не завершился.\"\"\"\n",
    "    import sys\n",
    "    import threading\n",
    "\n",
    "    if sys.platform == \"emscripten\":  # Python в браузере: потоков нет, таймаут обеспечивает страница\n",
    "        target()\n",
    "        return True\n",
    "    # Большой стек нужен, чтобы глубокая рекурсия давала RecursionError, а не аварийное завершение Python.\n",
    "    for megabytes in (256, 64, 0):\n",
    "        try:\n",
    "            threading.stack_size(megabytes * 1024 * 1024)\n",
    "            worker = threading.Thread(target=target, daemon=True)\n",
    "            worker.start()\n",
    "        except (ValueError, RuntimeError, MemoryError):\n",
    "            continue\n",
    "        worker.join(seconds)\n",
    "        return not worker.is_alive()\n",
    "    target()  # потоки недоступны — запускаем без таймаута\n",
    "    return True\n",
    "\n",
    "\n",
    "def _test_info(fn) -> dict:\n",
    "    \"\"\"Описание теста, его лимит времени и сообщение на случай зависания.\"\"\"\n",
    "    limit = getattr(fn, \"timeout\", _TIMEOUT)\n",
    "    hint = getattr(fn, \"timeout_hint\", \"\")\n",
    "    message = (\n",
    "        f\"тест не завершился за {limit:g} с — возможно, бесконечный цикл или рекурсия: \"\n",
    "        \"проверьте, что границы/аргументы изменяются на каждом шаге\" + (f\". {hint}\" if hint else \"\")\n",
    "    )\n",
    "    return {\"title\": (fn.__doc__ or fn.__name__).strip(), \"timeout\": limit, \"timeout_message\": message}\n",
    "\n",
    "\n",
    "def _error_result(title: str, error: BaseException, user_file: str | None) -> dict:\n",
    "    \"\"\"Результат упавшего теста: статус, сообщение, тип исключения и строка в коде решения.\"\"\"\n",
    "    line = None\n",
    "    if user_file:  # самый глубокий кадр в коде решения; ошибка внутри самих тестов — без номера строки\n",
    "        tb = error.__traceback__\n",
    "        while tb is not None:\n",
    "            if tb.tb_frame.f_code.co_filename == user_file:\n",
    "                line = tb.tb_lineno\n",
    "            tb = tb.tb_next\n",
    "    status, message = \"error\", f\"{type(error).__name__}: {error}\"\n",
    "    if isinstance(error, NotImplementedError):\n",
    "        status, message, line = \"not_written\", \"функция ещё не написана\", None\n",
    "    elif isinstance(error, AssertionError):\n",
    "        status, message = \"failed\", str(error) or \"проверка не прошла\"\n",
    "    elif isinstance(error, RecursionError):\n",
    "        message = \"RecursionError: слишком глубокая рекурсия — проверьте базовый случай и то, что задача уменьшается\"\n",
    "    elif isinstance(error, MemoryError) or (isinstance(error, OverflowError) and \"index-sized\" in str(error)):\n",
    "        message = f\"{type(error).__name__}: не хватило памяти — возможно, создаётся слишком большая структура данных\"\n",
    "    return {\"title\": title, \"status\": status, \"message\": message, \"error_type\": type(error).__name__, \"line\": line}\n",
    "\n",
    "\n",
    "def _run_tests(verbose: bool = True, on_start=None, on_result=None, user_file: str | None = None) -> list[dict]:\n",
    "    \"\"\"Запускает тесты задачи (_TESTS — функции из tests.py) по порядку, каждый — с таймаутом.\n",
    "\n",
    "    Возвращает список результатов: {\"title\", \"status\", \"message\", \"error_type\", \"line\"}, где status —\n",
    "    passed · failed · error · not_written · timeout · not_run. Если тест завис, при verbose=True печатает\n",
    "    итог и завершает процесс: зависший поток остановить нельзя. on_start(i) и on_result(i, результат)\n",
    "    вызываются по мере выполнения; user_file — имя файла с кодом решения для номеров строк в ошибках.\n",
    "    \"\"\"\n",
    "    import os\n",
    "    import sys\n",
    "\n",
    "    if verbose:\n",
    "        try:  # ✓ и кириллица в консоли Windows со старой кодировкой\n",
    "            sys.stdout.reconfigure(encoding=\"utf-8\")\n",
    "        except Exception:  # noqa: BLE001 — reconfigure может не быть (перенаправленный вывод, браузер)\n",
    "            pass\n",
    "\n",
    "    tests = list(_TESTS)\n",
    "    results: list[dict] = []\n",
    "    not_written = hung = False\n",
    "    for index, fn in enumerate(tests):\n",
    "        info = _test_info(fn)\n",
    "        outcome: dict = {}\n",
    "\n",
    "        def target(fn=fn, outcome=outcome):\n",
    "            try:\n",
    "                fn()\n",
    "            except BaseException as e:\n",
    "                outcome[\"error\"] = e\n",
    "\n",
    "        if on_start:\n",
    "            on_start(index)\n",
    "        if not _call_with_timeout(target, info[\"timeout\"]):\n",
    "            results.append({\"title\": info[\"title\"], \"status\": \"timeout\", \"message\": info[\"timeout_message\"], \"error_type\": None, \"line\": None})\n",
    "            for other in tests[index + 1:]:\n",
    "                results.append({\"title\": _test_info(other)[\"title\"], \"status\": \"not_run\", \"message\": \"не запускался: предыдущий тест завис\", \"error_type\": None, \"line\": None})\n",
    "            hung = True\n",
    "            break\n",
    "        error = outcome.get(\"error\")\n",
    "        if error is None:\n",
    "            result = {\"title\": info[\"title\"], \"status\": \"passed\", \"message\": \"\", \"error_type\": None, \"line\": None}\n",
    "        else:\n",
    "            result = _error_result(info[\"title\"], error, user_file)\n",
    "            not_written = not_written or result[\"status\"] == \"not_written\"\n",
    "        results.append(result)\n",
    "        if on_result:\n",
    "            on_result(index, result)\n",
    "\n",
    "    if not_written:  # пока функция не написана, «даром» пройденные тесты не засчитываются\n",
    "        for r in results:\n",
    "            if r[\"status\"] == \"passed\":\n",
    "                r.update(status=\"not_written\", message=\"не засчитан, пока функция не написана\")\n",
    "    for r in results:\n",
    "        if len(r[\"message\"]) > 300:\n",
    "            r[\"message\"] = r[\"message\"][:300] + \"…\"\n",
    "\n",
    "    if verbose:\n",
    "        if not_written:\n",
    "            print(\"Функция ещё не написана — замените raise NotImplementedError своим кодом.\\n\")\n",
    "        for r in results:\n",
    "            mark = {\"passed\": \"✓\", \"not_run\": \"–\"}.get(r[\"status\"], \"✗\")\n",
    "            print(f\"{mark} {r['title']}\")\n",
    "            if r[\"message\"]:\n",
    "                print(f\"    {r['message']}\")\n",
    "        passed = sum(r[\"status\"] == \"passed\" for r in results)\n",
    "        print(\"─\" * 40)\n",
    "        print(f\"Прошло {passed} из {len(results)}\" + (\" — всё верно!\" if passed == len(results) else \"\"))\n",
    "        if hung:\n",
    "            print(\"Выполнение остановлено: один из тестов завис.\")\n",
    "            sys.stdout.flush()\n",
    "            os._exit(1)\n",
    "    return results\n",
    "\n",
    "\n",
    "def _check(*tests, names=()):\n",
    "    \"\"\"Запускает проверки упражнения и печатает ✓ / ✗ и итог — как на сайте.\"\"\"\n",
    "    for name in names:\n",
    "        if \".\" in name:  # «Класс.метод» из заготовки: класс должен быть объявлен\n",
    "            if not isinstance(globals().get(name.split(\".\")[0]), type):\n",
    "                print(f\"✗ класс {name.split('.')[0]} не объявлен — выполните ячейку упражнения\")\n",
    "                return\n",
    "            continue\n",
    "        if name not in globals():\n",
    "            print(f\"✗ переменная {name} не создана — выполните ячейку упражнения\")\n",
    "            return\n",
    "        if globals()[name] is Ellipsis:\n",
    "            print(f\"✗ {name} пока равна ... — замените многоточие своим кодом\")\n",
    "            return\n",
    "    globals()[\"_TESTS\"] = list(tests)\n",
    "    _run_tests()"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "setup"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`for p in menu.items` работает, но открывает внутренности меню. Хочется писать просто `for p in menu:` —\n",
    "и чтобы так же работали `list(menu)`, `sum(...)` и генераторы списков. Для этого объекту нужен метод\n",
    "`__iter__`.\n",
    "\n",
    "## `__iter__` и `yield`\n",
    "\n",
    "`for x in obj` начинается с вызова `obj.__iter__()`. Проще всего написать этот метод с `yield`: функция или\n",
    "метод, в теле которого есть `yield`, — это **генератор** (generator). Он не возвращает значение один раз, как\n",
    "`return`, а **выдаёт** значения по одному: `yield` отдаёт очередное значение циклу и замирает до следующего\n",
    "шага. Когда тело метода закончилось, цикл тоже заканчивается."
   ],
   "id": "text-9"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Генератор выдаёт значения по одному\n",
    "def countdown(n):\n",
    "    while n > 0:\n",
    "        yield n  # выдать значение и замереть до следующего шага\n",
    "        n -= 1\n",
    "\n",
    "\n",
    "for x in countdown(3):\n",
    "    print(x)\n",
    "print(list(countdown(5)))"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "yield"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В `__iter__` можно и не писать `yield`: достаточно вернуть итератор по внутреннему списку — `iter(…)` (о нём\n",
    "подробнее ниже). Важно одно — `for` получает новый итератор при каждом обходе:"
   ],
   "id": "text-22"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Смена по часам в цикле for\n",
    "class Shift:\n",
    "    def __init__(self, barista, hours):\n",
    "        self.barista = barista\n",
    "        self._hours = list(hours)\n",
    "\n",
    "    def __iter__(self):\n",
    "        return iter(self._hours)  # новый итератор по списку часов\n",
    "\n",
    "\n",
    "morning = Shift(\"Анна\", [\"08:00\", \"09:00\", \"10:00\"])\n",
    "for hour in morning:\n",
    "    print(morning.barista, hour)\n",
    "print(list(morning), len(list(morning)))"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "iter"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 1. Меню в цикле\n",
    "\n",
    "Допишите класс `Menu`: `for p in menu` перебирает товары меню по порядку. После этого заработают и\n",
    "`list(menu)`, и `[p.name for p in menu]`.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Как `countdown`: пройдите по внутреннему списку и выдавайте элементы по одному.\n",
    "\n",
    "</details>\n",
    "<details><summary>Подсказка 2</summary>\n",
    "\n",
    "`yield p` внутри цикла `for p in self._items:`.\n",
    "\n",
    "</details>"
   ],
   "id": "menu-iter-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "class Product:\n",
    "    def __init__(self, name, price):\n",
    "        self.name = name\n",
    "        self.price = price\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f\"Product({self.name!r}, {self.price})\"\n",
    "\n",
    "\n",
    "class Menu:\n",
    "    def __init__(self, products):\n",
    "        self._items = list(products)\n",
    "\n",
    "    def __iter__(self):\n",
    "        ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "menu-iter"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 1 — выполните после своего решения\n",
    "def _menu():\n",
    "    return Menu([Product(\"Латте\", 220), Product(\"Чай\", 120), Product(\"Раф\", 260)])\n",
    "\n",
    "\n",
    "def test_for():\n",
    "    \"for перебирает товары по порядку\"\n",
    "    try:\n",
    "        names = [p.name for p in _menu()]\n",
    "    except TypeError as e:\n",
    "        if \"list\" in str(e):\n",
    "            assert False, \"__iter__ вернул список — список итерируемый, но не итератор: верните iter(self._items) или выдавайте товары через yield\"\n",
    "        assert False, f\"меню не перебирается циклом: {e}. __iter__ должен выдавать товары через yield\"\n",
    "    except AttributeError:\n",
    "        assert False, \"цикл по меню выдал не товары, а весь список сразу — выдавайте товары по одному: yield p внутри цикла\"\n",
    "    assert names == [\"Латте\", \"Чай\", \"Раф\"], f\"цикл по меню дал {names}\"\n",
    "\n",
    "\n",
    "def test_twice():\n",
    "    \"меню можно пройти дважды\"\n",
    "    menu = _menu()\n",
    "    try:\n",
    "        first, second = list(menu), list(menu)\n",
    "    except TypeError:\n",
    "        assert False, \"меню не перебирается циклом — сначала исправьте __iter__ (проверка выше)\"\n",
    "    assert len(first) == 3, f\"проход по меню выдал {len(first)} шт., а товаров 3 — выдавайте каждый товар через yield p, а не весь список\"\n",
    "    assert len(second) == 3, \"второй проход по меню пуст — __iter__ должен каждый раз начинать заново\"\n",
    "    assert first == second\n",
    "\n",
    "_check(test_for, test_twice, names=[\"Menu.__iter__\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "menu-iter-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "class Product:\n",
    "    def __init__(self, name, price):\n",
    "        self.name = name\n",
    "        self.price = price\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f\"Product({self.name!r}, {self.price})\"\n",
    "\n",
    "\n",
    "class Menu:\n",
    "    def __init__(self, products):\n",
    "        self._items = list(products)\n",
    "\n",
    "    def __iter__(self):\n",
    "        for p in self._items:\n",
    "            yield p\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "menu-iter-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Генератор в обычном методе\n",
    "\n",
    "`yield` можно писать и в обычном методе — тогда метод возвращает генератор, по которому можно пройти циклом.\n",
    "Это удобно для «выборок» без промежуточных списков:"
   ],
   "id": "text-35"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 2. Товары дешевле суммы\n",
    "\n",
    "Добавьте в класс `Menu` (скопируйте его из упражнения выше) метод `cheaper_than(price)`: генератор, который\n",
    "выдаёт по порядку товары дешевле `price`. Используйте `yield`, а не список.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Генератор с условием: выдавайте только подходящие товары.\n",
    "\n",
    "</details>"
   ],
   "id": "cheaper-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "class Menu:\n",
    "    # скопируйте сюда __init__ и __iter__ из упражнения выше\n",
    "\n",
    "    def cheaper_than(self, price):\n",
    "        ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "cheaper"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 2 — выполните после своего решения\n",
    "def _menu():\n",
    "    try:\n",
    "        return Menu([Product(\"Латте\", 220), Product(\"Чай\", 120), Product(\"Какао\", 190)])\n",
    "    except TypeError:\n",
    "        assert False, \"Menu([...]) не создаётся — скопируйте __init__ из упражнения выше\"\n",
    "\n",
    "\n",
    "def test_copied():\n",
    "    \"__iter__ на месте\"\n",
    "    assert \"__iter__\" in Menu.__dict__, \"в классе нет __iter__ — скопируйте класс из упражнения выше\"\n",
    "    assert [p.name for p in _menu()] == [\"Латте\", \"Чай\", \"Какао\"], \"цикл по меню работает не так, как в упражнении выше\"\n",
    "\n",
    "\n",
    "def test_cheaper():\n",
    "    \"cheaper_than выдаёт дешёвые товары\"\n",
    "    got = _menu().cheaper_than(200)\n",
    "    assert not isinstance(got, list), \"cheaper_than вернул список, а нужен генератор — используйте yield\"\n",
    "    assert got is not None, \"cheaper_than ничего не возвращает — выдавайте товары через yield\"\n",
    "    names = [p.name for p in got]\n",
    "    assert names == [\"Чай\", \"Какао\"], f\"дешевле 200 ₽ — {names}, а нужно ['Чай', 'Какао']\"\n",
    "    assert [p.name for p in _menu().cheaper_than(100)] == [], \"дешевле 100 ₽ ничего нет\"\n",
    "    assert [p.name for p in _menu().cheaper_than(190)] == [\"Чай\"], \"какао стоит ровно 190 ₽ — оно не дешевле 190, сравнение строгое: <\"\n",
    "\n",
    "_check(test_copied, test_cheaper, names=[\"Menu.cheaper_than\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "cheaper-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "class Menu:\n",
    "    def __init__(self, products):\n",
    "        self._items = list(products)\n",
    "\n",
    "    def __iter__(self):\n",
    "        for p in self._items:\n",
    "            yield p\n",
    "\n",
    "    def cheaper_than(self, price):\n",
    "        for p in self._items:\n",
    "            if p.price < price:\n",
    "                yield p\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "cheaper-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Итерируемый объект и итератор\n",
    "\n",
    "За `for` стоят два понятия. **Итерируемый объект** (iterable) — то, по чему можно пройти: список, строка,\n",
    "меню с `__iter__`. **Итератор** (iterator) — объект, который выдаёт элементы по одному и помнит, где\n",
    "остановился. `iter(x)` просит у итерируемого объекта новый итератор, а `next(it)` берёт из итератора\n",
    "следующий элемент. Когда элементы кончились, `next` выбрасывает `StopIteration` — так `for` узнаёт, что пора\n",
    "остановиться:"
   ],
   "id": "text-47"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# iter и next вручную\n",
    "drinks = [\"латте\", \"чай\"]\n",
    "it = iter(drinks)\n",
    "print(next(it))\n",
    "print(next(it))\n",
    "try:\n",
    "    next(it)\n",
    "except StopIteration:\n",
    "    print(\"StopIteration — элементы кончились\")"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "iter-next"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Главное отличие: список, строку или меню с `__iter__` можно проходить сколько угодно раз — каждый `for`\n",
    "вызывает `__iter__` и получает новый итератор. Итератор тоже можно пройти циклом `for` (`iter(it)` возвращает\n",
    "его самого), но только **один раз**: дошёл до конца — пуст навсегда. Генератор — тоже итератор: результат\n",
    "`menu.cheaper_than(200)` из упражнения выше хватает на один проход, для второго вызовите метод снова."
   ],
   "id": "text-57"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Второй проход по итератору пуст\n",
    "it = iter(drinks)\n",
    "print(list(it))\n",
    "print(list(it))  # итератор уже пройден\n",
    "print(list(drinks), list(drinks))  # список — сколько угодно раз"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "one-pass"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Типичная ошибка: итератор на один проход.**\n",
    ">\n",
    "> Если `__iter__` возвращает один и тот же сохранённый итератор (например, `self._it = iter(songs)` в\n",
    "> `__init__`), объект можно пройти только один раз: второй `for` ничего не найдёт, без всякой ошибки.\n",
    "> `__iter__` должен каждый раз отдавать **новый** итератор — так и получается с `yield` или с `return iter(self._items)`."
   ],
   "id": "component-65"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 3. Плейлист на весь день\n",
    "\n",
    "В заготовке — класс `Playlist` с ошибкой из блока выше: плейлист кофейни проигрывается только один раз.\n",
    "Исправьте класс, чтобы плейлист можно было проходить сколько угодно раз. Песни храните копией переданного\n",
    "списка — чтобы плейлист не менялся, если потом изменят исходный список.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Сохранять нужно не итератор, а сами песни; итератор пусть создаётся заново при каждом вызове `__iter__`.\n",
    "\n",
    "</details>"
   ],
   "id": "playlist-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "class Playlist:\n",
    "    def __init__(self, songs):\n",
    "        self._it = iter(songs)\n",
    "\n",
    "    def __iter__(self):\n",
    "        return self._it"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "playlist"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 3 — выполните после своего решения\n",
    "def test_twice():\n",
    "    \"плейлист проходится несколько раз\"\n",
    "    playlist = Playlist([\"Джаз утром\", \"Босса-нова\"])\n",
    "    first = list(playlist)\n",
    "    second = list(playlist)\n",
    "    assert first == [\"Джаз утром\", \"Босса-нова\"], f\"первый проход дал {first}\"\n",
    "    assert second == first, \"второй проход по плейлисту пуст — __iter__ должен отдавать новый итератор каждый раз\"\n",
    "\n",
    "\n",
    "def test_source_list():\n",
    "    \"исходный список не нужен после создания\"\n",
    "    songs = [\"Джаз утром\"]\n",
    "    playlist = Playlist(songs)\n",
    "    songs.append(\"чужая песня\")\n",
    "    assert list(playlist) == [\"Джаз утром\"], \"плейлист изменился вместе с чужим списком — храните копию: list(songs)\"\n",
    "\n",
    "_check(test_twice, test_source_list)"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "playlist-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "class Playlist:\n",
    "    def __init__(self, songs):\n",
    "        self._songs = list(songs)\n",
    "\n",
    "    def __iter__(self):\n",
    "        for song in self._songs:\n",
    "            yield song\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "playlist-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Вопрос.** `cheap = menu.cheaper_than(200)`. Первый `list(cheap)` дал два товара. Что даст второй `list(cheap)`?\n",
    "\n",
    "- те же два товара\n",
    "- `[]`\n",
    "- ошибку `StopIteration`\n",
    "\n",
    "<details><summary>Ответ</summary>\n",
    "\n",
    "`[]`\n",
    "\n",
    "Генератор — итератор: второй проход начинается там, где закончился первый, то есть в конце. `list` перехватывает `StopIteration` сам и возвращает пустой список. Чтобы пройти ещё раз, вызовите `menu.cheaper_than(200)` снова.\n",
    "\n",
    "</details>"
   ],
   "id": "quiz-79"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Вопрос.** `it = iter([\"латте\"])`. Что будет при втором вызове `next(it)`?\n",
    "\n",
    "- вернётся `\"латте\"` ещё раз\n",
    "- вернётся `None`\n",
    "- исключение `StopIteration`\n",
    "\n",
    "<details><summary>Ответ</summary>\n",
    "\n",
    "исключение `StopIteration`\n",
    "\n",
    "Итератор помнит, что выдал единственный элемент. Больше элементов нет — `next` выбрасывает `StopIteration`. Цикл `for` перехватывает его сам, поэтому в цикле вы его не видите.\n",
    "\n",
    "</details>"
   ],
   "id": "quiz-89"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python"
  },
  "colab": {
   "provenance": []
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}