{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Операторы: __add__ и компания\n",
    "\n",
    "Перегрузка операторов: __add__ и __mul__ задают + и * для своего класса, __radd__ и __rmul__ — операции, где ваш объект справа (и sum). Неизменяемые объекты: оператор возвращает новый объект.\n",
    "\n",
    "Курс ООП в Python · урок `oop-operators` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/oop/operators).\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": [
    "Деньги удобно складывать плюсом: `Money(220) + Money(140)`. Чтобы так можно было писать со своим классом,\n",
    "операторы тоже задают магическими методами. Это называется **перегрузка операторов** (operator\n",
    "overloading) — у оператора появляется смысл для нового типа.\n",
    "\n",
    "## `__add__`: плюс\n",
    "\n",
    "`a + b` вызывает `a.__add__(b)`. Метод возвращает **новый** объект — результат сложения. Если тип второго\n",
    "слагаемого чужой, метод, как и `__eq__`, возвращает `NotImplemented`:"
   ],
   "id": "text-9"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Вес плюс вес\n",
    "class Weight:\n",
    "    def __init__(self, grams):\n",
    "        self.grams = grams\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f\"Weight({self.grams})\"\n",
    "\n",
    "    def __add__(self, other):\n",
    "        if not isinstance(other, Weight):\n",
    "            return NotImplemented\n",
    "        return Weight(self.grams + other.grams)  # новый объект\n",
    "\n",
    "\n",
    "a = Weight(250)\n",
    "b = Weight(100)\n",
    "print(a + b, a, b)\n",
    "print(a + b + Weight(50))"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "add"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Типичная ошибка: оператор меняет объект слева.**\n",
    ">\n",
    "> `a + b` не должен менять `a`: никто не ждёт, что после `total = price + delivery` изменится `price`. Метод\n",
    "> `__add__` создаёт и возвращает новый объект, а `self` и `other` оставляет как есть. Объекты-значения вроде\n",
    "> денег и веса лучше вообще делать **неизменяемыми** — менять их только созданием нового объекта. По-настоящему\n",
    "> неизменяемыми их сделает `frozen=True` из модуля 8; а пока договоримся не менять атрибуты таких объектов снаружи."
   ],
   "id": "component-21"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Плюс, который портит слагаемое\n",
    "class BadWeight:\n",
    "    def __init__(self, grams):\n",
    "        self.grams = grams\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f\"BadWeight({self.grams})\"\n",
    "\n",
    "    def __add__(self, other):\n",
    "        self.grams += other.grams  # ошибка: меняет левое слагаемое\n",
    "        return self\n",
    "\n",
    "\n",
    "bag = BadWeight(250)\n",
    "total = bag + BadWeight(100)\n",
    "print(total, bag, total is bag)"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "mutating"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `__radd__`: когда ваш объект справа\n",
    "\n",
    "`sum(список)` начинает с нуля: `0 + первый + второй…`. Первое сложение — `0 + Weight(…)`: у числа 0 нет\n",
    "сложения с весом, его `__add__` возвращает `NotImplemented`. Тогда Python пробует **отражённый** метод\n",
    "второго объекта: `Weight(…).__radd__(0)` (r — от reflected). Если и его нет — `TypeError`:"
   ],
   "id": "text-29"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# sum не умеет складывать вес\n",
    "# Эта ячейка показывает ошибку TypeError: она перехвачена, чтобы «Выполнить всё» не останавливалось.\n",
    "try:\n",
    "    sum([Weight(250), Weight(100)])\n",
    "except Exception as error:\n",
    "    print(f\"{type(error).__name__}: {error}\")"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "sum-error"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Обычно `__radd__` для `sum` устроен так: ноль слева — вернуть себя, иначе — то же, что `__add__`."
   ],
   "id": "text-37"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 1. Деньги складываются\n",
    "\n",
    "Допишите класс `Money`: `Money(220) + Money(140)` — это `Money(360)`, слагаемые не меняются. Сложение\n",
    "с чужим типом — `NotImplemented`. Добавьте `__radd__`, чтобы `sum([Money(220), Money(140)])` давал\n",
    "`Money(360)`.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "`__add__` устроен как у `Weight`; результат — новый `Money` с суммой рублей.\n",
    "\n",
    "</details>\n",
    "<details><summary>Подсказка 2</summary>\n",
    "\n",
    "`__radd__` повторяет правило из абзаца выше: ноль слева — вернуть `self`, иначе — то же, что `__add__`.\n",
    "\n",
    "</details>"
   ],
   "id": "money-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "class Money:\n",
    "    def __init__(self, rubles):\n",
    "        self.rubles = rubles\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f\"Money({self.rubles})\"\n",
    "\n",
    "    def __eq__(self, other):\n",
    "        if not isinstance(other, Money):\n",
    "            return NotImplemented\n",
    "        return self.rubles == other.rubles\n",
    "\n",
    "    def __add__(self, other):\n",
    "        ...\n",
    "\n",
    "    def __radd__(self, other):\n",
    "        ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "money"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 1 — выполните после своего решения\n",
    "def test_add():\n",
    "    \"Money + Money — новый Money\"\n",
    "    a, b = Money(220), Money(140)\n",
    "    got = a + b\n",
    "    assert isinstance(got, Money), f\"Money(220) + Money(140) дал {got!r}, а нужен экземпляр Money\"\n",
    "    assert got == Money(360), f\"Money(220) + Money(140) = {got!r}, а нужно Money(360)\"\n",
    "    assert a.rubles == 220 and b.rubles == 140, \"сложение изменило слагаемые — создавайте новый Money, а не меняйте self\"\n",
    "    assert got is not a, \"сложение вернуло левое слагаемое — нужен новый объект\"\n",
    "\n",
    "\n",
    "def test_foreign():\n",
    "    \"чужой тип — NotImplemented\"\n",
    "    try:\n",
    "        got = Money.__dict__[\"__add__\"](Money(220), 5)\n",
    "    except AttributeError:\n",
    "        assert False, \"сложение с числом падает — сначала проверьте тип: isinstance(other, Money)\"\n",
    "    except TypeError:\n",
    "        assert False, \"для чужого типа __add__ выбросил TypeError, а должен вернуть NotImplemented — TypeError Python выбросит сам, если и второй объект не умеет\"\n",
    "    assert got is NotImplemented, f\"Money.__add__ с числом вернул {got!r}, а нужно NotImplemented\"\n",
    "\n",
    "\n",
    "def test_sum():\n",
    "    \"sum работает\"\n",
    "    try:\n",
    "        got = sum([Money(220), Money(140), Money(90)])\n",
    "    except TypeError as e:\n",
    "        assert False, f\"sum по списку Money падает: {e}. Нужен __radd__: 0 + Money — вернуть self\"\n",
    "    assert got == Money(450), f\"sum = {got!r}, а нужно Money(450)\"\n",
    "\n",
    "_check(test_add, test_foreign, test_sum, names=[\"Money.__add__\",\"Money.__radd__\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "money-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "class Money:\n",
    "    def __init__(self, rubles):\n",
    "        self.rubles = rubles\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f\"Money({self.rubles})\"\n",
    "\n",
    "    def __eq__(self, other):\n",
    "        if not isinstance(other, Money):\n",
    "            return NotImplemented\n",
    "        return self.rubles == other.rubles\n",
    "\n",
    "    def __add__(self, other):\n",
    "        if not isinstance(other, Money):\n",
    "            return NotImplemented\n",
    "        return Money(self.rubles + other.rubles)\n",
    "\n",
    "    def __radd__(self, other):\n",
    "        if other == 0:\n",
    "            return self\n",
    "        return self.__add__(other)\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "money-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `__mul__` и `__rmul__`: умножение на число\n",
    "\n",
    "`a * 3` вызывает `a.__mul__(3)`, а `3 * a` — сначала `int.__mul__`, который не умеет, а потом `a.__rmul__(3)`.\n",
    "Для коммутативного умножения на число `__rmul__` обычно просто вызывает `__mul__`:"
   ],
   "id": "text-48"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 2. Граммы на порцию\n",
    "\n",
    "Допишите класс `Grams` (вес в граммах, атрибут `value`): `Grams(18) * 3` и `3 * Grams(18)` — это `Grams(54)`.\n",
    "Умножать можно только на целое число (`int`); на что-то другое — `NotImplemented`.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Проверка типа — как в `__add__`, но множитель сравнивайте с `int`, а не с `Grams`.\n",
    "\n",
    "</details>\n",
    "<details><summary>Подсказка 2</summary>\n",
    "\n",
    "`__rmul__` может просто вызвать `self.__mul__(number)`.\n",
    "\n",
    "</details>"
   ],
   "id": "grams-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "class Grams:\n",
    "    def __init__(self, value):\n",
    "        self.value = value\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f\"Grams({self.value})\"\n",
    "\n",
    "    def __eq__(self, other):\n",
    "        if not isinstance(other, Grams):\n",
    "            return NotImplemented\n",
    "        return self.value == other.value\n",
    "\n",
    "    def __mul__(self, number):\n",
    "        ...\n",
    "\n",
    "    def __rmul__(self, number):\n",
    "        ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "grams"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 2 — выполните после своего решения\n",
    "def test_mul():\n",
    "    \"Grams(18) * 3\"\n",
    "    portion = Grams(18)\n",
    "    try:\n",
    "        got = portion * 3\n",
    "    except TypeError:\n",
    "        assert False, \"Grams(18) * 3 не работает: __mul__ вернул NotImplemented для 3 — проверяйте, что множитель — int, а не Grams\"\n",
    "    assert got == Grams(54), f\"Grams(18) * 3 = {got!r}, а нужно Grams(54)\"\n",
    "    assert portion.value == 18, \"умножение изменило исходный вес — возвращайте новый Grams\"\n",
    "\n",
    "\n",
    "def test_rmul():\n",
    "    \"3 * Grams(18)\"\n",
    "    try:\n",
    "        got = 3 * Grams(18)\n",
    "    except TypeError as e:\n",
    "        assert False, f\"3 * Grams(18) падает: {e}. Нужен __rmul__\"\n",
    "    assert got == Grams(54), f\"3 * Grams(18) = {got!r}, а нужно Grams(54)\"\n",
    "\n",
    "\n",
    "def test_foreign():\n",
    "    \"не int — NotImplemented\"\n",
    "    got = Grams.__dict__[\"__mul__\"](Grams(18), \"3\")\n",
    "    assert got is NotImplemented, f\"Grams(18) * \\\"3\\\" вернул {got!r}, а для не-int нужно NotImplemented\"\n",
    "\n",
    "_check(test_mul, test_rmul, test_foreign, names=[\"Grams.__mul__\",\"Grams.__rmul__\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "grams-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "class Grams:\n",
    "    def __init__(self, value):\n",
    "        self.value = value\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f\"Grams({self.value})\"\n",
    "\n",
    "    def __eq__(self, other):\n",
    "        if not isinstance(other, Grams):\n",
    "            return NotImplemented\n",
    "        return self.value == other.value\n",
    "\n",
    "    def __mul__(self, number):\n",
    "        if not isinstance(number, int):\n",
    "            return NotImplemented\n",
    "        return Grams(self.value * number)\n",
    "\n",
    "    def __rmul__(self, number):\n",
    "        return self.__mul__(number)\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "grams-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Вопрос.** У класса есть только `__mul__`, а `__rmul__` нет. Что даст `3 * Grams(18)`?\n",
    "\n",
    "- `Grams(54)` — Python сам переставит множители\n",
    "- `TypeError`\n",
    "- `54`\n",
    "\n",
    "<details><summary>Ответ</summary>\n",
    "\n",
    "`TypeError`\n",
    "\n",
    "`3 * Grams(18)` сначала спрашивает `int.__mul__`, он отвечает `NotImplemented`. Потом Python ищет `Grams.__rmul__` — а его нет. Переставлять множители сам Python не будет: для своих типов он не знает, коммутативно ли умножение.\n",
    "\n",
    "</details>"
   ],
   "id": "quiz-62"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Операторы в деле\n",
    "\n",
    "С операторами код кассы читается как формула:"
   ],
   "id": "text-71"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 3. Расход за смену\n",
    "\n",
    "Сохраните в `revenue` сумму всех чеков из `checks` — одним вызовом `sum`, а в `beans` — сколько зёрен уйдёт\n",
    "на `cups` чашек, если на чашку нужно `Grams(18)`.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Для выручки хватит одного вызова встроенной функции — благодаря `__radd__`; для зёрен — одного умножения.\n",
    "\n",
    "</details>"
   ],
   "id": "shift-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "checks = [Money(640), Money(1250), Money(380), Money(910)]\n",
    "cups = 120\n",
    "revenue = ...\n",
    "beans = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "shift"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 3 — выполните после своего решения\n",
    "def test_revenue():\n",
    "    \"revenue — Money с суммой чеков\"\n",
    "    assert isinstance(revenue, Money), f\"revenue — это {type(revenue).__name__}, а нужен Money: sum(checks)\"\n",
    "    assert revenue == Money(3180), f\"revenue = {revenue!r}, а сумма чеков — Money(3180)\"\n",
    "\n",
    "\n",
    "def test_beans():\n",
    "    \"beans — Grams на все чашки\"\n",
    "    assert isinstance(beans, Grams), f\"beans — это {type(beans).__name__}, а нужен Grams: Grams(18) * cups\"\n",
    "    assert beans == Grams(2160), f\"beans = {beans!r}, а на 120 чашек нужно Grams(2160)\"\n",
    "\n",
    "_check(test_revenue, test_beans, names=[\"revenue\",\"beans\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "shift-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "checks = [Money(640), Money(1250), Money(380), Money(910)]\n",
    "cups = 120\n",
    "revenue = sum(checks)\n",
    "beans = Grams(18) * cups\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "shift-solution"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python"
  },
  "colab": {
   "provenance": []
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}