{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Всё в Python — объект\n",
    "\n",
    "У каждого значения есть тип — класс, который определяет, что значение умеет. type, isinstance и методы строк и списков как поведение объекта.\n",
    "\n",
    "Курс ООП в Python · урок `oop-objects` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/oop/objects).\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",
    "Число `150`, строка `\"латте\"`, список заказов, словарь меню — всё это **объекты** (object). У каждого\n",
    "объекта есть **тип**, и тип определяет, что объект умеет.\n",
    "\n",
    "## Тип объекта\n",
    "\n",
    "Встроенная функция `type` возвращает тип значения. В выводе тип выглядит как `<class 'int'>`: тип\n",
    "в Python и есть **класс** (class), а само значение — **экземпляр** (instance) этого класса. `150` — экземпляр\n",
    "класса `int`, `\"латте\"` — экземпляр класса `str`."
   ],
   "id": "text-9"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Типы знакомых значений\n",
    "print(type(150))\n",
    "print(type(2.5))\n",
    "print(type(\"латте\"))\n",
    "print(type([\"чай\", \"раф\"]))\n",
    "print(type({\"чай\": 120}))"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "types"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Классы — это «чертежи», а экземпляры — сделанные по ним вещи. Экземпляров одного класса может быть сколько\n",
    "угодно: `150`, `220` и `-3` — разные экземпляры `int`, но устроены одинаково.\n",
    "\n",
    "## Тип определяет поведение\n",
    "\n",
    "Объект — это не только данные, но и **поведение**: что с ним можно сделать. Поведение записано в классе\n",
    "в виде **методов** (method) — функций, которые вызываются через точку. У строки есть `upper` и `split`,\n",
    "у списка — `append` и `sort`:"
   ],
   "id": "text-21"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Методы строки и списка\n",
    "name = \"латте\"\n",
    "print(name.upper())\n",
    "print(\"чай, раф, какао\".split(\", \"))\n",
    "\n",
    "order = [\"чай\", \"раф\"]\n",
    "order.append(\"какао\")\n",
    "print(order)"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "methods"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Метод берёт данные у того объекта, у которого его вызвали: `\"латте\".upper()` работает со строкой\n",
    "`\"латте\"`, а `order.append(...)` меняет именно список `order`. Методы другого класса у объекта не появятся:"
   ],
   "id": "text-32"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# У строки нет append\n",
    "# Эта ячейка показывает ошибку AttributeError: она перехвачена, чтобы «Выполнить всё» не останавливалось.\n",
    "try:\n",
    "    name.append(\"со льдом\")\n",
    "except Exception as error:\n",
    "    print(f\"{type(error).__name__}: {error}\")"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "no-method"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Типичная ошибка: AttributeError: 'str' object has no attribute 'append'.**\n",
    ">\n",
    "> **Атрибутом** (attribute) называют всё, что достают у объекта через точку, — и методы, и данные; подробнее\n",
    "> об атрибутах — в уроке о первом классе. Такая ошибка значит: у объекта этого класса нет такого атрибута или\n",
    "> метода. Проверьте, тот ли объект\n",
    "> у вас в переменной: часто вместо списка там оказалась строка (например, после `input()` или чтения файла)."
   ],
   "id": "component-38"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Имя класса\n",
    "\n",
    "У класса есть атрибут `__name__` — его имя строкой. `type(value).__name__` удобно печатать в сообщениях:\n",
    "это короче, чем `<class 'int'>`."
   ],
   "id": "text-44"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Имя класса строкой\n",
    "price = 220\n",
    "print(type(price).__name__)\n",
    "print(f\"price — это {type(price).__name__}\")"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "type-name"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 1. Что лежит в списке\n",
    "\n",
    "В списке `values` — значения разных типов. Сохраните в `kinds` список имён их классов по порядку:\n",
    "`[\"int\", \"str\", …]`.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Для одного значения имя класса — `type(v).__name__`; для всех — генератор списка.\n",
    "\n",
    "</details>"
   ],
   "id": "kinds-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "values = [150, \"латте\", 2.5, [\"чай\"], {\"раф\": 260}, True]\n",
    "kinds = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "kinds"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 1 — выполните после своего решения\n",
    "def test_kinds():\n",
    "    \"kinds — имена классов значений по порядку\"\n",
    "    assert isinstance(kinds, list), f\"kinds — это {type(kinds).__name__}, а нужен список строк\"\n",
    "    assert len(kinds) == 6, f\"в kinds {len(kinds)} элементов, а значений в values 6\"\n",
    "    assert all(isinstance(k, str) for k in kinds), \"в kinds должны быть имена классов строками: type(v).__name__, а не сам type(v)\"\n",
    "    assert not kinds[0].startswith(\"<class\"), f\"в kinds {kinds[0]!r} — это текст всего класса; нужно только имя: type(v).__name__\"\n",
    "    assert kinds == [\"int\", \"str\", \"float\", \"list\", \"dict\", \"bool\"], f\"в kinds {kinds}\"\n",
    "\n",
    "_check(test_kinds, names=[\"kinds\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "kinds-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "values = [150, \"латте\", 2.5, [\"чай\"], {\"раф\": 260}, True]\n",
    "kinds = [type(v).__name__ for v in values]\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "kinds-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Проверка типа: isinstance\n",
    "\n",
    "Чтобы проверить, экземпляр ли значение нужного класса, есть `isinstance(значение, класс)`: он возвращает\n",
    "`True` или `False`. Вторым аргументом можно передать кортеж классов — тогда подходит любой из них:"
   ],
   "id": "text-58"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# isinstance с одним классом и с кортежем\n",
    "print(isinstance(150, int))\n",
    "print(isinstance(\"150\", int))\n",
    "print(isinstance(2.5, (int, float)))"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "isinstance"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 2. Только числа\n",
    "\n",
    "В список `raw` попали цены из разных источников: числа вперемешку со строками и `None`. Сохраните в `prices`\n",
    "только числа — и целые, и дробные, — в том же порядке.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "`isinstance(v, (int, float))` — `True` для целых и дробных чисел.\n",
    "\n",
    "</details>"
   ],
   "id": "numbers-only-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "raw = [150, \"200\", 90.5, None, 120, \"нет цены\", 300.0]\n",
    "prices = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "numbers-only"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 2 — выполните после своего решения\n",
    "def test_prices():\n",
    "    \"prices — только числа из raw\"\n",
    "    assert isinstance(prices, list), f\"prices — это {type(prices).__name__}, а нужен список\"\n",
    "    assert \"200\" not in prices, \"в prices попала строка \\\"200\\\": она похожа на число, но это str\"\n",
    "    assert 90.5 in prices, \"в prices нет 90.5 — дробные числа (float) тоже нужны\"\n",
    "    assert prices == [150, 90.5, 120, 300.0], f\"в prices {prices}, а чисел в raw четыре: 150, 90.5, 120, 300.0\"\n",
    "\n",
    "_check(test_prices, names=[\"prices\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "numbers-only-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "raw = [150, \"200\", 90.5, None, 120, \"нет цены\", 300.0]\n",
    "prices = [v for v in raw if isinstance(v, (int, float))]\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "numbers-only-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Типичная ошибка: type(v) == int вместо isinstance.**\n",
    ">\n",
    "> Сравнение `type(v) == int` пропустит дробные числа (их класс `float`), а позже в курсе — и экземпляры\n",
    "> классов, построенных на основе другого. `isinstance` отвечает на вопрос «подходит ли значение», и проверку\n",
    "> типа пишут через него."
   ],
   "id": "component-73"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Вопрос.** Что вернёт `isinstance(True, int)`?\n",
    "\n",
    "- `True`\n",
    "- `False`\n",
    "- ошибку `TypeError`\n",
    "\n",
    "<details><summary>Ответ</summary>\n",
    "\n",
    "`True`\n",
    "\n",
    "Класс `bool` построен на основе `int`: `True` ведёт себя как 1, а `False` — как 0, поэтому `True + True` равно 2. Для `isinstance` логическое значение — тоже целое число. Как один класс строится на основе другого, разберём в модуле о наследовании.\n",
    "\n",
    "</details>"
   ],
   "id": "quiz-79"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Классы — тоже объекты\n",
    "\n",
    "Раз всё в Python — объект, то и сам класс — объект. Его можно положить в переменную или список, передать\n",
    "в функцию. А раз класс — объект, у него тоже есть тип: классы — экземпляры класса `type`, поэтому\n",
    "`type(int)` — это `type`:"
   ],
   "id": "text-88"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Класс в переменной\n",
    "kind = int\n",
    "print(kind(\"42\") + 1)\n",
    "print(type(int))\n",
    "print([c.__name__ for c in [int, str, list]])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "classes"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 3. Описание значения\n",
    "\n",
    "Напишите функцию `describe(value)`, которая возвращает строку вида `\"int: 150\"` — имя класса значения,\n",
    "двоеточие и само значение. Например, `describe(\"латте\")` — это `\"str: латте\"`.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Имя класса — `type(value).__name__`; строку удобно собрать f-строкой.\n",
    "\n",
    "</details>"
   ],
   "id": "describe-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "def describe(value):\n",
    "    ...  # \"имя класса: значение\""
   ],
   "execution_count": null,
   "outputs": [],
   "id": "describe"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 3 — выполните после своего решения\n",
    "def test_number():\n",
    "    \"describe(150) = \\\"int: 150\\\"\"\n",
    "    got = describe(150)\n",
    "    assert got is not None, \"функция ничего не возвращает — не забудьте return\"\n",
    "    assert isinstance(got, str), f\"функция вернула {type(got).__name__}, а нужна строка\"\n",
    "    assert \"class\" not in got, f\"получилось {got!r}: нужно имя класса type(value).__name__, а не сам класс\"\n",
    "    assert got == \"int: 150\", f\"describe(150) вернула {got!r}, а нужно \\\"int: 150\\\"\"\n",
    "\n",
    "\n",
    "def test_others():\n",
    "    \"describe(\\\"латте\\\") и describe([1, 2])\"\n",
    "    assert describe(\"латте\") == \"str: латте\", f\"describe(\\\"латте\\\") вернула {describe('латте')!r}\"\n",
    "    assert describe([1, 2]) == \"list: [1, 2]\", f\"describe([1, 2]) вернула {describe([1, 2])!r}\"\n",
    "\n",
    "_check(test_number, test_others)"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "describe-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "def describe(value):\n",
    "    return f\"{type(value).__name__}: {value}\"\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "describe-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Итак, у любого значения есть класс, а класс задаёт данные и поведение его экземпляров. В следующем уроке\n",
    "вы объявите свой первый класс — для товара кофейни."
   ],
   "id": "text-103"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python"
  },
  "colab": {
   "provenance": []
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}