{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Свои исключения\n", "\n", "Исключение — тоже класс: своя иерархия ShopError → OutOfStockError, атрибуты исключения с подробностями, перехват по базовому классу и цепочка raise … from.\n", "\n", "Курс ООП в Python · урок `oop-exceptions` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/oop/exceptions).\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": [ "До сих пор программа сообщала об ошибках встроенными `ValueError` и `TypeError`. Но в кассе ошибки бывают\n", "свои: товара нет на складе, оплата не прошла, строка заказа записана неправильно. Код, который вызывает\n", "кассу, хочет отличать их друг от друга и от настоящих ошибок программы. Для этого объявляют **свои\n", "исключения** (exception).\n", "\n", "## Исключение — это класс\n", "\n", "Каждое исключение — экземпляр класса. Почти все классы исключений — и все, с которыми вы встречались, включая\n", "`ValueError`, — наследуют от `Exception` (выше него только `BaseException` для служебных вроде\n", "`KeyboardInterrupt` — Ctrl+C). Своё исключение — подкласс `Exception`; часто ему не нужно ничего, кроме имени. По соглашению имя\n", "заканчивается на `Error`:" ], "id": "text-9" }, { "cell_type": "code", "metadata": {}, "source": [ "# Своё исключение\n", "class RegisterClosedError(Exception):\n", " pass\n", "\n", "\n", "def open_check(hour):\n", " if hour < 8 or hour >= 22:\n", " raise RegisterClosedError(f\"касса закрыта в {hour}:00\")\n", " return \"чек открыт\"\n", "\n", "\n", "print(open_check(9))\n", "try:\n", " open_check(23)\n", "except RegisterClosedError as error:\n", " print(type(error).__name__, \"—\", error)" ], "execution_count": null, "outputs": [], "id": "own" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Иерархия исключений\n", "\n", "Свои исключения удобно собрать в иерархию: общий базовый класс для всех ошибок кассы и подклассы для\n", "конкретных случаев. Тогда `except ShopError` перехватит **любую** ошибку кассы, а `except OutOfStockError` —\n", "только нехватку товара. Работает обычный `isinstance`: исключение подкласса — это и исключение базового класса." ], "id": "text-23" }, { "cell_type": "code", "metadata": {}, "source": [ "# Перехват по базовому классу\n", "class DeliveryError(Exception):\n", " pass\n", "\n", "\n", "class CourierLateError(DeliveryError):\n", " pass\n", "\n", "\n", "class AddressError(DeliveryError):\n", " pass\n", "\n", "\n", "for problem in [CourierLateError(\"курьер опаздывает\"), AddressError(\"нет такого дома\")]:\n", " try:\n", " raise problem\n", " except DeliveryError as error: # перехватит оба подкласса\n", " print(type(error).__name__, \"→\", error)\n", "print(issubclass(AddressError, DeliveryError), issubclass(AddressError, Exception))" ], "execution_count": null, "outputs": [], "id": "hierarchy" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 1. Ошибки кассы\n", "\n", "Объявите три класса исключений: `ShopError` — базовый для всех ошибок кассы, подкласс `Exception`;\n", "`OutOfStockError` и `PaymentError` — подклассы `ShopError`.\n", "\n", "
Подсказка 1\n", "\n", "Каждому классу достаточно тела `pass`; важны только базовые классы в скобках.\n", "\n", "
" ], "id": "errors-task" }, { "cell_type": "code", "metadata": {}, "source": [ "# объявите ShopError, OutOfStockError и PaymentError" ], "execution_count": null, "outputs": [], "id": "errors" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 1 — выполните после своего решения\n", "def _cls(name):\n", " cls = globals().get(name)\n", " assert isinstance(cls, type), f\"класса {name} нет — объявите его\"\n", " return cls\n", "\n", "\n", "def test_base():\n", " \"ShopError — подкласс Exception\"\n", " shop = _cls(\"ShopError\")\n", " assert issubclass(shop, Exception), \"ShopError должен наследовать от Exception: class ShopError(Exception):\"\n", "\n", "\n", "def test_children():\n", " \"OutOfStockError и PaymentError — подклассы ShopError\"\n", " shop = _cls(\"ShopError\")\n", " for name in [\"OutOfStockError\", \"PaymentError\"]:\n", " cls = _cls(name)\n", " assert issubclass(cls, shop), f\"{name} должен наследовать от ShopError, а не прямо от Exception — иначе except ShopError его не перехватит\"\n", " assert not issubclass(_cls(\"PaymentError\"), _cls(\"OutOfStockError\")), \"PaymentError и OutOfStockError — разные ветки, оба наследуют от ShopError\"\n", "\n", "_check(test_base, test_children)" ], "execution_count": null, "outputs": [], "id": "errors-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "class ShopError(Exception):\n", " pass\n", "\n", "\n", "class OutOfStockError(ShopError):\n", " pass\n", "\n", "\n", "class PaymentError(ShopError):\n", " pass\n", "```\n", "\n", "
" ], "id": "errors-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Типичная ошибка: except не в том порядке.**\n", ">\n", "> Как и проверки `isinstance` в модуле 5, блоки `except` проверяются сверху вниз. Если первым стоит\n", "> `except ShopError`, до `except OutOfStockError` ниже дело не дойдёт. И не перехватывайте `Exception`\n", "> целиком без нужды: вместе с ошибками кассы он спрячет и настоящие ошибки в коде — опечатку в имени,\n", "> `TypeError` от неверного вызова." ], "id": "component-39" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Атрибуты исключения\n", "\n", "Исключение — объект, и у него могут быть атрибуты: какой товар, сколько просили, сколько есть. Код, который\n", "его перехватил, достанет подробности, а не будет разбирать текст сообщения. Текст же по-прежнему передают\n", "в `__init__` базового класса — его покажет `str(error)`:" ], "id": "text-45" }, { "cell_type": "code", "metadata": {}, "source": [ "# Исключение с подробностями\n", "class PaymentDeclinedError(Exception):\n", " def __init__(self, amount, reason):\n", " super().__init__(f\"оплата {amount} ₽ отклонена: {reason}\")\n", " self.amount = amount\n", " self.reason = reason\n", "\n", "\n", "try:\n", " raise PaymentDeclinedError(640, \"нет связи с банком\")\n", "except PaymentDeclinedError as error:\n", " print(error)\n", " print(error.amount, error.reason)" ], "execution_count": null, "outputs": [], "id": "attrs" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 2. Чего не хватает\n", "\n", "Допишите `OutOfStockError` (по-прежнему подкласс `ShopError`): `OutOfStockError(\"Сироп\", 2, 1)` хранит\n", "название товара, сколько просили и сколько есть — в атрибутах `name`, `requested` и `available`, а\n", "`str(error)` — `\"мало «Сироп»: нужно 2, есть 1\"`.\n", "\n", "
Подсказка 1\n", "\n", "Свой `__init__` записывает три атрибута и передаёт текст в `super().__init__(…)`.\n", "\n", "
" ], "id": "out-of-stock-task" }, { "cell_type": "code", "metadata": {}, "source": [ "class OutOfStockError(ShopError):\n", " def __init__(self, name, requested, available):\n", " ..." ], "execution_count": null, "outputs": [], "id": "out-of-stock" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 2 — выполните после своего решения\n", "def _error():\n", " try:\n", " return OutOfStockError(\"Сироп\", 2, 1)\n", " except TypeError as e:\n", " assert False, f\"OutOfStockError(\\\"Сироп\\\", 2, 1) не создаётся: {e}\"\n", "\n", "\n", "def test_attrs():\n", " \"name, requested, available\"\n", " assert issubclass(OutOfStockError, ShopError), \"OutOfStockError должен по-прежнему наследовать от ShopError\"\n", " e = _error()\n", " got = (getattr(e, \"name\", None), getattr(e, \"requested\", None), getattr(e, \"available\", None))\n", " assert got == (\"Сироп\", 2, 1), f\"атрибуты name, requested, available = {got}\"\n", "\n", "\n", "def test_message():\n", " \"str(error) — понятный текст\"\n", " got = str(_error())\n", " assert got != \"('Сироп', 2, 1)\", \"текст исключения — кортеж аргументов: передайте готовую фразу в super().__init__(…)\"\n", " assert got == \"мало «Сироп»: нужно 2, есть 1\", f\"str(error) = {got!r}\"\n", "\n", "_check(test_attrs, test_message, names=[\"OutOfStockError.__init__\"])" ], "execution_count": null, "outputs": [], "id": "out-of-stock-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "class OutOfStockError(ShopError):\n", " def __init__(self, name, requested, available):\n", " super().__init__(f\"мало «{name}»: нужно {requested}, есть {available}\")\n", " self.name = name\n", " self.requested = requested\n", " self.available = available\n", "```\n", "\n", "
" ], "id": "out-of-stock-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 3. Продажа со склада\n", "\n", "Напишите функцию `sell(stock, name, qty)`: `stock` — словарь «товар → количество». Если товара меньше `qty`\n", "(или его нет вовсе), функция выбрасывает `OutOfStockError` с подробностями и склад не меняет; иначе —\n", "уменьшает количество.\n", "\n", "
Подсказка 1\n", "\n", "Сколько товара есть, если ключа нет? Метод словаря, который возвращает значение по умолчанию.\n", "\n", "
\n", "
Подсказка 2\n", "\n", "Не хватает — `raise OutOfStockError(name, qty, available)` до изменения склада.\n", "\n", "
" ], "id": "sell-task" }, { "cell_type": "code", "metadata": {}, "source": [ "def sell(stock, name, qty):\n", " ..." ], "execution_count": null, "outputs": [], "id": "sell" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 3 — выполните после своего решения\n", "def test_ok():\n", " \"хватает — количество уменьшается\"\n", " stock = {\"Сироп\": 3}\n", " sell(stock, \"Сироп\", 2)\n", " assert stock == {\"Сироп\": 1}, f\"после sell(…, \\\"Сироп\\\", 2) склад {stock}, а нужно {{'Сироп': 1}}\"\n", "\n", "\n", "def test_short():\n", " \"не хватает — OutOfStockError, склад прежний\"\n", " stock = {\"Сироп\": 1}\n", " try:\n", " sell(stock, \"Сироп\", 2)\n", " except OutOfStockError as e:\n", " assert (e.name, e.requested, e.available) == (\"Сироп\", 2, 1), f\"в исключении name, requested, available = {e.name!r}, {e.requested!r}, {e.available!r}\"\n", " except KeyError:\n", " assert False, \"sell упал с KeyError — сколько есть, узнайте через stock.get(name, 0)\"\n", " else:\n", " assert False, \"sell(…, \\\"Сироп\\\", 2) при одной бутылке не выбросил OutOfStockError\"\n", " assert stock == {\"Сироп\": 1}, f\"после отказа склад {stock} — он не должен меняться\"\n", "\n", "\n", "def test_missing():\n", " \"товара нет вовсе — тоже OutOfStockError\"\n", " try:\n", " sell({}, \"Корица\", 1)\n", " except OutOfStockError as e:\n", " assert e.available == 0, f\"товара нет — available должен быть 0, а он {e.available!r}\"\n", " except KeyError:\n", " assert False, \"sell упал с KeyError — для отсутствующего товара считайте количество 0: stock.get(name, 0)\"\n", " else:\n", " assert False, \"sell для отсутствующего товара не выбросил OutOfStockError\"\n", "\n", "_check(test_ok, test_short, test_missing)" ], "execution_count": null, "outputs": [], "id": "sell-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "def sell(stock, name, qty):\n", " available = stock.get(name, 0)\n", " if available < qty:\n", " raise OutOfStockError(name, qty, available)\n", " stock[name] = available - qty\n", "```\n", "\n", "
" ], "id": "sell-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## `raise … from`: цепочка исключений\n", "\n", "Иногда своё исключение возникает из-за чужого: строку заказа `\"Латте x два\"` не удалось разобрать, потому что\n", "`int(\"два\")` выбросил `ValueError`. Перехватить `ValueError` и выбросить своё — правильно, но причину терять не\n", "стоит. `raise НовоеИсключение(…) from err` создаёт **цепочку исключений** (exception chaining): причина\n", "сохраняется в атрибуте `__cause__`, и трассировка покажет обе ошибки." ], "id": "text-70" }, { "cell_type": "code", "metadata": {}, "source": [ "# Причина в __cause__\n", "class PriceFormatError(Exception):\n", " pass\n", "\n", "\n", "def parse_price(text):\n", " try:\n", " return int(text.replace(\"₽\", \"\"))\n", " except ValueError as err:\n", " raise PriceFormatError(f\"цена не разобрана: {text}\") from err\n", "\n", "\n", "try:\n", " parse_price(\"двести ₽\")\n", "except PriceFormatError as error:\n", " print(error)\n", " print(\"причина:\", type(error.__cause__).__name__, \"—\", error.__cause__)" ], "execution_count": null, "outputs": [], "id": "chain" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 4. Разбор количества\n", "\n", "Объявите исключение `OrderFormatError` (подкласс `ShopError`) и функцию `parse_qty(text)`: она возвращает\n", "число из строки вида `\"x2\"` — после буквы `x`. Если число не разбирается, функция выбрасывает\n", "`OrderFormatError(\"неверное количество: x два\")` с исходным `ValueError` в качестве причины.\n", "\n", "
Подсказка 1\n", "\n", "Число — всё после первого символа: срез `text[1:]` и `int` внутри `try`.\n", "\n", "
\n", "
Подсказка 2\n", "\n", "В `except ValueError as err:` — своё исключение с `from err`.\n", "\n", "
" ], "id": "parse-task" }, { "cell_type": "code", "metadata": {}, "source": [ "class OrderFormatError(ShopError):\n", " pass\n", "\n", "\n", "def parse_qty(text):\n", " ..." ], "execution_count": null, "outputs": [], "id": "parse" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 4 — выполните после своего решения\n", "def test_ok():\n", " \"x2 → 2\"\n", " got = parse_qty(\"x2\")\n", " assert got == 2, f\"parse_qty(\\\"x2\\\") = {got!r}, а нужно 2\"\n", " assert parse_qty(\"x12\") == 12, \"parse_qty(\\\"x12\\\") должно быть 12\"\n", "\n", "\n", "def test_error():\n", " \"неверное число — OrderFormatError от ValueError\"\n", " try:\n", " parse_qty(\"x два\")\n", " except OrderFormatError as e:\n", " assert str(e) == \"неверное количество: x два\", f\"сообщение {str(e)!r}\"\n", " assert isinstance(e.__cause__, ValueError), \"у OrderFormatError нет причины — выбросите его через raise … from err\"\n", " except ValueError:\n", " assert False, \"parse_qty выбросил ValueError — перехватите его и выбросите OrderFormatError\"\n", " else:\n", " assert False, \"parse_qty(\\\"x два\\\") не выбросил исключение\"\n", "\n", "_check(test_ok, test_error)" ], "execution_count": null, "outputs": [], "id": "parse-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "class OrderFormatError(ShopError):\n", " pass\n", "\n", "\n", "def parse_qty(text):\n", " try:\n", " return int(text[1:])\n", " except ValueError as err:\n", " raise OrderFormatError(f\"неверное количество: {text}\") from err\n", "```\n", "\n", "
" ], "id": "parse-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Вопрос.** `OutOfStockError` — подкласс `ShopError`. Какой блок сработает?\n", "\n", "```python\n", "try:\n", " sell(stock, \"Сироп\", 10)\n", "except ShopError:\n", " print(\"ошибка кассы\")\n", "except OutOfStockError:\n", " print(\"нет товара\")\n", "```\n", "\n", "- `ошибка кассы`\n", "- `нет товара`\n", "- оба по очереди\n", "\n", "
Ответ\n", "\n", "`ошибка кассы`\n", "\n", "`except` проверяются сверху вниз, и срабатывает первый подходящий. `OutOfStockError` — это и `ShopError`, поэтому сработал первый блок; второй тут не сработает никогда. Конкретные исключения ставят выше общих.\n", "\n", "
" ], "id": "quiz-89" } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "name": "python" }, "colab": { "provenance": [] } }, "nbformat": 4, "nbformat_minor": 5 }