{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Свой контейнер: __len__, __getitem__, __contains__\n",
    "\n",
    "Магические методы контейнера: len(), bool() и if, квадратные скобки и in работают с вашим объектом так же, как со списком или словарём.\n",
    "\n",
    "Курс ООП в Python · урок `oop-container` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/oop/container).\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": [
    "Корзина и меню из прошлых модулей хранят товары внутри, но снаружи с ними неудобно: чтобы узнать число\n",
    "товаров, пишут `len(cart.items)`, а чтобы найти товар — вызывают метод. Со списком или словарём всё проще:\n",
    "`len(menu)`, `menu[0]`, `\"Латте\" in menu`. Такие объекты называют **контейнерами**. Свой класс тоже может\n",
    "стать контейнером — нужно объявить несколько магических методов. Набор методов, которые ждёт встроенная\n",
    "операция, называют **протоколом** (protocol): здесь — протоколом контейнера.\n",
    "\n",
    "## `len` и `bool`\n",
    "\n",
    "`len(x)` вызывает `x.__len__()` — метод должен вернуть целое число не меньше нуля. А в `if x:` и `bool(x)`\n",
    "Python спрашивает `x.__bool__()`; если такого метода нет, но есть `__len__`, — объект ложен, когда его длина 0.\n",
    "Поэтому пустая корзина с `__len__` сама собой становится «ложью»:"
   ],
   "id": "text-9"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# len и if для заказа\n",
    "class Ticket:\n",
    "    def __init__(self, number, lines):\n",
    "        self.number = number\n",
    "        self.lines = list(lines)\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.lines)\n",
    "\n",
    "\n",
    "full = Ticket(17, [\"латте\", \"круассан\"])\n",
    "empty = Ticket(18, [])\n",
    "print(len(full), len(empty))\n",
    "for ticket in [full, empty]:\n",
    "    if ticket:\n",
    "        print(f\"заказ №{ticket.number}: {len(ticket)} поз.\")\n",
    "    else:\n",
    "        print(f\"заказ №{ticket.number} пуст\")"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "len"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 1. Длина корзины\n",
    "\n",
    "Допишите класс `Cart`: `len(cart)` — число товаров в корзине. После этого `if cart:` будет пропускать пустую\n",
    "корзину — проверка упражнения это тоже проверит.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Длина корзины — это длина её списка товаров.\n",
    "\n",
    "</details>"
   ],
   "id": "cart-len-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 Cart:\n",
    "    def __init__(self):\n",
    "        self.items = []\n",
    "\n",
    "    def add(self, product):\n",
    "        self.items.append(product)\n",
    "\n",
    "    def __len__(self):\n",
    "        ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "cart-len"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 1 — выполните после своего решения\n",
    "def test_len():\n",
    "    \"len — число товаров\"\n",
    "    cart = Cart()\n",
    "    assert len(cart) == 0, \"у пустой корзины len должен быть 0\"\n",
    "    cart.add(Product(\"Латте\", 220))\n",
    "    cart.add(Product(\"Чай\", 120))\n",
    "    try:\n",
    "        n = len(cart)\n",
    "    except TypeError as e:\n",
    "        assert False, f\"len(cart) не работает: {e}. __len__ должен вернуть целое число — число товаров\"\n",
    "    assert n == 2, f\"в корзине два товара, а len = {n}\"\n",
    "\n",
    "\n",
    "def test_bool():\n",
    "    \"пустая корзина — ложь\"\n",
    "    cart = Cart()\n",
    "    assert not cart, \"пустая корзина должна быть «ложью» — это даёт __len__, возвращающий 0\"\n",
    "    cart.add(Product(\"Чай\", 120))\n",
    "    assert cart, \"корзина с товаром должна быть «истиной»\"\n",
    "\n",
    "_check(test_len, test_bool, names=[\"Cart.__len__\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "cart-len-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 Cart:\n",
    "    def __init__(self):\n",
    "        self.items = []\n",
    "\n",
    "    def add(self, product):\n",
    "        self.items.append(product)\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.items)\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "cart-len-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`__bool__` объявляют, когда «истинность» объекта означает не «непустой», а что-то другое:"
   ],
   "id": "text-30"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 2. Готова ли кофемашина\n",
    "\n",
    "Допишите класс `CoffeeMachine`: `bool(machine)` — `True`, если в ней есть и вода (`water` больше 0 мл), и\n",
    "зёрна (`beans` больше 0 г). Тогда кассир сможет писать `if machine:`.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Нужны оба условия сразу — соедините два сравнения через `and`.\n",
    "\n",
    "</details>\n",
    "<details><summary>Подсказка 2</summary>\n",
    "\n",
    "`__bool__` должен вернуть именно `True` или `False` — результат сравнения подходит.\n",
    "\n",
    "</details>"
   ],
   "id": "machine-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "class CoffeeMachine:\n",
    "    def __init__(self, water, beans):\n",
    "        self.water = water\n",
    "        self.beans = beans\n",
    "\n",
    "    def __bool__(self):\n",
    "        ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "machine"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 2 — выполните после своего решения\n",
    "def test_ready():\n",
    "    \"есть вода и зёрна — True\"\n",
    "    try:\n",
    "        got = bool(CoffeeMachine(1500, 300))\n",
    "    except TypeError as e:\n",
    "        assert False, f\"bool(machine) не работает: {e}. __bool__ должен вернуть True или False\"\n",
    "    assert got is True, \"в машине есть и вода, и зёрна — bool(machine) должен быть True\"\n",
    "\n",
    "\n",
    "def test_not_ready():\n",
    "    \"нет воды или зёрен — False\"\n",
    "    assert not CoffeeMachine(0, 300), \"без воды машина не готова\"\n",
    "    assert not CoffeeMachine(1500, 0), \"без зёрен машина не готова — проверяйте оба условия через and\"\n",
    "\n",
    "_check(test_ready, test_not_ready, names=[\"CoffeeMachine.__bool__\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "machine-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "class CoffeeMachine:\n",
    "    def __init__(self, water, beans):\n",
    "        self.water = water\n",
    "        self.beans = beans\n",
    "\n",
    "    def __bool__(self):\n",
    "        return self.water > 0 and self.beans > 0\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "machine-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Квадратные скобки: `__getitem__`\n",
    "\n",
    "`x[key]` вызывает `x.__getitem__(key)`. Что считать ключом, решает класс: список принимает номер, словарь —\n",
    "ключ. Например, расписание смен удобно открывать по дню недели:"
   ],
   "id": "text-40"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Бариста по дню недели\n",
    "class Schedule:\n",
    "    def __init__(self, shifts):\n",
    "        self._shifts = dict(shifts)  # день → бариста\n",
    "\n",
    "    def __getitem__(self, day):\n",
    "        if day not in self._shifts:\n",
    "            raise KeyError(day)\n",
    "        return self._shifts[day]\n",
    "\n",
    "\n",
    "week = Schedule({\"пн\": \"Анна\", \"вт\": \"Борис\", \"ср\": \"Анна\"})\n",
    "print(week[\"вт\"])\n",
    "try:\n",
    "    week[\"вс\"]\n",
    "except KeyError as error:\n",
    "    print(\"нет смены:\", error)"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "getitem"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если такого ключа нет, по соглашению выбрасывают `KeyError` (для номеров — `IndexError`), как делает словарь.\n",
    "\n",
    "## `in`: `__contains__`\n",
    "\n",
    "`x in container` вызывает `container.__contains__(x)`. Без него Python перебрал бы элементы по одному — но\n",
    "только если объект умеет перебираться. С `__contains__` вы сами решаете, что значит «есть в контейнере»:"
   ],
   "id": "text-47"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Работает ли кофейня в этот день\n",
    "class OpenDays:\n",
    "    def __init__(self, days):\n",
    "        self._days = list(days)\n",
    "\n",
    "    def __contains__(self, day):\n",
    "        return day in self._days\n",
    "\n",
    "\n",
    "open_days = OpenDays([\"пн\", \"вт\", \"ср\", \"чт\", \"пт\", \"сб\"])\n",
    "print(\"сб\" in open_days, \"вс\" in open_days)"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "contains"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 3. Меню по названию\n",
    "\n",
    "Допишите класс `Menu`: `menu[\"Латте\"]` возвращает товар с этим названием, а если его нет — выбрасывает\n",
    "`KeyError` с названием; `\"Латте\" in menu` — `True`, если такой товар есть в меню.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Найти товар — цикл по `self._items`; выбросить `KeyError` можно только когда проверены все товары, то есть после цикла.\n",
    "\n",
    "</details>\n",
    "<details><summary>Подсказка 2</summary>\n",
    "\n",
    "В `__contains__` можно перебрать товары и сравнить названия — или попробовать `self[name]` и перехватить `KeyError`.\n",
    "\n",
    "</details>"
   ],
   "id": "menu-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "class Menu:\n",
    "    def __init__(self, products):\n",
    "        self._items = list(products)\n",
    "\n",
    "    def __getitem__(self, name):\n",
    "        ...\n",
    "\n",
    "    def __contains__(self, name):\n",
    "        ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "menu"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 3 — выполните после своего решения\n",
    "def _menu():\n",
    "    return Menu([Product(\"Латте\", 220), Product(\"Чай\", 120)])\n",
    "\n",
    "\n",
    "def test_getitem():\n",
    "    \"menu[название] — товар\"\n",
    "    menu = _menu()\n",
    "    try:\n",
    "        got = menu[\"Чай\"]\n",
    "    except KeyError:\n",
    "        assert False, \"menu[\\\"Чай\\\"] выбросил KeyError, хотя чай в меню есть — raise должен стоять после цикла, когда проверены все товары\"\n",
    "    assert got is not None, \"menu[\\\"Чай\\\"] вернул None — верните найденный товар\"\n",
    "    assert isinstance(got, Product) and got.name == \"Чай\", f\"menu[\\\"Чай\\\"] = {got!r}, а нужен товар «Чай»\"\n",
    "\n",
    "\n",
    "def test_missing():\n",
    "    \"нет товара — KeyError\"\n",
    "    try:\n",
    "        got = _menu()[\"Какао\"]\n",
    "    except KeyError:\n",
    "        return\n",
    "    assert False, f\"menu[\\\"Какао\\\"] вернул {got!r}, а для отсутствующего товара нужен KeyError: raise KeyError(name)\"\n",
    "\n",
    "\n",
    "def test_contains():\n",
    "    \"in — по названию\"\n",
    "    menu = _menu()\n",
    "    assert (\"Латте\" in menu) is True, \"\\\"Латте\\\" in menu должно быть True\"\n",
    "    assert (\"Какао\" in menu) is False, \"\\\"Какао\\\" in menu должно быть False\"\n",
    "\n",
    "_check(test_getitem, test_missing, test_contains, names=[\"Menu.__getitem__\",\"Menu.__contains__\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "menu-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 __getitem__(self, name):\n",
    "        for p in self._items:\n",
    "            if p.name == name:\n",
    "                return p\n",
    "        raise KeyError(name)\n",
    "\n",
    "    def __contains__(self, name):\n",
    "        for p in self._items:\n",
    "            if p.name == name:\n",
    "                return True\n",
    "        return False\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "menu-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Вопрос.** У класса `Cart` есть `__len__`, но нет `__bool__`. Что напечатает `print(bool(Cart()))` для пустой корзины?\n",
    "\n",
    "- `False`\n",
    "- `True`\n",
    "- ошибку `TypeError`\n",
    "\n",
    "<details><summary>Ответ</summary>\n",
    "\n",
    "`False`\n",
    "\n",
    "Без `__bool__` Python спрашивает `__len__`: длина 0 — значит, объект ложен. Без обоих методов любой объект был бы истинным.\n",
    "\n",
    "</details>"
   ],
   "id": "quiz-65"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python"
  },
  "colab": {
   "provenance": []
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}