{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Сеттер и проверка значений\n", "\n", "@x.setter разрешает запись в свойство и проверяет значение: неверное — raise ValueError. Проверка в __init__ через свойство и рекурсия в сеттере.\n", "\n", "Курс ООП в Python · урок `oop-setter` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/oop/setter).\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": [ "Свойство только для чтения не даёт изменить атрибут через публичный интерфейс. Но цену товара менять нужно — просто не на любое\n", "значение: отрицательная цена — ошибка в программе, и лучше узнать о ней сразу. Для этого у свойства бывает\n", "вторая половина — **сеттер** (setter): метод, который вызывается при *записи* в свойство.\n", "\n", "## Сеттер\n", "\n", "Сеттер объявляется вторым методом с тем же именем и декоратором `@имя.setter`. Он получает новое значение,\n", "проверяет его и записывает во внутренний атрибут:" ], "id": "text-9" }, { "cell_type": "code", "metadata": {}, "source": [ "# Объём с проверкой\n", "class Cup:\n", " def __init__(self, volume):\n", " self._volume = volume\n", "\n", " @property\n", " def volume(self):\n", " return self._volume\n", "\n", " @volume.setter\n", " def volume(self, value):\n", " print(f\"сеттер получил {value}\")\n", " if value < 50:\n", " print(\"слишком мало — объём не изменён\")\n", " return\n", " self._volume = value\n", "\n", "\n", "cup = Cup(300)\n", "cup.volume = 400 # вызывается сеттер\n", "print(cup.volume)\n", "cup.volume = 10\n", "print(cup.volume)" ], "execution_count": null, "outputs": [], "id": "setter" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## raise: сообщить об ошибке\n", "\n", "Что делать, если значение неверное? Молча проигнорировать — плохо: программа продолжит работать с неверными\n", "данными, и ошибка всплывёт далеко отсюда. Правильно — **выбросить исключение** (raise) — так же, как это\n", "делает Python, когда вы пишете `int(\"сто\")`:" ], "id": "text-20" }, { "cell_type": "code", "metadata": {}, "source": [ "# Неверный объём — ValueError\n", "# Эта ячейка показывает ошибку ValueError: она перехвачена, чтобы «Выполнить всё» не останавливалось.\n", "try:\n", " class Cup:\n", " def __init__(self, volume):\n", " self._volume = volume\n", "\n", " @property\n", " def volume(self):\n", " return self._volume\n", "\n", " @volume.setter\n", " def volume(self, value):\n", " if value < 50:\n", " raise ValueError(f\"объём {value} мл — меньше 50 мл не бывает\")\n", " self._volume = value\n", "\n", "\n", " cup = Cup(300)\n", " cup.volume = 10\n", "except Exception as error:\n", " print(f\"{type(error).__name__}: {error}\")" ], "execution_count": null, "outputs": [], "id": "raise" }, { "cell_type": "markdown", "metadata": {}, "source": [ "`raise ValueError(\"…\")` сразу прерывает метод: строки ниже не выполняются, атрибут не меняется, а вызвавший\n", "код получает исключение. `ValueError` — встроенное исключение для «значение подходящего типа, но\n", "недопустимое». Сообщение пишут так, чтобы было понятно, что исправить.\n", "\n", "Вызывающий код может перехватить исключение в `try/except` и решить, что делать дальше. Запись\n", "`except ValueError as error` даёт перехваченному исключению имя: `str(error)` — его сообщение." ], "id": "text-28" }, { "cell_type": "code", "metadata": {}, "source": [ "# Перехватить ValueError\n", "try:\n", " cup.volume = 10\n", " print(\"записали\") # не выполнится\n", "except ValueError as error:\n", " print(\"не получилось:\", error)\n", "print(cup.volume)" ], "execution_count": null, "outputs": [], "id": "catch" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 1. Цена с проверкой\n", "\n", "Допишите класс `Product`: свойство `price` возвращает `_price`, а сеттер записывает новую цену, если она больше\n", "нуля, иначе выбрасывает `ValueError` с сообщением `\"цена должна быть больше нуля\"`. Неудачная попытка не меняет\n", "старую цену.\n", "\n", "
Подсказка 1\n", "\n", "Сеттер: `@price.setter`, затем `def price(self, value):`. Внутри — `if value <= 0: raise ValueError(...)` и после проверки `self._price = value`.\n", "\n", "
" ], "id": "price-task" }, { "cell_type": "code", "metadata": {}, "source": [ "class Product:\n", " def __init__(self, name, price):\n", " self.name = name\n", " self.price = price # запись через свойство: сработает сеттер\n", "\n", " @property\n", " def price(self):\n", " ...\n", "\n", " @price.setter\n", " def price(self, value):\n", " ..." ], "execution_count": null, "outputs": [], "id": "price" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 1 — выполните после своего решения\n", "def _product(name, price):\n", " \"создаёт Product; запись в self.price внутри сеттера даёт бесконечную рекурсию — понятное сообщение\"\n", " try:\n", " return Product(name, price)\n", " except RecursionError:\n", " assert False, \"сеттер вызывает сам себя: внутри него запись идёт в self.price — пишите в self._price\"\n", "\n", "\n", "def _raises_value_error(action):\n", " \"True, если action() выбросил ValueError\"\n", " try:\n", " action()\n", " except ValueError:\n", " return True\n", " except RecursionError:\n", " assert False, \"сеттер вызывает сам себя: внутри него запись идёт в self.price — пишите в self._price\"\n", " return False\n", "\n", "\n", "def test_property():\n", " \"price — свойство с сеттером\"\n", " prop = Product.__dict__.get(\"price\")\n", " assert isinstance(prop, property), \"price должен быть свойством: @property над геттером\"\n", " assert prop.fset is not None, \"у свойства нет сеттера — объявите второй метод price с декоратором @price.setter\"\n", "\n", "\n", "def test_valid():\n", " \"верная цена записывается\"\n", " p = _product(\"Латте\", 220)\n", " assert p.price == 220, f\"у Product(\\\"Латте\\\", 220) price = {p.price!r}, а нужно 220\"\n", " p.price = 250\n", " assert p.price == 250, f\"после p.price = 250 цена {p.price!r}\"\n", "\n", "\n", "def test_invalid():\n", " \"цена 0 и меньше — ValueError, старая цена на месте\"\n", " p = _product(\"Латте\", 220)\n", " for bad in [0, -50]:\n", " def assign(bad=bad):\n", " p.price = bad\n", " assert _raises_value_error(assign), f\"p.price = {bad} не выбросил ValueError — проверьте значение в сеттере: raise ValueError(…)\"\n", " assert p.price == 220, f\"после неудачной записи {bad} цена стала {p.price!r} — сначала проверка, потом запись\"\n", "\n", "\n", "def test_init():\n", " \"Product с неверной ценой не создаётся\"\n", " assert _raises_value_error(lambda: Product(\"Чай\", -5)), \"Product(\\\"Чай\\\", -5) создался — в __init__ запись должна идти через свойство: self.price = price\"\n", "\n", "_check(test_property, test_valid, test_invalid, test_init, names=[\"Product.price\"])" ], "execution_count": null, "outputs": [], "id": "price-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", " @property\n", " def price(self):\n", " return self._price\n", "\n", " @price.setter\n", " def price(self, value):\n", " if value <= 0:\n", " raise ValueError(\"цена должна быть больше нуля\")\n", " self._price = value\n", "```\n", "\n", "
" ], "id": "price-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Типичная ошибка: рекурсия в сеттере.**\n", ">\n", "> Внутри сеттера легко написать `self.price = value` вместо `self._price = value`:\n", ">\n", "> ```python\n", "> @price.setter\n", "> def price(self, value):\n", "> if value <= 0:\n", "> raise ValueError(\"цена должна быть больше нуля\")\n", "> self.price = value # ошибка: это снова вызов сеттера\n", "> ```\n", ">\n", "> Запись в `self.price` — это снова вызов сеттера, который снова пишет в `self.price`… Метод вызывает сам себя\n", "> без конца, пока Python не остановит его ошибкой `RecursionError: maximum recursion depth exceeded` (в браузере\n", "> вместо неё Python может просто перезапуститься — стек там меньше). Внутри геттера и сеттера всегда работайте\n", "> с внутренним атрибутом `_price`." ], "id": "component-46" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Проверка при создании\n", "\n", "Сеттер срабатывает при любой записи в свойство — и в `__init__` тоже. Если в `__init__` написать\n", "`self.volume = volume` (без подчёркивания), неверный экземпляр просто не создастся:" ], "id": "text-62" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка в __init__ через свойство\n", "# Эта ячейка показывает ошибку ValueError: она перехвачена, чтобы «Выполнить всё» не останавливалось.\n", "try:\n", " class Cup:\n", " def __init__(self, volume):\n", " self.volume = volume # через свойство — с проверкой\n", "\n", " @property\n", " def volume(self):\n", " return self._volume\n", "\n", " @volume.setter\n", " def volume(self, value):\n", " if value < 50:\n", " raise ValueError(f\"объём {value} мл — меньше 50 мл не бывает\")\n", " self._volume = value\n", "\n", "\n", " tiny = Cup(20)\n", "except Exception as error:\n", " print(f\"{type(error).__name__}: {error}\")" ], "execution_count": null, "outputs": [], "id": "init-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Вопрос.** В `__init__` класса с сеттером цены написано `self._price = price`. Что будет при `Product(\"Чай\", -5)`?\n", "\n", "- экземпляр создастся с ценой -5\n", "- `ValueError`: сеттер проверит цену\n", "- `AttributeError`: у свойства нет такого атрибута\n", "\n", "
Ответ\n", "\n", "экземпляр создастся с ценой -5\n", "\n", "Запись в `_price` — это запись в обычный атрибут, сеттер `price` при этом не вызывается. Чтобы проверка работала и при создании, `__init__` должен писать в свойство: `self.price = price`.\n", "\n", "
" ], "id": "quiz-70" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 2. Оценка в отзыве\n", "\n", "Объявите класс `Review`: `Review(\"Анна\", 5)` хранит имя автора в атрибуте `author` и оценку в свойстве `stars`.\n", "Оценка — число от 1 до 5; число вне этого диапазона — и при создании, и при изменении — выбрасывает\n", "`ValueError`.\n", "\n", "
Подсказка 1\n", "\n", "В `__init__`: `self.stars = stars` — запись через свойство, чтобы сработала проверка.\n", "\n", "
\n", "
Подсказка 2\n", "\n", "В сеттере проверьте обе границы — и меньше 1, и больше 5 — и только потом записывайте `_stars`.\n", "\n", "
" ], "id": "review-task" }, { "cell_type": "code", "metadata": {}, "source": [ "class Review:\n", " def __init__(self, author, stars):\n", " ..." ], "execution_count": null, "outputs": [], "id": "review" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 2 — выполните после своего решения\n", "def _value_error(action):\n", " try:\n", " action()\n", " except ValueError:\n", " return True\n", " return False\n", "\n", "\n", "def test_valid():\n", " \"Review(\\\"Анна\\\", 5) — автор и оценка\"\n", " r = Review(\"Анна\", 5)\n", " assert getattr(r, \"author\", None) == \"Анна\", \"у отзыва должен быть атрибут author с именем автора\"\n", " assert getattr(r, \"stars\", None) == 5, \"у Review(\\\"Анна\\\", 5) stars должно быть 5\"\n", "\n", "\n", "def test_is_property():\n", " \"stars — свойство с сеттером\"\n", " prop = Review.__dict__.get(\"stars\")\n", " assert isinstance(prop, property), \"stars должен быть свойством: @property и @stars.setter\"\n", " assert prop.fset is not None, \"у свойства stars нет сеттера — объявите @stars.setter\"\n", "\n", "\n", "def test_create_invalid():\n", " \"неверная оценка при создании — ValueError\"\n", " for bad in [0, 6, -1]:\n", " assert _value_error(lambda bad=bad: Review(\"Анна\", bad)), f\"Review(\\\"Анна\\\", {bad}) создался — в __init__ пишите через свойство: self.stars = stars\"\n", "\n", "\n", "def test_change():\n", " \"изменить оценку можно, неверную — нельзя\"\n", " r = Review(\"Анна\", 4)\n", " r.stars = 5\n", " assert r.stars == 5, \"оценку 5 должно быть можно записать\"\n", "\n", " def bad():\n", " r.stars = 10\n", " assert _value_error(bad), \"r.stars = 10 не выбросил ValueError\"\n", " assert r.stars == 5, \"после неудачной записи оценка не должна меняться\"\n", "\n", "_check(test_valid, test_is_property, test_create_invalid, test_change, names=[\"Review.__init__\"])" ], "execution_count": null, "outputs": [], "id": "review-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "class Review:\n", " def __init__(self, author, stars):\n", " self.author = author\n", " self.stars = stars\n", "\n", " @property\n", " def stars(self):\n", " return self._stars\n", "\n", " @stars.setter\n", " def stars(self, value):\n", " if value < 1 or value > 5:\n", " raise ValueError(\"оценка — от 1 до 5\")\n", " self._stars = value\n", "```\n", "\n", "
" ], "id": "review-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Неверные данные на входе\n", "\n", "Проверки в сеттерах особенно полезны, когда данные приходят извне — из файла или формы. Объект сам не даст\n", "создать себя с ошибкой, а программа перехватит исключение и пропустит плохую строку." ], "id": "text-88" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 3. Загрузка прайса\n", "\n", "В `rows` — строки прайса «название, цена», среди них есть ошибочные. Создайте список `products` из\n", "экземпляров `Product` (из упражнения про цену) для верных строк, а в `skipped` сохраните названия\n", "пропущенных — тех, где `Product(...)` выбросил `ValueError`.\n", "\n", "
Подсказка 1\n", "\n", "В цикле: `try:` — создать товар и добавить в `products`; `except ValueError:` — добавить название в `skipped`.\n", "\n", "
" ], "id": "import-task" }, { "cell_type": "code", "metadata": {}, "source": [ "rows = [(\"Эспрессо\", 150), (\"Капучино\", -220), (\"Чай\", 120), (\"Раф\", 0), (\"Какао\", 190)]\n", "products = ...\n", "skipped = ..." ], "execution_count": null, "outputs": [], "id": "import" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 3 — выполните после своего решения\n", "def test_products():\n", " \"products — товары из верных строк\"\n", " assert isinstance(products, list), f\"products — это {type(products).__name__}, а нужен список\"\n", " assert all(isinstance(p, Product) for p in products), \"в products должны быть экземпляры Product\"\n", " names = [p.name for p in products]\n", " assert names == [\"Эспрессо\", \"Чай\", \"Какао\"], f\"в products {names}, а верные строки — эспрессо, чай и какао\"\n", "\n", "\n", "def test_skipped():\n", " \"skipped — названия ошибочных строк\"\n", " assert isinstance(skipped, list), f\"skipped — это {type(skipped).__name__}, а нужен список названий\"\n", " assert skipped == [\"Капучино\", \"Раф\"], f\"skipped = {skipped}, а ошибочные строки — капучино (-220) и раф (0)\"\n", "\n", "_check(test_products, test_skipped, names=[\"products\",\"skipped\"])" ], "execution_count": null, "outputs": [], "id": "import-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "rows = [(\"Эспрессо\", 150), (\"Капучино\", -220), (\"Чай\", 120), (\"Раф\", 0), (\"Какао\", 190)]\n", "products = []\n", "skipped = []\n", "for name, price in rows:\n", " try:\n", " products.append(Product(name, price))\n", " except ValueError:\n", " skipped.append(name)\n", "```\n", "\n", "
" ], "id": "import-solution" } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "name": "python" }, "colab": { "provenance": [] } }, "nbformat": 4, "nbformat_minor": 5 }