{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Методы класса и статические методы\n", "\n", "@classmethod получает класс вместо экземпляра — так пишут альтернативные конструкторы: Product.from_line(...). @staticmethod — вспомогательная функция внутри класса.\n", "\n", "Курс ООП в Python · урок `oop-classmethod` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/oop/classmethod).\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(\"Латте\", 220)`, а строками из файла\n", "(`\"Латте;220\"`) или словарями из формы. Разбирать строку перед каждым созданием экземпляра — неудобно, и\n", "делать это в `__init__` тоже не хочется: тогда обычный вызов `Product(\"Латте\", 220)` перестанет работать.\n", "Нужен второй способ создать экземпляр — **альтернативный конструктор**.\n", "\n", "## `@classmethod`\n", "\n", "Метод с декоратором `@classmethod` — **метод класса** (class method). Первым параметром он получает не\n", "экземпляр, а **сам класс** — по соглашению этот параметр называют `cls`. Вызывают его через класс:\n", "`Product.from_line(\"Латте;220\")`. Внутри `cls(...)` — то же, что вызов класса, то есть создание экземпляра:" ], "id": "text-9" }, { "cell_type": "code", "metadata": {}, "source": [ "# Товар из строки\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\"{type(self).__name__}({self.name!r}, {self.price})\"\n", "\n", " @classmethod\n", " def from_line(cls, line):\n", " name, price = line.split(\";\")\n", " return cls(name, int(price))\n", "\n", "\n", "print(Product.from_line(\"Латте;220\"))\n", "print([Product.from_line(line) for line in [\"Чай;120\", \"Раф;260\"]])" ], "execution_count": null, "outputs": [], "id": "from-line" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 1. Напиток из строки\n", "\n", "Допишите класс `Drink`: метод класса `from_line(line)` создаёт напиток из строки вида `\"Латте;220;300\"` —\n", "название, цена и объём через точку с запятой. Цена и объём — целые числа.\n", "\n", "
Подсказка 1\n", "\n", "`name, price, volume = line.split(\";\")`; числа — `int(price)` и `int(volume)`.\n", "\n", "
\n", "
Подсказка 2\n", "\n", "Верните `cls(name, ..., ...)`, а не `Drink(...)` — почему, расскажет следующий раздел.\n", "\n", "
" ], "id": "drink-line-task" }, { "cell_type": "code", "metadata": {}, "source": [ "class Drink:\n", " def __init__(self, name, price, volume):\n", " self.name = name\n", " self.price = price\n", " self.volume = volume\n", "\n", " def __repr__(self):\n", " return f\"{type(self).__name__}({self.name!r}, {self.price}, {self.volume})\"\n", "\n", " @classmethod\n", " def from_line(cls, line):\n", " ..." ], "execution_count": null, "outputs": [], "id": "drink-line" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 1 — выполните после своего решения\n", "def test_is_classmethod():\n", " \"from_line — метод класса\"\n", " assert isinstance(Drink.__dict__.get(\"from_line\"), classmethod), \"from_line должен быть методом класса — с декоратором @classmethod\"\n", "\n", "\n", "def test_parse():\n", " \"Drink.from_line(\\\"Латте;220;300\\\")\"\n", " try:\n", " latte = Drink.from_line(\"Латте;220;300\")\n", " except TypeError as e:\n", " assert False, f\"Drink.from_line(\\\"Латте;220;300\\\") падает: {e}. Первый параметр метода класса — cls, второй — line\"\n", " assert isinstance(latte, Drink), f\"from_line вернул {type(latte).__name__}, а нужен экземпляр Drink: cls(...)\"\n", " assert latte.name == \"Латте\", f\"name = {latte.name!r}\"\n", " assert latte.price == 220 and latte.volume == 300, f\"price и volume = {latte.price!r} и {latte.volume!r}, а нужны числа 220 и 300 — переведите их int()\"\n", "\n", "\n", "def test_subclass():\n", " \"подкласс получает экземпляр подкласса\"\n", " class SeasonalDrink(Drink):\n", " pass\n", " got = SeasonalDrink.from_line(\"Глинтвейн;300;250\")\n", " assert type(got) is SeasonalDrink, f\"SeasonalDrink.from_line вернул {type(got).__name__} — создавайте экземпляр через cls(...), а не Drink(...)\"\n", "\n", "_check(test_is_classmethod, test_parse, test_subclass, names=[\"Drink.from_line\"])" ], "execution_count": null, "outputs": [], "id": "drink-line-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "class Drink:\n", " def __init__(self, name, price, volume):\n", " self.name = name\n", " self.price = price\n", " self.volume = volume\n", "\n", " def __repr__(self):\n", " return f\"{type(self).__name__}({self.name!r}, {self.price}, {self.volume})\"\n", "\n", " @classmethod\n", " def from_line(cls, line):\n", " name, price, volume = line.split(\";\")\n", " return cls(name, int(price), int(volume))\n", "```\n", "\n", "
" ], "id": "drink-line-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Почему `cls`, а не имя класса\n", "\n", "Метод класса наследуется. Если подкласс вызывает `from_line`, то `cls` — это подкласс, и создаётся\n", "экземпляр подкласса. А `Drink(...)`, записанный внутри метода явно, всегда создаёт `Drink` — даже когда\n", "вызвали `SeasonalDrink.from_line(...)`:" ], "id": "text-30" }, { "cell_type": "code", "metadata": {}, "source": [ "# cls — тот класс, через который вызвали\n", "class SeasonalProduct(Product):\n", " pass\n", "\n", "\n", "print(SeasonalProduct.from_line(\"Глинтвейн;300\"))\n", "print(type(SeasonalProduct.from_line(\"Глинтвейн;300\")).__name__)" ], "execution_count": null, "outputs": [], "id": "cls" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 2. Покупатель из формы\n", "\n", "Допишите класс `Customer`: метод класса `from_dict(data)` создаёт покупателя из словаря\n", "`{\"name\": \"Анна\", \"phone\": \"+7 900 111-22-33\"}`. Если в словаре нет ключа `\"points\"`, баллов 0, иначе —\n", "значение из словаря.\n", "\n", "
Подсказка 1\n", "\n", "`data.get(\"points\", 0)` возвращает 0, если ключа нет.\n", "\n", "
" ], "id": "customer-dict-task" }, { "cell_type": "code", "metadata": {}, "source": [ "class Customer:\n", " def __init__(self, name, phone, points=0):\n", " self.name = name\n", " self.phone = phone\n", " self.points = points\n", "\n", " @classmethod\n", " def from_dict(cls, data):\n", " ..." ], "execution_count": null, "outputs": [], "id": "customer-dict" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 2 — выполните после своего решения\n", "def test_basic():\n", " \"имя и телефон из словаря, баллов 0\"\n", " assert isinstance(Customer.__dict__.get(\"from_dict\"), classmethod), \"from_dict должен быть методом класса — с @classmethod\"\n", " anna = Customer.from_dict({\"name\": \"Анна\", \"phone\": \"+7 900 111-22-33\"})\n", " assert isinstance(anna, Customer), f\"from_dict вернул {type(anna).__name__}, а нужен экземпляр Customer\"\n", " assert (anna.name, anna.phone) == (\"Анна\", \"+7 900 111-22-33\"), f\"name и phone = {anna.name!r}, {anna.phone!r}\"\n", " assert anna.points == 0, f\"без ключа points баллов должно быть 0, а получилось {anna.points!r}\"\n", "\n", "\n", "def test_points():\n", " \"баллы из словаря, если есть\"\n", " try:\n", " boris = Customer.from_dict({\"name\": \"Борис\", \"phone\": \"+7 900 222-33-44\", \"points\": 340})\n", " except KeyError as e:\n", " assert False, f\"нет ключа {e} — берите необязательные значения через data.get(…)\"\n", " assert boris.points == 340, f\"баллы из словаря — 340, а получилось {boris.points!r}\"\n", "\n", "_check(test_basic, test_points, names=[\"Customer.from_dict\"])" ], "execution_count": null, "outputs": [], "id": "customer-dict-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "class Customer:\n", " def __init__(self, name, phone, points=0):\n", " self.name = name\n", " self.phone = phone\n", " self.points = points\n", "\n", " @classmethod\n", " def from_dict(cls, data):\n", " return cls(data[\"name\"], data[\"phone\"], data.get(\"points\", 0))\n", "```\n", "\n", "
" ], "id": "customer-dict-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## `@staticmethod`\n", "\n", "Иногда функция логически относится к классу, но ей не нужны ни экземпляр, ни класс — например, проверка\n", "формата телефона. Такую функцию объявляют внутри класса с декоратором `@staticmethod` — это **статический\n", "метод** (static method): без `self` и без `cls`. Вызывают его через класс или экземпляр:" ], "id": "text-46" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка цены из строки\n", "class PriceTag:\n", " def __init__(self, name, price):\n", " self.name = name\n", " self.price = price\n", "\n", " @staticmethod\n", " def parse_price(text): # ни self, ни cls\n", " return int(text.replace(\"₽\", \"\").strip())\n", "\n", " @classmethod\n", " def from_text(cls, name, text):\n", " return cls(name, cls.parse_price(text))\n", "\n", "\n", "print(PriceTag.parse_price(\"220 ₽\"))\n", "print(PriceTag.from_text(\"Латте\", \"240 ₽\").price)" ], "execution_count": null, "outputs": [], "id": "static" }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Типичная ошибка: self в статическом методе.**\n", ">\n", "> Python ничего не подставляет в статический метод: если оставить в нём `self` первым параметром, вызов\n", "> `Customer.normalize_phone(\"+7…\")` отдаст строку в `self`, а для `phone` аргумента не останется —\n", "> `TypeError: … missing 1 required positional argument: 'phone'`. У статического метода параметры — только его\n", "> собственные данные." ], "id": "component-55" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 3. Проверка телефона\n", "\n", "Допишите в класс `Customer` статический метод `normalize_phone(phone)`: он оставляет в строке только цифры\n", "и возвращает их строкой, если цифр ровно 11, а иначе выбрасывает `ValueError`. Например,\n", "`Customer.normalize_phone(\"+7 (900) 111-22-33\")` — `\"79001112233\"`. Скопируйте класс из упражнения выше.\n", "\n", "
Подсказка 1\n", "\n", "Цифры — `\"\".join(ch for ch in phone if ch.isdigit())`.\n", "\n", "
" ], "id": "phone-task" }, { "cell_type": "code", "metadata": {}, "source": [ "class Customer:\n", " # скопируйте сюда __init__ и from_dict из упражнения выше\n", "\n", " @staticmethod\n", " def normalize_phone(phone):\n", " ..." ], "execution_count": null, "outputs": [], "id": "phone" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 3 — выполните после своего решения\n", "def test_copied():\n", " \"from_dict на месте\"\n", " assert isinstance(Customer.__dict__.get(\"from_dict\"), classmethod), \"в классе нет from_dict — скопируйте класс из упражнения выше\"\n", " anna = Customer.from_dict({\"name\": \"Анна\", \"phone\": \"1\"})\n", " assert anna.points == 0, \"from_dict работает не так, как в упражнении выше — проверьте скопированный код\"\n", "\n", "\n", "def test_static():\n", " \"normalize_phone — статический метод\"\n", " assert isinstance(Customer.__dict__.get(\"normalize_phone\"), staticmethod), \"normalize_phone должен быть статическим — с @staticmethod\"\n", "\n", "\n", "def _call(phone):\n", " try:\n", " return Customer.normalize_phone(phone)\n", " except TypeError:\n", " assert False, \"normalize_phone не вызывается с одним аргументом — у статического метода нет self, уберите его из параметров\"\n", "\n", "\n", "def test_digits():\n", " \"оставляет 11 цифр\"\n", " got = _call(\"+7 (900) 111-22-33\")\n", " assert got is not None, \"normalize_phone ничего не возвращает — нужен return\"\n", " assert got == \"79001112233\", f\"normalize_phone(\\\"+7 (900) 111-22-33\\\") = {got!r}, а нужно \\\"79001112233\\\"\"\n", "\n", "\n", "def test_invalid():\n", " \"не 11 цифр — ValueError\"\n", " for bad in [\"123-45\", \"+7 900 111-22-33-44\"]:\n", " try:\n", " _call(bad)\n", " except ValueError:\n", " continue\n", " assert False, f\"normalize_phone({bad!r}) не выбросил ValueError — в номере не 11 цифр\"\n", "\n", "_check(test_copied, test_static, test_digits, test_invalid, names=[\"Customer.normalize_phone\"])" ], "execution_count": null, "outputs": [], "id": "phone-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "class Customer:\n", " def __init__(self, name, phone, points=0):\n", " self.name = name\n", " self.phone = phone\n", " self.points = points\n", "\n", " @classmethod\n", " def from_dict(cls, data):\n", " return cls(data[\"name\"], data[\"phone\"], data.get(\"points\", 0))\n", "\n", " @staticmethod\n", " def normalize_phone(phone):\n", " digits = \"\".join(ch for ch in phone if ch.isdigit())\n", " if len(digits) != 11:\n", " raise ValueError(\"в номере телефона должно быть 11 цифр\")\n", " return digits\n", "```\n", "\n", "
" ], "id": "phone-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Какой метод выбрать\n", "\n", "| Метод | Первый параметр | Когда |\n", "| --- | --- | --- |\n", "| обычный | `self` — экземпляр | работает с данными экземпляра |\n", "| `@classmethod` | `cls` — класс | создаёт экземпляры (альтернативный конструктор) или работает с атрибутами класса |\n", "| `@staticmethod` | нет | вспомогательная функция, которая по смыслу относится к классу |" ], "id": "text-69" }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Вопрос.** Какой метод нужен для `Order.from_receipt(text)`, который разбирает текст чека и возвращает новый заказ?\n", "\n", "- обычный метод с `self`\n", "- метод класса с `cls`\n", "- статический метод\n", "\n", "
Ответ\n", "\n", "метод класса с `cls`\n", "\n", "Экземпляра ещё нет — его только предстоит создать, поэтому `self` неоткуда взять. Метод класса получает класс и создаёт экземпляр вызовом `cls(...)` — и для подклассов тоже. Статический метод мог бы вернуть `Order(...)`, но потерял бы подклассы.\n", "\n", "
" ], "id": "quiz-78" } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "name": "python" }, "colab": { "provenance": [] } }, "nbformat": 4, "nbformat_minor": 5 }