{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python-минимум\n",
    "\n",
    "Самопроверка перед курсом — словари, циклы, генераторы списков, функции и try/except. Если всё решается легко, вы готовы.\n",
    "\n",
    "Курс ООП в Python · урок `oop-python-minimum` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/oop/python-minimum).\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": [
    "Курс рассчитан на тех, кто уже пишет простые программы на Python: с переменными, списками, словарями, циклами\n",
    "и функциями. Этот урок — не объяснение, а **самопроверка**: пять коротких упражнений на то, что понадобится\n",
    "дальше. Если они решаются за пару минут — смело идите к следующему уроку. Если какое-то не получается, в конце\n",
    "урока есть ссылки, что повторить.\n",
    "\n",
    "Заодно познакомьтесь с устройством уроков. Серые блоки — **ячейки кода**: нажмите «Выполнить», и код выполнится\n",
    "прямо в браузере. Под ячейкой виден сохранённый вывод — так он выглядел, когда урок писали; после запуска\n",
    "появится ваш. Код можно изменить кнопкой «Изменить» и вернуть обратно. Все ячейки урока работают в одной\n",
    "программе: переменная из одной ячейки видна в следующих — как в Jupyter-ноутбуке.\n",
    "\n",
    "Весь курс построен вокруг одного примера — кассы «Кофейной лавки». Сейчас меню — обычный словарь, а к концу\n",
    "курса касса станет программой из нескольких классов: товары, корзина, скидки, оплата, склад и чек.\n",
    "\n",
    "## Словари и циклы\n",
    "\n",
    "Словарь хранит пары «ключ → значение», а цикл `for` по `items()` перебирает пары целиком:"
   ],
   "id": "text-9"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Меню — словарь\n",
    "menu = {\"эспрессо\": 150, \"капучино\": 220, \"чай\": 120, \"раф\": 260, \"какао\": 190}\n",
    "for name, price in menu.items():\n",
    "    print(f\"{name}: {price} ₽\")\n",
    "print(\"позиций в меню:\", len(menu))"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "menu"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 1. Сколько стоит всё меню\n",
    "\n",
    "Посчитайте, сколько стоит взять по одной позиции каждого напитка из словаря `menu`, и сохраните сумму\n",
    "в `total`.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Значения словаря — `menu.values()`; сложить их можно встроенной `sum` или циклом.\n",
    "\n",
    "</details>"
   ],
   "id": "menu-total-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "total = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "menu-total"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 1 — выполните после своего решения\n",
    "def test_total():\n",
    "    \"total — стоимость всех напитков меню\"\n",
    "    assert total != 5, \"5 — это число позиций, а нужна сумма цен: сложите значения словаря\"\n",
    "    assert total == 940, f\"total = {total!r}, а сумма цен меню — 940 ₽\"\n",
    "\n",
    "_check(test_total, names=[\"total\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "menu-total-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "total = sum(menu.values())\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "menu-total-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Генераторы списков\n",
    "\n",
    "Генератор списка (list comprehension) строит новый список из старого одной строкой — выражение, `for` и при\n",
    "желании `if`:"
   ],
   "id": "text-35"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Новый список из старого\n",
    "volumes = [250, 300, 400]\n",
    "print([v * 2 for v in volumes])\n",
    "print([v for v in volumes if v > 280])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "comprehension"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 2. Недорогие напитки\n",
    "\n",
    "Сохраните в `cheap` список названий напитков из `menu`, которые стоят меньше 200 ₽, — в том порядке, в каком\n",
    "они записаны в словаре.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "`[name for name, price in menu.items() if ...]` — пары из словаря и условие на цену.\n",
    "\n",
    "</details>"
   ],
   "id": "cheap-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "cheap = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "cheap"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 2 — выполните после своего решения\n",
    "def test_cheap():\n",
    "    \"cheap — названия напитков дешевле 200 ₽\"\n",
    "    assert isinstance(cheap, list), f\"cheap — это {type(cheap).__name__}, а нужен список названий\"\n",
    "    assert cheap != [150, 120, 190], \"в списке цены, а нужны названия напитков\"\n",
    "    assert \"какао\" in cheap, \"какао стоит 190 ₽ — меньше 200, его тоже нужно взять\"\n",
    "    assert cheap == [\"эспрессо\", \"чай\", \"какао\"], f\"в cheap {cheap}, а дешевле 200 ₽ — эспрессо, чай и какао\"\n",
    "\n",
    "_check(test_cheap, names=[\"cheap\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "cheap-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "cheap = [name for name, price in menu.items() if price < 200]\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "cheap-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Функции\n",
    "\n",
    "Функция получает аргументы и возвращает результат через `return`. У параметра может быть значение по\n",
    "умолчанию — тогда аргумент можно не передавать:"
   ],
   "id": "text-49"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Функция со значением по умолчанию\n",
    "def per_cup(price, cups=1):\n",
    "    return price / cups\n",
    "\n",
    "\n",
    "print(per_cup(300))\n",
    "print(per_cup(300, 4))"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "functions"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 3. Чаевые\n",
    "\n",
    "Напишите функцию `with_tip(amount, percent=10)`: она возвращает сумму вместе с чаевыми, округлённую до целых\n",
    "рублей встроенной `round`. Например, `with_tip(500)` — это 550, а `with_tip(480, 5)` — 504.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Чаевые — `amount * percent / 100`; вернуть нужно `round(amount + чаевые)`.\n",
    "\n",
    "</details>"
   ],
   "id": "with-tip-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "def with_tip(amount, percent=10):\n",
    "    ...  # верните сумму с чаевыми"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "with-tip"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 3 — выполните после своего решения\n",
    "def test_default():\n",
    "    \"with_tip(500) = 550 — по умолчанию 10 %\"\n",
    "    try:\n",
    "        got = with_tip(500)\n",
    "    except TypeError:\n",
    "        assert False, \"with_tip(500) не вызывается с одним аргументом — дайте параметру percent значение по умолчанию 10\"\n",
    "    assert got is not None, \"функция ничего не возвращает — не забудьте return\"\n",
    "    assert got != 50, \"50 — это только чаевые, а нужна сумма вместе с ними\"\n",
    "    assert got == 550, f\"with_tip(500) вернула {got!r}, а нужно 550\"\n",
    "\n",
    "\n",
    "def test_percent():\n",
    "    \"with_tip(480, 5) = 504, with_tip(333, 15) = 383\"\n",
    "    got = with_tip(480, 5)\n",
    "    assert got == 504, f\"with_tip(480, 5) вернула {got!r}, а нужно 504\"\n",
    "    got = with_tip(333, 15)\n",
    "    assert got == 383, f\"with_tip(333, 15) вернула {got!r}, а нужно 383 — округлите итог функцией round\"\n",
    "\n",
    "_check(test_default, test_percent)"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "with-tip-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "def with_tip(amount, percent=10):\n",
    "    return round(amount + amount * percent / 100)\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "with-tip-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Словарь-счётчик\n",
    "\n",
    "Частая задача — посчитать, сколько раз встречается каждое значение. Метод словаря `get` возвращает значение по\n",
    "ключу, а если ключа нет — значение по умолчанию:"
   ],
   "id": "text-63"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# get со значением по умолчанию\n",
    "stock = {\"зёрна\": 12, \"молоко\": 4}\n",
    "print(stock.get(\"молоко\", 0))\n",
    "print(stock.get(\"сливки\", 0))"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "counter"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 4. Что заказывают\n",
    "\n",
    "В списке `orders` — напитки по порядку заказов за утро. Соберите словарь `counts`: напиток → сколько раз его\n",
    "заказали.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Начните с пустого словаря и в цикле увеличивайте `counts[drink]` на единицу; `counts.get(drink, 0)` вернёт 0 для нового напитка.\n",
    "\n",
    "</details>"
   ],
   "id": "count-orders-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "orders = [\"капучино\", \"чай\", \"капучино\", \"раф\", \"чай\", \"капучино\"]\n",
    "counts = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "count-orders"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 4 — выполните после своего решения\n",
    "def test_counts():\n",
    "    \"counts — сколько раз заказали каждый напиток\"\n",
    "    assert isinstance(counts, dict), f\"counts — это {type(counts).__name__}, а нужен словарь\"\n",
    "    assert counts.get(\"капучино\") != 1, \"у капучино 1, а его заказали трижды — увеличивайте счётчик, а не записывайте 1\"\n",
    "    assert counts == {\"капучино\": 3, \"чай\": 2, \"раф\": 1}, f\"в counts {counts}, а нужно капучино — 3, чай — 2, раф — 1\"\n",
    "\n",
    "_check(test_counts, names=[\"counts\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "count-orders-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "orders = [\"капучино\", \"чай\", \"капучино\", \"раф\", \"чай\", \"капучино\"]\n",
    "counts = {}\n",
    "for drink in orders:\n",
    "    counts[drink] = counts.get(drink, 0) + 1\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "count-orders-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Исключения: try и except\n",
    "\n",
    "Если операция невозможна, Python выбрасывает исключение — например, `int(\"сто\")` даёт `ValueError`.\n",
    "Блок `try/except` перехватывает его, и программа продолжает работу:"
   ],
   "id": "text-77"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Перехватить ValueError\n",
    "for text in [\"3\", \"три\"]:\n",
    "    try:\n",
    "        print(int(text) * 2)\n",
    "    except ValueError:\n",
    "        print(f\"не число: {text}\")"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "try-except"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 5. Цена из строки\n",
    "\n",
    "Напишите функцию `parse_price(text)`: если строка — целое число (`\"250\"`), функция возвращает его как `int`,\n",
    "а если нет (`\"бесплатно\"`, `\"\"`) — возвращает `None`.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Внутри `try` — `return int(text)`, в `except ValueError` — `return None`.\n",
    "\n",
    "</details>"
   ],
   "id": "parse-price-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "def parse_price(text):\n",
    "    ...  # число или None"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "parse-price"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 5 — выполните после своего решения\n",
    "def test_number():\n",
    "    \"parse_price(\\\"250\\\") = 250 — число, а не строка\"\n",
    "    got = parse_price(\"250\")\n",
    "    assert got != \"250\", \"функция вернула строку \\\"250\\\", а нужно число: int(text)\"\n",
    "    assert got == 250, f\"parse_price(\\\"250\\\") вернула {got!r}, а нужно 250\"\n",
    "\n",
    "\n",
    "def test_not_number():\n",
    "    \"parse_price(\\\"бесплатно\\\") и parse_price(\\\"\\\") — None\"\n",
    "    try:\n",
    "        a, b = parse_price(\"бесплатно\"), parse_price(\"\")\n",
    "    except ValueError:\n",
    "        assert False, \"int(\\\"бесплатно\\\") выбрасывает ValueError — перехватите его в try/except и верните None\"\n",
    "    assert a is None and b is None, f\"для нечисловых строк функция вернула {a!r} и {b!r}, а нужно None\"\n",
    "\n",
    "_check(test_number, test_not_number)"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "parse-price-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "def parse_price(text):\n",
    "    try:\n",
    "        return int(text)\n",
    "    except ValueError:\n",
    "        return None\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "parse-price-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Что повторить, если не получилось\n",
    "\n",
    "| Не получилось | Что повторить |\n",
    "| --- | --- |\n",
    "| словари и циклы | [Словари](https://docs.python.org/3/tutorial/datastructures.html#dictionaries), [for](https://docs.python.org/3/tutorial/controlflow.html#for-statements) |\n",
    "| генераторы списков | [List comprehensions](https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions) |\n",
    "| функции | [Как определить функцию](https://docs.python.org/3/tutorial/controlflow.html#defining-functions), [значения по умолчанию](https://docs.python.org/3/tutorial/controlflow.html#default-argument-values) |\n",
    "| try/except | [Обработка исключений](https://docs.python.org/3/tutorial/errors.html#handling-exceptions) |\n",
    "\n",
    "Всё решилось? Отлично — в следующем уроке посмотрим на знакомые значения по-новому: как на объекты."
   ],
   "id": "text-91"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python"
  },
  "colab": {
   "provenance": []
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}