{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Как объект выглядит: __repr__ и __str__\n",
    "\n",
    "Магические методы — способ встроить свой класс в язык. __repr__ — представление для отладки, __str__ — для людей, repr() и !r в f-строках.\n",
    "\n",
    "Курс ООП в Python · урок `oop-repr` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/oop/repr).\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": [
    "До сих пор экземпляры своих классов мы не печатали — только их атрибуты. И не зря: без подготовки Python\n",
    "печатает экземпляр так:\n",
    "\n",
    "```text\n",
    ">>> latte = Product(\"Латте\", 220)\n",
    ">>> latte\n",
    "<__main__.Product object at 0x10a3f2b50>\n",
    "```\n",
    "\n",
    "Имя класса и адрес объекта в памяти — для отладки почти бесполезно, а адрес к тому же меняется при каждом\n",
    "запуске. Научим класс выглядеть понятно.\n",
    "\n",
    "## Магические методы\n",
    "\n",
    "`__init__` — не единственный метод с двумя подчёркиваниями. Таких методов десятки, и все они устроены\n",
    "одинаково: **Python вызывает их сам**, когда с объектом делают что-то встроенное. `len(x)` вызывает\n",
    "`x.__len__()`, `print(x)` — `x.__str__()`, а `__init__` — создание экземпляра. Их называют **магическими\n",
    "методами** (special methods; их ещё называют dunder — от double underscore). Объявите такой метод в своём\n",
    "классе — и встроенная операция заработает с вашими объектами."
   ],
   "id": "text-9"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# len — это вызов __len__\n",
    "word = \"латте\"\n",
    "print(len(word))\n",
    "print(word.__len__())  # это и делает len"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "dunder"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `__repr__`: представление для отладки\n",
    "\n",
    "Метод `__repr__` возвращает **строковое представление** (representation) объекта для программиста. Его\n",
    "показывает Jupyter для значения последней строки ячейки, его используют списки и словари, когда печатают\n",
    "свои элементы, и его возвращает встроенная функция `repr()`. Хорошее представление однозначно и, по\n",
    "возможности, похоже на код, который создаёт такой же объект:"
   ],
   "id": "text-31"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Product с __repr__\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(name={self.name!r}, price={self.price})\"\n",
    "\n",
    "\n",
    "latte = Product(\"Латте\", 220)\n",
    "print(repr(latte))\n",
    "print([latte, Product(\"Чай\", 120)])\n",
    "latte  # значение последней строки ячейки показывается через repr"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "repr"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Обратите внимание на `!r` в f-строке: `{self.name!r}` вставляет не саму строку, а её `repr` — с кавычками.\n",
    "Без них `Product(Латте, 220)` уже не похоже на код."
   ],
   "id": "text-40"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 1. Представление напитка\n",
    "\n",
    "Допишите класс `Drink`: метод `__repr__` возвращает строку вида `Drink('Латте', 220)` — имя класса, название\n",
    "в кавычках и цену.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Чтобы название попало в строку с кавычками, вспомните `!r` из демонстрации.\n",
    "\n",
    "</details>\n",
    "<details><summary>Подсказка 2</summary>\n",
    "\n",
    "Представление собирается f-строкой: `f\"Drink(…, …)\"` с `self.name!r` и `self.price` внутри.\n",
    "\n",
    "</details>"
   ],
   "id": "drink-repr-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 __repr__(self):\n",
    "        ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "drink-repr"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 1 — выполните после своего решения\n",
    "def test_repr():\n",
    "    \"repr(Drink(\\\"Латте\\\", 220)) = Drink('Латте', 220)\"\n",
    "    assert \"__repr__\" in Drink.__dict__, \"в классе нет метода __repr__ — объявите его\"\n",
    "    got = Drink.__dict__[\"__repr__\"](Drink(\"Латте\", 220))\n",
    "    assert isinstance(got, str), f\"__repr__ вернул {type(got).__name__}, а должен вернуть строку\"\n",
    "    assert got != \"Drink(Латте, 220)\", \"название без кавычек — вставьте его с !r: {self.name!r}\"\n",
    "    assert got == \"Drink('Латте', 220)\", f\"repr = {got!r}, а нужно \\\"Drink('Латте', 220)\\\"\"\n",
    "\n",
    "\n",
    "def test_other():\n",
    "    \"repr другого напитка и списка\"\n",
    "    assert \"__repr__\" in Drink.__dict__, \"сначала объявите __repr__\"\n",
    "    got = repr([Drink(\"Раф\", 260), Drink(\"Чай\", 120)])\n",
    "    assert got == \"[Drink('Раф', 260), Drink('Чай', 120)]\", f\"repr списка напитков: {got} — берите значения из self\"\n",
    "\n",
    "_check(test_repr, test_other, names=[\"Drink.__repr__\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "drink-repr-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 __repr__(self):\n",
    "        return f\"Drink({self.name!r}, {self.price})\"\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "drink-repr-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `__str__`: для людей\n",
    "\n",
    "Метод `__str__` возвращает текст **для людей** — для `print`, `str()` и f-строк. Он не обязан быть похож на\n",
    "код. Если `__str__` в классе нет, Python использует `__repr__`:"
   ],
   "id": "text-51"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# print, str() и значение в ячейке\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(name={self.name!r}, price={self.price})\"\n",
    "\n",
    "    def __str__(self):\n",
    "        return f\"{self.name} за {self.price} ₽\"\n",
    "\n",
    "\n",
    "latte = Product(\"Латте\", 220)\n",
    "print(latte)\n",
    "print(str(latte), \"|\", repr(latte))\n",
    "print(f\"Сегодня советуем: {latte}\")\n",
    "latte"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "str"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 2. Заказ для журнала и для кассы\n",
    "\n",
    "Допишите класс `Order`: `__repr__` возвращает `Order(17, 640)` — номер и сумму, а `__str__` — текст для\n",
    "кассира: `Заказ №17 на 640 ₽`.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "`__repr__` похож на код создания заказа, `__str__` — на фразу для кассира; оба собирают строку из `self.number` и `self.total`.\n",
    "\n",
    "</details>\n",
    "<details><summary>Подсказка 2</summary>\n",
    "\n",
    "`return f\"Заказ №{self.number} на {self.total} ₽\"` — это `__str__`.\n",
    "\n",
    "</details>"
   ],
   "id": "order-str-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "class Order:\n",
    "    def __init__(self, number, total):\n",
    "        self.number = number\n",
    "        self.total = total\n",
    "\n",
    "    def __repr__(self):\n",
    "        ...\n",
    "\n",
    "    def __str__(self):\n",
    "        ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "order-str"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 2 — выполните после своего решения\n",
    "def test_repr():\n",
    "    \"repr — Order(17, 640)\"\n",
    "    assert \"__repr__\" in Order.__dict__, \"в классе нет __repr__ — объявите его\"\n",
    "    got = Order.__dict__[\"__repr__\"](Order(17, 640))\n",
    "    assert got == \"Order(17, 640)\", f\"repr заказа = {got!r}, а нужно \\\"Order(17, 640)\\\"\"\n",
    "\n",
    "\n",
    "def test_str():\n",
    "    \"str — Заказ №17 на 640 ₽\"\n",
    "    assert \"__str__\" in Order.__dict__, \"в классе нет __str__ — объявите его\"\n",
    "    got = Order.__dict__[\"__str__\"](Order(17, 640))\n",
    "    assert got != \"Order(17, 640)\", \"__str__ вернул то же, что __repr__, а нужен текст для кассира\"\n",
    "    assert got == \"Заказ №17 на 640 ₽\", f\"str заказа = {got!r}, а нужно \\\"Заказ №17 на 640 ₽\\\"\"\n",
    "    assert str(Order(3, 150)) == \"Заказ №3 на 150 ₽\", \"у Order(3, 150) str должен быть \\\"Заказ №3 на 150 ₽\\\" — берите значения из self\"\n",
    "\n",
    "_check(test_repr, test_str, names=[\"Order.__repr__\",\"Order.__str__\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "order-str-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "class Order:\n",
    "    def __init__(self, number, total):\n",
    "        self.number = number\n",
    "        self.total = total\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f\"Order({self.number}, {self.total})\"\n",
    "\n",
    "    def __str__(self):\n",
    "        return f\"Заказ №{self.number} на {self.total} ₽\"\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "order-str-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Вопрос.** У класса `Order` из упражнения есть и `__str__`, и `__repr__`. Что напечатает `print([Order(17, 640)])`?\n",
    "\n",
    "- `[Заказ №17 на 640 ₽]`\n",
    "- `[Order(17, 640)]`\n",
    "- `[<__main__.Order object at 0x…>]`\n",
    "\n",
    "<details><summary>Ответ</summary>\n",
    "\n",
    "`[Order(17, 640)]`\n",
    "\n",
    "`print` вызывает `__str__` у самого списка, а список собирает свой текст из `repr` элементов. Поэтому внутри списка, словаря и кортежа всегда видно представление для отладки.\n",
    "\n",
    "</details>"
   ],
   "id": "quiz-67"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## repr и str в f-строках\n",
    "\n",
    "В f-строке `{x}` даёт `str(x)`, а `{x!r}` — `repr(x)`. Первое — для сообщений людям, второе — для журналов\n",
    "и сообщений об ошибках, где важно точно видеть значение:"
   ],
   "id": "text-76"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 3. Два сообщения\n",
    "\n",
    "Для заказа `order` составьте две строки: `message` — `\"Готов: Заказ №17 на 640 ₽\"` для экрана выдачи (через\n",
    "`__str__`) и `log` — `\"создан Order(17, 640)\"` для журнала (через `__repr__`). Используйте f-строки с самим\n",
    "объектом, без обращения к его атрибутам.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "`{order}` в f-строке вызывает `__str__`, а что вызовет `__repr__` — сказано в абзаце выше.\n",
    "\n",
    "</details>\n",
    "<details><summary>Подсказка 2</summary>\n",
    "\n",
    "`f\"создан {order!r}\"`.\n",
    "\n",
    "</details>"
   ],
   "id": "log-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "order = Order(17, 640)\n",
    "message = ...\n",
    "log = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "log"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 3 — выполните после своего решения\n",
    "def test_message():\n",
    "    \"message — через __str__\"\n",
    "    assert message == \"Готов: Заказ №17 на 640 ₽\", f\"message = {message!r}, а нужно \\\"Готов: Заказ №17 на 640 ₽\\\": {{order}} в f-строке\"\n",
    "\n",
    "\n",
    "def test_log():\n",
    "    \"log — через __repr__\"\n",
    "    assert log != \"создан Заказ №17 на 640 ₽\", \"в log попал текст __str__ — для repr добавьте !r: {order!r}\"\n",
    "    assert log == \"создан Order(17, 640)\", f\"log = {log!r}, а нужно \\\"создан Order(17, 640)\\\"\"\n",
    "\n",
    "_check(test_message, test_log, names=[\"message\",\"log\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "log-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "order = Order(17, 640)\n",
    "message = f\"Готов: {order}\"\n",
    "log = f\"создан {order!r}\"\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "log-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Правило на будущее: **у каждого своего класса должен быть `__repr__`** — отладка без него мучительна.\n",
    "`__str__` — когда объекту нужен отдельный «человеческий» вид."
   ],
   "id": "text-90"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python"
  },
  "colab": {
   "provenance": []
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}