{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Свойства\n", "\n", "Декоратор @property превращает метод в атрибут, который читается без скобок, — вычисляемый и только для чтения. Когда писать свойство, а когда метод.\n", "\n", "Курс ООП в Python · урок `oop-property` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/oop/property).\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": [ "В прошлом уроке баланс карты читался методом: `card.balance()`. Работает, но выглядит странно — баланс\n", "скорее *атрибут* карты, чем действие. Python позволяет оставить внутренний `_balance` спрятанным и при этом\n", "читать баланс как атрибут, без скобок. Для этого есть **свойства** (property).\n", "\n", "## @property\n", "\n", "Строка `@property` перед методом — это **декоратор** (decorator): он меняет то, как работает метод под ним.\n", "Метод с `@property` вызывается сам, когда атрибут *читают*, — скобки не нужны. Например, у заказа статус\n", "хранится во внутреннем `_status`, а читается свойством `status`:" ], "id": "text-9" }, { "cell_type": "code", "metadata": {}, "source": [ "# Статус заказа — свойство\n", "class Order:\n", " def __init__(self, number):\n", " self._number = number\n", " self._status = \"новый\"\n", "\n", " @property\n", " def number(self):\n", " return self._number\n", "\n", " @property\n", " def status(self):\n", " return self._status\n", "\n", " def pay(self):\n", " if self._status == \"оплачен\":\n", " return False # дважды не оплачивают\n", " self._status = \"оплачен\"\n", " return True\n", "\n", "\n", "order = Order(17)\n", "print(order.number, order.status) # без скобок\n", "print(order.pay(), order.status)\n", "print(order.pay(), order.status)" ], "execution_count": null, "outputs": [], "id": "property" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Снаружи `order.status` выглядит как обычный атрибут, но записать в него нельзя: у свойства есть только\n", "«чтение» — **геттер** (getter). Так получается атрибут **только для чтения**:" ], "id": "text-21" }, { "cell_type": "code", "metadata": {}, "source": [ "# В свойство нельзя записать\n", "# Эта ячейка показывает ошибку AttributeError: она перехвачена, чтобы «Выполнить всё» не останавливалось.\n", "try:\n", " order.status = \"отменён\"\n", "except Exception as error:\n", " print(f\"{type(error).__name__}: {error}\")" ], "execution_count": null, "outputs": [], "id": "read-only" }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Свойство сильнее экземпляра.** В модуле 2 запись `latte.CURRENCY = \"$\"` создавала атрибут у экземпляра и закрывала атрибут класса. Со\n", "> свойством так не выйдет: свойство — особый атрибут класса, который перехватывает и чтение, и запись через\n", "> экземпляр. Поэтому `order.status = …` не создаёт атрибут у заказа, а обращается к свойству — и получает\n", "> отказ, потому что записи у него нет." ], "id": "component-27" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Менять статус можно только методами заказа — например, `pay()`, который не даст оплатить заказ дважды.\n", "Так же стоит поступить с балансом подарочной карты." ], "id": "text-33" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 1. Баланс карты свойством\n", "\n", "Допишите класс `GiftCard`: сделайте `balance` свойством, которое возвращает `_balance`. Методы `pay` и\n", "`top_up` уже есть.\n", "\n", "
Подсказка 1\n", "\n", "Перед методом `def balance(self):` строка `@property`; внутри — `return self._balance`.\n", "\n", "
" ], "id": "balance-task" }, { "cell_type": "code", "metadata": {}, "source": [ "class GiftCard:\n", " def __init__(self, amount):\n", " self._balance = amount\n", "\n", " def balance(self):\n", " ...\n", "\n", " def pay(self, amount):\n", " if amount > self._balance:\n", " return False\n", " self._balance -= amount\n", " return True\n", "\n", " def top_up(self, amount):\n", " if amount <= 0:\n", " return False\n", " self._balance += amount\n", " return True" ], "execution_count": null, "outputs": [], "id": "balance" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 1 — выполните после своего решения\n", "def test_is_property():\n", " \"balance — свойство\"\n", " assert \"balance\" in GiftCard.__dict__, \"в классе нет balance — объявите его\"\n", " assert isinstance(GiftCard.__dict__[\"balance\"], property), \"balance — обычный метод; поставьте над ним декоратор @property\"\n", "\n", "\n", "def test_value():\n", " \"card.balance — текущий баланс\"\n", " assert isinstance(GiftCard.__dict__.get(\"balance\"), property), \"сначала сделайте balance свойством\"\n", " card = GiftCard(500)\n", " assert card.balance == 500, f\"у GiftCard(500) balance = {card.balance!r}, а нужно 500 — верните self._balance\"\n", " card.pay(200)\n", " assert card.balance == 300, f\"после pay(200) balance = {card.balance!r}, а нужно 300\"\n", "\n", "\n", "def test_read_only():\n", " \"записать в balance нельзя\"\n", " assert isinstance(GiftCard.__dict__.get(\"balance\"), property), \"сначала сделайте balance свойством\"\n", " card = GiftCard(500)\n", " try:\n", " card.balance = 10 ** 6\n", " except AttributeError:\n", " return\n", " assert False, \"в balance удалось записать значение — у свойства не должно быть сеттера\"\n", "\n", "_check(test_is_property, test_value, test_read_only, names=[\"GiftCard.balance\"])" ], "execution_count": null, "outputs": [], "id": "balance-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "class GiftCard:\n", " def __init__(self, amount):\n", " self._balance = amount\n", "\n", " @property\n", " def balance(self):\n", " return self._balance\n", "\n", " def pay(self, amount):\n", " if amount > self._balance:\n", " return False\n", " self._balance -= amount\n", " return True\n", "\n", " def top_up(self, amount):\n", " if amount <= 0:\n", " return False\n", " self._balance += amount\n", " return True\n", "```\n", "\n", "
" ], "id": "balance-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Типичная ошибка: скобки после свойства.**\n", ">\n", "> `order.number()` для свойства — ошибка: `order.number` уже вернуло число, и скобки пытаются вызвать это\n", "> число — `TypeError: 'int' object is not callable`. Свойство читают без скобок." ], "id": "component-44" }, { "cell_type": "code", "metadata": {}, "source": [ "# Свойство со скобками\n", "# Эта ячейка показывает ошибку TypeError: она перехвачена, чтобы «Выполнить всё» не останавливалось.\n", "try:\n", " order.number()\n", "except Exception as error:\n", " print(f\"{type(error).__name__}: {error}\")" ], "execution_count": null, "outputs": [], "id": "call-property" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Вычисляемый атрибут\n", "\n", "Свойство не обязано возвращать сохранённый атрибут — оно может **вычислять** значение каждый раз, когда его\n", "читают. Например, сумма корзины: её не нужно хранить и обновлять при каждом `add`, достаточно посчитать\n", "по товарам:" ], "id": "text-50" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 2. Сумма и число товаров\n", "\n", "Допишите класс `Cart`: свойство `total` возвращает сумму цен товаров, свойство `count` — число товаров\n", "в корзине.\n", "\n", "
Подсказка 1\n", "\n", "Два метода с `@property`: `return sum(p.price for p in self.items)` и `return len(self.items)`.\n", "\n", "
" ], "id": "cart-task" }, { "cell_type": "code", "metadata": {}, "source": [ "class Product:\n", " def __init__(self, name, price):\n", " self.name = name\n", " self.price = price\n", "\n", "\n", "class Cart:\n", " def __init__(self):\n", " self.items = []\n", "\n", " def add(self, product):\n", " self.items.append(product)\n", "\n", " # свойства total и count" ], "execution_count": null, "outputs": [], "id": "cart" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 2 — выполните после своего решения\n", "def test_properties():\n", " \"total и count — свойства\"\n", " for name in [\"total\", \"count\"]:\n", " assert name in Cart.__dict__, f\"в классе Cart нет {name} — объявите его с декоратором @property\"\n", " assert isinstance(Cart.__dict__[name], property), f\"{name} — обычный метод; поставьте над ним @property\"\n", "\n", "\n", "def test_values():\n", " \"сумма и число товаров\"\n", " assert all(isinstance(Cart.__dict__.get(n), property) for n in [\"total\", \"count\"]), \"сначала объявите свойства total и count\"\n", " cart = Cart()\n", " assert cart.total == 0 and cart.count == 0, f\"у пустой корзины total = {cart.total!r}, count = {cart.count!r}, а нужно 0 и 0\"\n", " cart.add(Product(\"Чай\", 120))\n", " cart.add(Product(\"Раф\", 260))\n", " assert cart.count == 2, f\"в корзине 2 товара, а count = {cart.count!r}\"\n", " assert cart.total == 380, f\"чай и раф стоят 380, а total = {cart.total!r}\"\n", "\n", "_check(test_properties, test_values)" ], "execution_count": null, "outputs": [], "id": "cart-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "class Product:\n", " def __init__(self, name, price):\n", " self.name = name\n", " self.price = price\n", "\n", "\n", "class Cart:\n", " def __init__(self):\n", " self.items = []\n", "\n", " def add(self, product):\n", " self.items.append(product)\n", "\n", " @property\n", " def total(self):\n", " return sum(p.price for p in self.items)\n", "\n", " @property\n", " def count(self):\n", " return len(self.items)\n", "```\n", "\n", "
" ], "id": "cart-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Вычисляемое свойство всегда **актуально**: оно считается заново при каждом чтении. Значение, вычисленное\n", "один раз в `__init__`, устареет, как только поменяются данные." ], "id": "text-63" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 3. Размер по объёму\n", "\n", "Допишите класс `Drink`: свойство `size` возвращает размер по объёму `volume` — до 250 мл включительно `\"S\"`,\n", "до 350 мл включительно `\"M\"`, больше — `\"L\"`. Если объём изменился, размер должен измениться вместе с ним.\n", "\n", "
Подсказка 1\n", "\n", "Свойство с `if self.volume <= 250: return \"S\"`, затем проверка на 350 и `return \"L\"`.\n", "\n", "
" ], "id": "size-task" }, { "cell_type": "code", "metadata": {}, "source": [ "class Drink:\n", " def __init__(self, name, volume):\n", " self.name = name\n", " self.volume = volume\n", "\n", " @property\n", " def size(self):\n", " ..." ], "execution_count": null, "outputs": [], "id": "size" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 3 — выполните после своего решения\n", "def test_sizes():\n", " \"S, M и L по объёму, границы включительно\"\n", " assert isinstance(Drink.__dict__.get(\"size\"), property), \"size должен оставаться свойством — с декоратором @property\"\n", " cases = [(200, \"S\"), (250, \"S\"), (300, \"M\"), (350, \"M\"), (400, \"L\")]\n", " for volume, expected in cases:\n", " got = Drink(\"Латте\", volume).size\n", " assert got == expected, f\"при объёме {volume} мл size = {got!r}, а нужно {expected!r}\"\n", "\n", "\n", "def test_follows_volume():\n", " \"размер меняется вместе с объёмом\"\n", " cup = Drink(\"Латте\", 250)\n", " cup.volume = 400\n", " assert cup.size == \"L\", f\"объём стал 400 мл, а size всё ещё {cup.size!r} — вычисляйте размер в свойстве при каждом чтении, а не один раз в __init__\"\n", "\n", "_check(test_sizes, test_follows_volume, names=[\"Drink.size\"])" ], "execution_count": null, "outputs": [], "id": "size-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "class Drink:\n", " def __init__(self, name, volume):\n", " self.name = name\n", " self.volume = volume\n", "\n", " @property\n", " def size(self):\n", " if self.volume <= 250:\n", " return \"S\"\n", " if self.volume <= 350:\n", " return \"M\"\n", " return \"L\"\n", "```\n", "\n", "
" ], "id": "size-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Свойство или метод" ], "id": "text-73" }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Вопрос.** Что из этого естественнее сделать свойством, а не методом?\n", "\n", "- `pay(amount)` — оплатить с карты\n", "- `is_empty` — пуста ли корзина\n", "- `add(product)` — положить товар в корзину\n", "\n", "
Ответ\n", "\n", "`is_empty` — пуста ли корзина\n", "\n", "Свойство — это «характеристика» объекта: значение без параметров, которое быстро вычисляется и ничего не меняет. `pay` и `add` меняют состояние и принимают аргументы — это действия, то есть методы.\n", "\n", "
" ], "id": "quiz-76" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Правило выбора:\n", "\n", "| Свойство | Метод |\n", "| --- | --- |\n", "| характеристика объекта: `balance`, `total`, `size` | действие: `pay`, `add`, `remove` |\n", "| без параметров | с параметрами или без |\n", "| ничего не меняет в объекте | может менять состояние |\n", "| вычисляется быстро | может работать долго |\n", "\n", "В следующем уроке у свойства появится и запись — с проверкой значения." ], "id": "text-85" } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "name": "python" }, "colab": { "provenance": [] } }, "nbformat": 4, "nbformat_minor": 5 }