{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Первый класс\n", "\n", "Объявить свой класс словом class, создать экземпляры вызовом класса и записать в них атрибуты — и понять, почему записывать атрибуты снаружи неудобно.\n", "\n", "Курс ООП в Python · урок `oop-first-class` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/oop/first-class).\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": [ "Встроенных классов — `int`, `str`, `list` — не хватит, чтобы описать кофейню: нет класса «товар», «заказ»\n", "или «карта лояльности». Такие классы объявляют сами.\n", "\n", "## Объявление класса\n", "\n", "Класс объявляется словом `class`, за ним — имя и двоеточие, ниже с отступом — тело класса. Имена классов\n", "пишут с большой буквы, слова — слитно: `Product`, `LoyaltyCard`. Пока тело пустое, в нём пишут `pass` —\n", "«ничего не делать»:" ], "id": "text-9" }, { "cell_type": "code", "metadata": {}, "source": [ "# Пустой класс Product\n", "class Product:\n", " pass\n", "\n", "\n", "print(Product.__name__)\n", "print(type(Product).__name__)" ], "execution_count": null, "outputs": [], "id": "declare" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Чтобы создать **экземпляр** класса, класс **вызывают**, как функцию: `Product()`. Каждый вызов создаёт\n", "новый объект. `type` и `isinstance` работают с вашим классом так же, как со встроенными:" ], "id": "text-20" }, { "cell_type": "code", "metadata": {}, "source": [ "# Два экземпляра Product\n", "first = Product()\n", "second = Product()\n", "print(type(first).__name__)\n", "print(isinstance(first, Product))\n", "print(first == second) # два разных объекта" ], "execution_count": null, "outputs": [], "id": "instances" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 1. Класс напитка\n", "\n", "Объявите пустой класс `Drink` и создайте его экземпляр `espresso`.\n", "\n", "
Подсказка 1\n", "\n", "`class Drink:` и с отступом `pass`; экземпляр — `Drink()`.\n", "\n", "
" ], "id": "declare-drink-task" }, { "cell_type": "code", "metadata": {}, "source": [ "# объявите класс Drink\n", "\n", "espresso = ..." ], "execution_count": null, "outputs": [], "id": "declare-drink" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 1 — выполните после своего решения\n", "def test_class():\n", " \"Drink — класс\"\n", " assert \"Drink\" in globals(), \"класса Drink нет — объявите его: class Drink:\"\n", " assert isinstance(Drink, type), f\"Drink — это {type(Drink).__name__}, а нужен класс: class Drink:\"\n", "\n", "\n", "def test_instance():\n", " \"espresso — экземпляр Drink\"\n", " assert isinstance(Drink, type), \"сначала объявите класс Drink\"\n", " assert espresso is not Drink, \"espresso — это сам класс; экземпляр создаётся вызовом: Drink()\"\n", " assert isinstance(espresso, Drink), f\"espresso — это {type(espresso).__name__}, а нужен экземпляр Drink: Drink()\"\n", "\n", "_check(test_class, test_instance, names=[\"espresso\"])" ], "execution_count": null, "outputs": [], "id": "declare-drink-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "class Drink:\n", " pass\n", "\n", "\n", "espresso = Drink()\n", "```\n", "\n", "
" ], "id": "declare-drink-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Атрибуты экземпляра\n", "\n", "У экземпляра могут быть **атрибуты** (attribute) — переменные, которые живут внутри объекта. Записывают и\n", "читают их через точку: `cup.name = \"Латте\"`, `print(cup.name)`. У каждого экземпляра атрибуты свои:" ], "id": "text-31" }, { "cell_type": "code", "metadata": {}, "source": [ "# Атрибуты двух чашек\n", "cup = Product()\n", "cup.name = \"Латте\"\n", "cup.price = 220\n", "\n", "other = Product()\n", "other.name = \"Чай\"\n", "other.price = 120\n", "\n", "print(cup.name, cup.price)\n", "print(other.name, other.price)\n", "print(cup.price + other.price)" ], "execution_count": null, "outputs": [], "id": "attributes" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 2. Латте с атрибутами\n", "\n", "Создайте экземпляр `latte` класса `Drink` с атрибутами `name` — `\"Латте\"`, `price` — 220 и `volume` — 300.\n", "\n", "
Подсказка 1\n", "\n", "Сначала `latte = Drink()`, затем три строки вида `latte.price = 220`.\n", "\n", "
" ], "id": "latte-task" }, { "cell_type": "code", "metadata": {}, "source": [ "latte = ..." ], "execution_count": null, "outputs": [], "id": "latte" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 2 — выполните после своего решения\n", "def test_instance():\n", " \"latte — экземпляр Drink\"\n", " assert isinstance(latte, Drink), f\"latte — это {type(latte).__name__}, а нужен экземпляр: latte = Drink()\"\n", "\n", "\n", "def test_attributes():\n", " \"у latte атрибуты name, price и volume\"\n", " assert isinstance(latte, Drink), \"сначала создайте экземпляр: latte = Drink()\"\n", " for attr in [\"name\", \"price\", \"volume\"]:\n", " assert hasattr(latte, attr), f\"у latte нет атрибута {attr} — запишите его: latte.{attr} = …\"\n", " assert latte.name == \"Латте\", f\"latte.name = {latte.name!r}, а нужно \\\"Латте\\\"\"\n", " assert latte.price == 220, f\"latte.price = {latte.price!r}, а нужно число 220 (без кавычек)\"\n", " assert latte.volume == 300, f\"latte.volume = {latte.volume!r}, а нужно число 300\"\n", "\n", "_check(test_instance, test_attributes, names=[\"latte\"])" ], "execution_count": null, "outputs": [], "id": "latte-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "latte = Drink()\n", "latte.name = \"Латте\"\n", "latte.price = 220\n", "latte.volume = 300\n", "```\n", "\n", "
" ], "id": "latte-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "С атрибутами экземпляр работает как обычное значение: их складывают, сравнивают, передают в функции." ], "id": "text-44" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 3. Маленький и большой\n", "\n", "Создайте два экземпляра `Drink`: `small` с атрибутами `name = \"Капучино\"`, `price = 180` и `large`\n", "с `name = \"Капучино\"`, `price = 240`. Сохраните в `diff`, на сколько большой дороже маленького.\n", "\n", "
Подсказка 1\n", "\n", "Разница — `large.price - small.price`.\n", "\n", "
" ], "id": "two-sizes-task" }, { "cell_type": "code", "metadata": {}, "source": [ "small = ...\n", "large = ...\n", "diff = ..." ], "execution_count": null, "outputs": [], "id": "two-sizes" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 3 — выполните после своего решения\n", "def test_two():\n", " \"small и large — два разных экземпляра Drink\"\n", " assert isinstance(small, Drink) and isinstance(large, Drink), \"small и large должны быть экземплярами Drink: small = Drink()\"\n", " assert small is not large, \"small и large — один и тот же объект; создайте два: два раза вызовите Drink()\"\n", " assert getattr(small, \"price\", None) == 180, \"у small должна быть цена small.price = 180\"\n", " assert getattr(large, \"price\", None) == 240, \"у large должна быть цена large.price = 240\"\n", " assert getattr(small, \"name\", None) == \"Капучино\" and getattr(large, \"name\", None) == \"Капучино\", \"у обоих напитков name = \\\"Капучино\\\"\"\n", "\n", "\n", "def test_diff():\n", " \"diff — на сколько большой дороже\"\n", " assert diff != -60, \"получилось -60: вычитайте из цены большого цену маленького\"\n", " assert diff == 60, f\"diff = {diff!r}, а большой дороже на 60 ₽\"\n", "\n", "_check(test_two, test_diff, names=[\"small\",\"large\",\"diff\"])" ], "execution_count": null, "outputs": [], "id": "two-sizes-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "small = Drink()\n", "small.name = \"Капучино\"\n", "small.price = 180\n", "large = Drink()\n", "large.name = \"Капучино\"\n", "large.price = 240\n", "diff = large.price - small.price\n", "```\n", "\n", "
" ], "id": "two-sizes-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Почему так неудобно\n", "\n", "Записывать атрибуты снаружи можно, но легко ошибиться. Забыли строчку — атрибута у объекта нет, и программа\n", "упадёт там, где его прочитают:" ], "id": "text-53" }, { "cell_type": "code", "metadata": {}, "source": [ "# Атрибут забыли записать\n", "# Эта ячейка показывает ошибку AttributeError: она перехвачена, чтобы «Выполнить всё» не останавливалось.\n", "try:\n", " tea = Drink()\n", " tea.name = \"Чай\"\n", " print(tea.price)\n", "except Exception as error:\n", " print(f\"{type(error).__name__}: {error}\")" ], "execution_count": null, "outputs": [], "id": "forgot" }, { "cell_type": "markdown", "metadata": {}, "source": [ "А опечатка ещё хуже: Python молча создаст *новый* атрибут, и старое значение останется прежним:" ], "id": "text-60" }, { "cell_type": "code", "metadata": {}, "source": [ "# Опечатка в имени атрибута\n", "tea.price = 120\n", "tea.prise = 130 # опечатка\n", "print(tea.price)\n", "print(tea.prise)" ], "execution_count": null, "outputs": [], "id": "typo" }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Типичная ошибка: опечатка создаёт новый атрибут.**\n", ">\n", "> `tea.prise = 130` не исправляет цену, а добавляет экземпляру ещё один атрибут `prise`. Ошибки нет, поэтому\n", "> такую опечатку трудно заметить. Это главная причина задавать все атрибуты в одном месте — как это сделать,\n", "> расскажет следующий урок." ], "id": "component-65" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Пока придётся следить самим. Например, вынести создание объекта в функцию — тогда атрибуты задаются в одном\n", "месте и одинаково для всех объектов." ], "id": "text-70" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 4. Функция-фабрика\n", "\n", "Напишите функцию `make_drink(name, price)`: она создаёт экземпляр `Drink`, записывает в него атрибуты\n", "`name` и `price` из аргументов и возвращает его.\n", "\n", "
Подсказка 1\n", "\n", "Внутри функции: `drink = Drink()`, две строки с атрибутами и `return drink`.\n", "\n", "
" ], "id": "make-drink-task" }, { "cell_type": "code", "metadata": {}, "source": [ "def make_drink(name, price):\n", " ... # создайте Drink, запишите атрибуты и верните его" ], "execution_count": null, "outputs": [], "id": "make-drink" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 4 — выполните после своего решения\n", "def test_returns():\n", " \"make_drink возвращает экземпляр Drink\"\n", " got = make_drink(\"Раф\", 260)\n", " assert got is not None, \"функция ничего не возвращает — в конце нужен return\"\n", " assert isinstance(got, Drink), f\"функция вернула {type(got).__name__}, а нужен экземпляр Drink\"\n", "\n", "\n", "def test_attributes():\n", " \"атрибуты name и price — из аргументов\"\n", " got = make_drink(\"Раф\", 260)\n", " assert isinstance(got, Drink), \"функция должна вернуть экземпляр Drink\"\n", " assert getattr(got, \"name\", None) == \"Раф\", \"у результата make_drink(\\\"Раф\\\", 260) должно быть name = \\\"Раф\\\"\"\n", " assert getattr(got, \"price\", None) == 260, \"у результата make_drink(\\\"Раф\\\", 260) должно быть price = 260\"\n", " other = make_drink(\"Чай\", 120)\n", " assert getattr(other, \"price\", None) == 120, \"атрибуты берутся из аргументов: у make_drink(\\\"Чай\\\", 120) цена 120\"\n", " assert other is not got, \"каждый вызов должен создавать новый экземпляр — Drink() внутри функции\"\n", "\n", "_check(test_returns, test_attributes)" ], "execution_count": null, "outputs": [], "id": "make-drink-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "def make_drink(name, price):\n", " drink = Drink()\n", " drink.name = name\n", " drink.price = price\n", " return drink\n", "```\n", "\n", "
" ], "id": "make-drink-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Функция-фабрика помогает, но она живёт отдельно от класса: про неё можно забыть и снова создать объект\n", "без атрибутов. В Python для этого есть место внутри самого класса — метод `__init__`. О нём — следующий урок." ], "id": "text-80" } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "name": "python" }, "colab": { "provenance": [] } }, "nbformat": 4, "nbformat_minor": 5 }