{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Методы\n",
    "\n",
    "Метод — функция внутри класса, которая работает с данными своего экземпляра. Метод, который возвращает результат, и метод, который меняет атрибуты; забытый self и вызов без скобок.\n",
    "\n",
    "Курс ООП в Python · урок `oop-methods` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/oop/methods).\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": [
    "`__init__` — первый метод, который вы написали. Но у класса бывают и обычные методы: они описывают, что\n",
    "экземпляр **умеет делать**. Так в класс попадает поведение — как `upper` у строки и `append` у списка.\n",
    "\n",
    "## Свой метод\n",
    "\n",
    "Метод объявляется внутри класса, как функция, и первым параметром получает `self`. Через `self` метод\n",
    "читает атрибуты своего экземпляра:"
   ],
   "id": "text-9"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Метод label\n",
    "class Product:\n",
    "    def __init__(self, name, price, volume):\n",
    "        self.name = name\n",
    "        self.price = price\n",
    "        self.volume = volume\n",
    "\n",
    "    def label(self):\n",
    "        return f\"{self.name}, {self.volume} мл\"\n",
    "\n",
    "\n",
    "latte = Product(\"Латте\", 220, 300)\n",
    "tea = Product(\"Чай\", 120, 400)\n",
    "print(latte.label())\n",
    "print(tea.label())"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "method"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вызов `latte.label()` Python превращает в `Product.label(latte)`: экземпляр слева от точки становится\n",
    "аргументом `self`. Поэтому один и тот же метод у разных экземпляров даёт разный результат — каждый раз\n",
    "`self` — другой объект."
   ],
   "id": "text-19"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Два способа вызвать метод\n",
    "print(latte.label())\n",
    "print(Product.label(latte))  # то же самое: latte становится self"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "same-call"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 1. Строка для меню\n",
    "\n",
    "Допишите класс `Drink`: метод `label()` возвращает строку вида `\"Капучино — 220 ₽\"` — название, тире и цену\n",
    "со знаком рубля.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "`return f\"{self.name} — {self.price} ₽\"`.\n",
    "\n",
    "</details>"
   ],
   "id": "label-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "class Drink:\n",
    "    def __init__(self, name, price):\n",
    "        self.name = name\n",
    "        self.price = price\n",
    "\n",
    "    def label(self):\n",
    "        ...  # верните строку \"Название — цена ₽\""
   ],
   "execution_count": null,
   "outputs": [],
   "id": "label"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 1 — выполните после своего решения\n",
    "def test_label():\n",
    "    \"Drink(\\\"Капучино\\\", 220).label() = \\\"Капучино — 220 ₽\\\"\"\n",
    "    try:\n",
    "        got = Drink(\"Капучино\", 220).label()\n",
    "    except TypeError as e:\n",
    "        assert False, f\"label() не вызывается: {e}. Первым параметром метода должен быть self\"\n",
    "    assert got is not None, \"метод ничего не возвращает — нужен return, а не print\"\n",
    "    assert isinstance(got, str), f\"label() вернул {type(got).__name__}, а нужна строка\"\n",
    "    assert got == \"Капучино — 220 ₽\", f\"label() вернул {got!r}, а нужно \\\"Капучино — 220 ₽\\\"\"\n",
    "\n",
    "\n",
    "def test_other():\n",
    "    \"у другого экземпляра — своя строка\"\n",
    "    try:\n",
    "        got = Drink(\"Раф\", 260).label()\n",
    "    except TypeError:\n",
    "        assert False, \"label() не вызывается — первым параметром метода должен быть self\"\n",
    "    assert got == \"Раф — 260 ₽\", f\"Drink(\\\"Раф\\\", 260).label() вернул {got!r} — берите название и цену из self, а не пишите их в строке\"\n",
    "\n",
    "_check(test_label, test_other, names=[\"Drink.label\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "label-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "class Drink:\n",
    "    def __init__(self, name, price):\n",
    "        self.name = name\n",
    "        self.price = price\n",
    "\n",
    "    def label(self):\n",
    "        return f\"{self.name} — {self.price} ₽\"\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "label-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Метод меняет состояние\n",
    "\n",
    "Метод может не только вернуть результат, но и **изменить атрибуты** экземпляра. Набор значений атрибутов\n",
    "называют **состоянием** объекта: после вызова метода состояние уже другое."
   ],
   "id": "text-32"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Продажи круассанов\n",
    "class Pastry:\n",
    "    def __init__(self, name, left):\n",
    "        self.name = name\n",
    "        self.left = left\n",
    "\n",
    "    def sell(self, count):\n",
    "        self.left = self.left - count\n",
    "\n",
    "    def is_sold_out(self):\n",
    "        return self.left == 0\n",
    "\n",
    "\n",
    "croissant = Pastry(\"Круассан\", 5)\n",
    "croissant.sell(2)\n",
    "print(croissant.left, croissant.is_sold_out())\n",
    "croissant.sell(3)\n",
    "print(croissant.left, croissant.is_sold_out())"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "state"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 2. Кофемашина\n",
    "\n",
    "Допишите класс `CoffeeMachine`. У новой машины счётчик чашек `cups` равен 0. Метод `brew(count=1)` варит\n",
    "`count` чашек — увеличивает счётчик и ничего не возвращает. Метод `needs_cleaning()` возвращает `True`, если\n",
    "с момента создания машина сварила 50 чашек или больше, иначе `False`.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "В `brew`: `self.cups = self.cups + count`.\n",
    "\n",
    "</details>\n",
    "<details><summary>Подсказка 2</summary>\n",
    "\n",
    "`needs_cleaning` сравнивает `self.cups` с 50 и возвращает результат сравнения; ровно 50 чашек — уже пора чистить.\n",
    "\n",
    "</details>"
   ],
   "id": "machine-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "class CoffeeMachine:\n",
    "    def __init__(self):\n",
    "        ...\n",
    "\n",
    "    def brew(self, count=1):\n",
    "        ...\n",
    "\n",
    "    def needs_cleaning(self):\n",
    "        ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "machine"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 2 — выполните после своего решения\n",
    "def _machine():\n",
    "    try:\n",
    "        return CoffeeMachine()\n",
    "    except TypeError as e:\n",
    "        assert False, f\"CoffeeMachine() не создаётся: {e}. У __init__ только параметр self\"\n",
    "\n",
    "\n",
    "def test_new():\n",
    "    \"у новой машины cups = 0\"\n",
    "    m = _machine()\n",
    "    assert hasattr(m, \"cups\"), \"у новой машины нет атрибута cups — запишите в __init__ self.cups = 0\"\n",
    "    assert m.cups == 0, f\"у новой машины cups = {m.cups!r}, а нужно 0\"\n",
    "\n",
    "\n",
    "def test_brew():\n",
    "    \"brew() и brew(3) увеличивают счётчик\"\n",
    "    m = _machine()\n",
    "    assert hasattr(m, \"cups\"), \"сначала задайте cups в __init__\"\n",
    "    try:\n",
    "        result = m.brew()\n",
    "        m.brew(3)\n",
    "    except TypeError as e:\n",
    "        assert False, f\"brew не вызывается: {e}. Объявите def brew(self, count=1):\"\n",
    "    assert result is None, f\"brew() вернул {result!r}, а должен только изменить счётчик и ничего не возвращать\"\n",
    "    assert m.cups == 4, f\"после brew() и brew(3) cups = {m.cups!r}, а нужно 4 — прибавляйте count к self.cups\"\n",
    "\n",
    "\n",
    "def test_cleaning():\n",
    "    \"needs_cleaning() — True с 50 чашек\"\n",
    "    m = _machine()\n",
    "    assert hasattr(m, \"cups\"), \"сначала задайте cups в __init__\"\n",
    "    m.cups = 49\n",
    "    assert m.needs_cleaning() is False, \"при 49 чашках чистка ещё не нужна — needs_cleaning() должен вернуть False\"\n",
    "    m.cups = 50\n",
    "    assert m.needs_cleaning() is True, \"при 50 чашках needs_cleaning() должен вернуть True: сравнение >= 50\"\n",
    "\n",
    "_check(test_new, test_brew, test_cleaning, names=[\"CoffeeMachine.__init__\",\"CoffeeMachine.brew\",\"CoffeeMachine.needs_cleaning\"])"
   ],
   "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):\n",
    "        self.cups = 0\n",
    "\n",
    "    def brew(self, count=1):\n",
    "        self.cups = self.cups + count\n",
    "\n",
    "    def needs_cleaning(self):\n",
    "        return self.cups >= 50\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "machine-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Метод с параметрами\n",
    "\n",
    "Кроме `self`, у метода могут быть обычные параметры — и со значениями по умолчанию тоже. При вызове `self`\n",
    "не передаётся: его подставит Python."
   ],
   "id": "text-48"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 3. Счёт с чаевыми\n",
    "\n",
    "Допишите класс `Bill`: `Bill(500)` хранит сумму счёта в атрибуте `amount`. Метод `with_tip(percent=10)`\n",
    "возвращает сумму с чаевыми, округлённую до целых, и **не меняет** `amount`: `Bill(500).with_tip()` — 550,\n",
    "`Bill(480).with_tip(5)` — 504.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Как функция `with_tip` из первого урока, только сумма берётся из `self.amount`.\n",
    "\n",
    "</details>"
   ],
   "id": "bill-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "class Bill:\n",
    "    def __init__(self, amount):\n",
    "        self.amount = amount\n",
    "\n",
    "    def with_tip(self, percent=10):\n",
    "        ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "bill"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 3 — выполните после своего решения\n",
    "def test_default():\n",
    "    \"Bill(500).with_tip() = 550\"\n",
    "    try:\n",
    "        got = Bill(500).with_tip()\n",
    "    except TypeError:\n",
    "        assert False, \"with_tip() не вызывается без аргумента — дайте percent значение по умолчанию 10\"\n",
    "    assert got is not None, \"метод ничего не возвращает — нужен return\"\n",
    "    assert got == 550, f\"Bill(500).with_tip() = {got!r}, а нужно 550\"\n",
    "\n",
    "\n",
    "def test_percent():\n",
    "    \"Bill(480).with_tip(5) = 504, округление до целых\"\n",
    "    assert Bill(480).with_tip(5) == 504, f\"Bill(480).with_tip(5) = {Bill(480).with_tip(5)!r}, а нужно 504\"\n",
    "    got = Bill(333).with_tip(15)\n",
    "    assert got == 383, f\"Bill(333).with_tip(15) = {got!r}, а нужно 383 — округлите функцией round\"\n",
    "\n",
    "\n",
    "def test_unchanged():\n",
    "    \"amount не меняется\"\n",
    "    bill = Bill(500)\n",
    "    bill.with_tip()\n",
    "    assert bill.amount == 500, f\"после with_tip() amount = {bill.amount!r}: метод должен вернуть сумму с чаевыми, а не записать её в self.amount\"\n",
    "\n",
    "_check(test_default, test_percent, test_unchanged, names=[\"Bill.with_tip\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "bill-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "class Bill:\n",
    "    def __init__(self, amount):\n",
    "        self.amount = amount\n",
    "\n",
    "    def with_tip(self, percent=10):\n",
    "        return round(self.amount * (100 + percent) / 100)\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "bill-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Две частые ошибки\n",
    "\n",
    "Первая — забыть `self` в параметрах метода. Python всё равно передаст экземпляр первым аргументом, и ему\n",
    "некуда будет попасть:"
   ],
   "id": "text-61"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Метод без self\n",
    "# Эта ячейка показывает ошибку TypeError: она перехвачена, чтобы «Выполнить всё» не останавливалось.\n",
    "try:\n",
    "    class Cookie:\n",
    "        def __init__(self, name):\n",
    "            self.name = name\n",
    "\n",
    "        def label():  # забыли self\n",
    "            return \"печенье\"\n",
    "\n",
    "\n",
    "    Cookie(\"Овсяное\").label()\n",
    "except Exception as error:\n",
    "    print(f\"{type(error).__name__}: {error}\")"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "no-self"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Типичная ошибка: takes 0 positional arguments but 1 was given.**\n",
    ">\n",
    "> Метод объявлен без параметров, а вызван «с одним аргументом», хотя в скобках пусто. Этот аргумент —\n",
    "> экземпляр, который Python передаёт сам. Добавьте `self` первым параметром."
   ],
   "id": "component-69"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вторая — забыть скобки. `latte.label` без скобок — это сам метод, а не результат его вызова:"
   ],
   "id": "text-73"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Метод без скобок\n",
    "method = latte.label  # без скобок: сам метод, а не строка\n",
    "print(type(method).__name__)\n",
    "print(method())"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "no-parens"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Метод плюс строка\n",
    "# Эта ячейка показывает ошибку TypeError: она перехвачена, чтобы «Выполнить всё» не останавливалось.\n",
    "try:\n",
    "    latte.label + \"!\"\n",
    "except Exception as error:\n",
    "    print(f\"{type(error).__name__}: {error}\")"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "no-parens-error"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Типичная ошибка: метод без скобок.**\n",
    ">\n",
    "> Если в выводе или в ошибке видно `method` там, где ждали строку или число, — где-то пропущены скобки: `latte.label`\n",
    "> вместо `latte.label()`. Без скобок метод не вызывается."
   ],
   "id": "component-80"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Вопрос.** Что напечатает `print(type(latte.label()).__name__)`?\n",
    "\n",
    "- `str`\n",
    "- `method`\n",
    "- `Product`\n",
    "\n",
    "<details><summary>Ответ</summary>\n",
    "\n",
    "`str`\n",
    "\n",
    "Со скобками метод вызывается, и `type` получает его результат — строку. Без скобок было бы `method`.\n",
    "\n",
    "</details>"
   ],
   "id": "quiz-85"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 4. Всё меню строками\n",
    "\n",
    "В `menu` — три экземпляра `Drink` из первого упражнения. Сохраните в `labels` список их строк для меню —\n",
    "результатов метода `label()`, по порядку.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Генератор списка: `[d.label() for d in menu]` — со скобками.\n",
    "\n",
    "</details>"
   ],
   "id": "labels-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "menu = [Drink(\"Эспрессо\", 150), Drink(\"Капучино\", 220), Drink(\"Раф\", 260)]\n",
    "labels = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "labels"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 4 — выполните после своего решения\n",
    "def test_labels():\n",
    "    \"labels — строки меню по порядку\"\n",
    "    assert isinstance(labels, list), f\"labels — это {type(labels).__name__}, а нужен список\"\n",
    "    assert len(labels) == 3, f\"в labels {len(labels)} элементов, а напитков 3\"\n",
    "    assert all(isinstance(x, str) for x in labels), \"в labels не строки, а сами методы — вызовите метод со скобками: d.label()\"\n",
    "    assert labels == [\"Эспрессо — 150 ₽\", \"Капучино — 220 ₽\", \"Раф — 260 ₽\"], f\"в labels {labels}\"\n",
    "\n",
    "_check(test_labels, names=[\"labels\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "labels-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "menu = [Drink(\"Эспрессо\", 150), Drink(\"Капучино\", 220), Drink(\"Раф\", 260)]\n",
    "labels = [d.label() for d in menu]\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "labels-solution"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python"
  },
  "colab": {
   "provenance": []
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}