{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# dataclasses\n", "\n", "Декоратор @dataclass пишет __init__, __repr__ и __eq__ за вас по списку полей с аннотациями. Значения по умолчанию и field(default_factory=list) для списков.\n", "\n", "Курс ООП в Python · урок `oop-dataclass` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/oop/dataclass).\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": [ "Посмотрите на классы из прошлых модулей: `Product`, `Money`, `Customer`. В каждом — одинаковый `__init__`,\n", "который переписывает параметры в атрибуты, `__repr__`, который их перечисляет, и `__eq__`, который их\n", "сравнивает. Это много однообразного кода, в котором легко ошибиться: добавили атрибут — и забыли его в\n", "`__eq__`. Для таких **классов данных** (data class) в стандартной библиотеке есть модуль `dataclasses`.\n", "\n", "## `@dataclass`\n", "\n", "Декоратор `@dataclass` читает список **полей** (field) класса и сам пишет `__init__`, `__repr__` и `__eq__`.\n", "Поле объявляется в теле класса строкой `имя: тип` — это **аннотация типа** (type annotation): подсказка,\n", "какого типа значение ожидается." ], "id": "text-9" }, { "cell_type": "code", "metadata": {}, "source": [ "# Product на dataclass\n", "from dataclasses import dataclass\n", "\n", "\n", "@dataclass\n", "class Product:\n", " name: str\n", " price: int\n", "\n", "\n", "latte = Product(\"Латте\", 220)\n", "print(latte)\n", "print(latte == Product(\"Латте\", 220), latte == Product(\"Латте\", 250))\n", "print(latte.name, latte.price)" ], "execution_count": null, "outputs": [], "id": "dataclass" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Три строки полей заменили собой три метода. `__repr__` перечисляет поля с именами, `__eq__` сравнивает все\n", "поля по порядку." ], "id": "text-22" }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Аннотации не проверяются.** Python не проверяет аннотации при выполнении: `Product(\"Латте\", \"220\")` создастся, и в `price` окажется строка.\n", "> Аннотации читают люди, редакторы кода и отдельные программы-проверщики, а `@dataclass` — только чтобы узнать\n", "> список полей. До этого урока курс обходился без аннотаций; дальше поля dataclass пишутся только с ними." ], "id": "component-26" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 1. Напиток-dataclass\n", "\n", "Объявите dataclass `Drink` с полями `name` (строка), `price` (целое) и `volume` (целое). Свой `__init__` не\n", "пишите — его создаст декоратор.\n", "\n", "
Подсказка 1\n", "\n", "Декоратор — над классом, поля — строками «имя: тип» в теле класса, как в демонстрации.\n", "\n", "
" ], "id": "drink-task" }, { "cell_type": "code", "metadata": {}, "source": [ "from dataclasses import dataclass\n", "\n", "\n", "class Drink:\n", " ..." ], "execution_count": null, "outputs": [], "id": "drink" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 1 — выполните после своего решения\n", "from dataclasses import fields, is_dataclass\n", "\n", "\n", "def test_is_dataclass():\n", " \"Drink — dataclass с тремя полями\"\n", " assert is_dataclass(Drink), \"Drink — не dataclass: поставьте над классом @dataclass\"\n", " names = [f.name for f in fields(Drink)]\n", " assert names == [\"name\", \"price\", \"volume\"], f\"поля Drink: {names}, а нужны name, price, volume — по порядку\"\n", "\n", "\n", "def test_generated():\n", " \"__init__, __repr__ и __eq__ от декоратора\"\n", " assert is_dataclass(Drink), \"сначала сделайте Drink dataclass'ом\"\n", " assert [f.name for f in fields(Drink)] == [\"name\", \"price\", \"volume\"], \"сначала объявите три поля (проверка выше)\"\n", " latte = Drink(\"Латте\", 220, 300)\n", " assert repr(latte) == \"Drink(name='Латте', price=220, volume=300)\", f\"repr = {latte!r}\"\n", " assert latte == Drink(\"Латте\", 220, 300), \"два одинаковых напитка должны быть равны — __eq__ сравнивает поля\"\n", " assert latte != Drink(\"Латте\", 220, 400), \"напитки с разным объёмом не равны\"\n", "\n", "_check(test_is_dataclass, test_generated)" ], "execution_count": null, "outputs": [], "id": "drink-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "from dataclasses import dataclass\n", "\n", "\n", "@dataclass\n", "class Drink:\n", " name: str\n", " price: int\n", " volume: int\n", "```\n", "\n", "
" ], "id": "drink-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Значения по умолчанию\n", "\n", "Значение по умолчанию задают прямо в поле: `volume: int = 250`. Поля со значением по умолчанию идут **после**\n", "полей без него — как параметры функции:" ], "id": "text-38" }, { "cell_type": "code", "metadata": {}, "source": [ "# Объём по умолчанию\n", "@dataclass\n", "class Cup:\n", " name: str\n", " volume: int = 250\n", "\n", "\n", "print(Cup(\"Капучино\"), Cup(\"Капучино\", 400))" ], "execution_count": null, "outputs": [], "id": "defaults" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Методы и свойства в dataclass объявляются как обычно — декоратор их не трогает:" ], "id": "text-45" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 2. Строка заказа\n", "\n", "Объявите dataclass `OrderLine` с полями `product` (строка), `price` (целое) и `qty` (целое, по умолчанию 1)\n", "и свойством `cost` — стоимость строки, цена на количество.\n", "\n", "
Подсказка 1\n", "\n", "Поле со значением по умолчанию идёт последним; свойство объявляется как в обычном классе.\n", "\n", "
" ], "id": "line-task" }, { "cell_type": "code", "metadata": {}, "source": [ "class OrderLine:\n", " ..." ], "execution_count": null, "outputs": [], "id": "line" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 2 — выполните после своего решения\n", "from dataclasses import fields, is_dataclass\n", "\n", "\n", "def test_fields():\n", " \"поля и значение по умолчанию\"\n", " assert is_dataclass(OrderLine), \"OrderLine — не dataclass: поставьте над классом @dataclass\"\n", " assert [f.name for f in fields(OrderLine)] == [\"product\", \"price\", \"qty\"], f\"поля: {[f.name for f in fields(OrderLine)]}\"\n", " try:\n", " line = OrderLine(\"Латте\", 220)\n", " except TypeError:\n", " assert False, \"OrderLine(\\\"Латте\\\", 220) не создаётся — у qty должно быть значение по умолчанию 1\"\n", " assert line.qty == 1, f\"qty по умолчанию = {line.qty!r}, а нужно 1\"\n", "\n", "\n", "def test_cost():\n", " \"cost — свойство\"\n", " assert isinstance(OrderLine.__dict__.get(\"cost\"), property), \"cost должен быть свойством — с @property\"\n", " assert OrderLine(\"Латте\", 220, 3).cost == 660, \"у трёх латте по 220 ₽ cost — 660\"\n", "\n", "_check(test_fields, test_cost)" ], "execution_count": null, "outputs": [], "id": "line-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "@dataclass\n", "class OrderLine:\n", " product: str\n", " price: int\n", " qty: int = 1\n", "\n", " @property\n", " def cost(self):\n", " return self.price * self.qty\n", "```\n", "\n", "
" ], "id": "line-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Списки в полях: `default_factory`\n", "\n", "Помните изменяемое значение по умолчанию из модуля 2? dataclass не даёт на него наступить — поле\n", "`items: list = []` вызывает ошибку сразу при объявлении класса:" ], "id": "text-54" }, { "cell_type": "code", "metadata": {}, "source": [ "# Список по умолчанию запрещён\n", "# Эта ячейка показывает ошибку ValueError: она перехвачена, чтобы «Выполнить всё» не останавливалось.\n", "try:\n", " @dataclass\n", " class Basket:\n", " customer: str\n", " items: list = []\n", "except Exception as error:\n", " print(f\"{type(error).__name__}: {error}\")" ], "execution_count": null, "outputs": [], "id": "mutable" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Нужно сказать, **как создавать** значение для каждого нового экземпляра: `field(default_factory=list)` —\n", "вызвать `list()` и получить новый пустой список. `field` импортируют из того же модуля:" ], "id": "text-61" }, { "cell_type": "code", "metadata": {}, "source": [ "# Свой список у каждой корзины\n", "from dataclasses import dataclass, field\n", "\n", "\n", "@dataclass\n", "class Basket:\n", " customer: str\n", " items: list = field(default_factory=list)\n", "\n", "\n", "anna, boris = Basket(\"Анна\"), Basket(\"Борис\")\n", "anna.items.append(\"Латте\")\n", "print(anna)\n", "print(boris)" ], "execution_count": null, "outputs": [], "id": "factory" }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Типичная ошибка: список по умолчанию в dataclass.**\n", ">\n", "> Ошибка `mutable default for field items is not allowed: use default_factory` — защита от общего\n", "> списка на все экземпляры. Пишите `items: list = field(default_factory=list)`; для словаря —\n", "> `field(default_factory=dict)`." ], "id": "component-67" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 3. Покупатель с историей\n", "\n", "Перепишите класс `Customer` из заготовки на dataclass: поля `name`, `phone`, `points` (по умолчанию 0) и\n", "`visits` — список дат визитов, у каждого покупателя свой, по умолчанию пустой. Метод `visit(date)` добавляет\n", "дату в `visits` и начисляет 10 баллов — его перенесите без изменений.\n", "\n", "
Подсказка 1\n", "\n", "Над классом `@dataclass`; `__init__`, `__repr__` и `__eq__` из заготовки удалите — их напишет декоратор.\n", "\n", "
\n", "
Подсказка 2\n", "\n", "Список по умолчанию — через `field(default_factory=…)`.\n", "\n", "
" ], "id": "customer-task" }, { "cell_type": "code", "metadata": {}, "source": [ "class Customer:\n", " def __init__(self, name, phone, points=0, visits=None):\n", " self.name = name\n", " self.phone = phone\n", " self.points = points\n", " self.visits = [] if visits is None else visits\n", "\n", " def __repr__(self):\n", " return f\"Customer(name={self.name!r}, phone={self.phone!r}, points={self.points!r}, visits={self.visits!r})\"\n", "\n", " def __eq__(self, other):\n", " if not isinstance(other, Customer):\n", " return NotImplemented\n", " return (self.name, self.phone, self.points, self.visits) == (other.name, other.phone, other.points, other.visits)\n", "\n", " def visit(self, date):\n", " self.visits.append(date)\n", " self.points += 10" ], "execution_count": null, "outputs": [], "id": "customer" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 3 — выполните после своего решения\n", "from dataclasses import MISSING, fields, is_dataclass\n", "\n", "\n", "def test_dataclass():\n", " \"Customer — dataclass с четырьмя полями\"\n", " assert is_dataclass(Customer), \"Customer — не dataclass: поставьте @dataclass над классом\"\n", " assert [f.name for f in fields(Customer)] == [\"name\", \"phone\", \"points\", \"visits\"], f\"поля: {[f.name for f in fields(Customer)]} — объявите их с аннотациями\"\n", " assert fields(Customer)[3].default_factory is not MISSING, \"поле visits объявите через field(default_factory=list) — так у каждого покупателя будет свой список\"\n", " # методы, которые написал декоратор, скомпилированы из «» (__repr__ обёрнут — берём __wrapped__)\n", " own = [m for m in [\"__init__\", \"__repr__\", \"__eq__\"] if not getattr(getattr(Customer, m), \"__wrapped__\", getattr(Customer, m)).__code__.co_filename.startswith(\"<\")]\n", " assert not own, f\"в классе остались написанные вручную методы: {', '.join(own)} — удалите их, их напишет декоратор\"\n", "\n", "\n", "def test_defaults():\n", " \"points = 0, visits — свой пустой список\"\n", " a, b = Customer(\"Анна\", \"1\"), Customer(\"Борис\", \"2\")\n", " assert a.points == 0 and a.visits == [], f\"у нового покупателя points = {a.points!r}, visits = {a.visits!r}\"\n", " a.visits.append(\"01.10\")\n", " assert b.visits == [], \"визит Анны появился у Бориса — используйте field(default_factory=list)\"\n", "\n", "\n", "def test_visit():\n", " \"visit и сравнение\"\n", " a = Customer(\"Анна\", \"1\")\n", " a.visit(\"01.10\")\n", " assert a.visits == [\"01.10\"] and a.points == 10, f\"после visit: visits = {a.visits!r}, points = {a.points!r}\"\n", " assert repr(Customer(\"Анна\", \"1\")) == \"Customer(name='Анна', phone='1', points=0, visits=[])\", f\"repr = {Customer('Анна', '1')!r}\"\n", " assert Customer(\"Анна\", \"1\") == Customer(\"Анна\", \"1\"), \"одинаковые покупатели должны быть равны\"\n", "\n", "_check(test_dataclass, test_defaults, test_visit)" ], "execution_count": null, "outputs": [], "id": "customer-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "from dataclasses import dataclass, field\n", "\n", "\n", "@dataclass\n", "class Customer:\n", " name: str\n", " phone: str\n", " points: int = 0\n", " visits: list = field(default_factory=list)\n", "\n", " def visit(self, date):\n", " self.visits.append(date)\n", " self.points += 10\n", "```\n", "\n", "
" ], "id": "customer-solution" } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "name": "python" }, "colab": { "provenance": [] } }, "nbformat": 4, "nbformat_minor": 5 }