{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Типы\n",
"\n",
"Почему числа читаются как текст и как это заметить; astype и pd.to_numeric с errors=\"coerce\"; целые числа с пропусками — тип Int64; что теряется при переводе дробных в целые.\n",
"\n",
"Курс pandas · урок `pd-types` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/pandas/types).\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",
"for _name, _min in {\"numpy\":\"2.0\",\"pandas\":\"3.0\"}.items():\n",
" try:\n",
" _have = __import__(_name).__version__\n",
" except ImportError:\n",
" print(f\"Нет пакета {_name}: выполните %pip install {_name} и перезапустите ядро\")\n",
" continue\n",
" if tuple(int(x) for x in _have.split(\".\")[:2]) < tuple(int(x) for x in _min.split(\".\")):\n",
" print(f\"Урок написан для {_name} {_min} и новее, у вас {_have}: выполните %pip install -U {_name} и перезапустите ядро\")\n",
"\n",
"_DATA = {\n",
" \"supplier_prices.csv\": \"\"\"\n",
"eNp9lF1O20AUhd9ZxSzggmbGP0l2wQ4qlEQVqtogCA99swlVKpEKov6AKFUpVKISlRp+XEISmy2cuwVWUl3baew05cEPY8397pl7\n",
"zszGZquxXW8/W2/Qq7WXTaqvtZvPW5uvaWNzvd6kemurTVvtVv0FbW801trNxtKqNsTvOMQDB4g45BDJMoeYpIueMgoj3CjCMRLe\n",
"RURGeb5Wjzsx1awmI5+3os2K1dZfWtU23YkxdzDBFYa8r6ynFW5mhEpe72pNvkvGKZQ7ImYXQyR4KBQX+ledvNrXRMYWal1CH6c4\n",
"wCGO8BlH+CXqj/G+KN6pZOVVL2vuFwDe340KV4hwJ2dP1xgixuC/J0GMiHcUbjFAjJj3+A15tfLJfFIKF9znQDbgXnEXA9wrozPm\n",
"haxoKs/4mox2ybgFRIVwiAhj7j+FcG2OqArClBFVwnlqTjxX5dWyKlvRVJ3rWyOccYABrnkfMRLpHOIKCQfKK0JsDjFGk3EqpQEY\n",
"LQP4gURmijEGuFW4EQb3MMIQ94Rv2X8kHPIOhmSmPC1eF6wyhvAVEXcRIeaeGJbgmsNcX7QAlVslQ3GqZWVWlJ2kHouDY+4pXCt+\n",
"W9S6iOl4s0lXbVmgk3olUebg30prnw5OIdbGJYw44A5+Y4SBkqaYYKxkAsLrSDX5duafTL9I8Ih35XYj5u7y7KLPEazS/nTcrqZy\n",
"fI0vGehwkGqQ1wG3ciV4fx4yDZJxrZhWZFTSKyBJQYwhRgp3EioMOEDC3SzUZZ5Rrsl4j8EH8ku5NFXh5XcRk9QpUSfDElqm7gAj\n",
"DrMDc0da8R45ys2ts9pokjwUuTXC9/QJ+YkznOJSoY9znOAAn/AFl/i4mGr9WVo9XTq61YQzRBykMgt2LiYZZfNXztfiZSmvfwDH\n",
"5s7A\n",
"\"\"\",\n",
" \"delivery_h1.csv\": \"\"\"\n",
"eNpFWTkOZTcOzH0WBeJOncYw0Magkxmgx4lvbzyJVY4+IelRFMni9v/368efv37/+WP9+OPv/69ff/z187//+U323rJ8XUKXL7+U\n",
"LV1xKV82VCxfdqlc9j4ofNlYOcseC9k4LgK2oitnzVbeD8TnS4lVSy+VK+ZU4VTPRXLW/dU9CyorHnPVFW/JsOdLHyMNiKAf83uN\n",
"Qnhtbg532yOUySwoRDLDA83xGPtEv0RyCcytV875s/QuObg7ZXeFstygb3euBe70JFU8B907LoiNvZA1hI4mg5YNB68IyBg5OowC\n",
"8XG/UsTBl7lXvbUUrul6ak0bcdKh1qTnZHKN8mdDjjy4q/Z6SyWrhtLRaNk6j6ABigqqHB1UcfOzwBWtDvTdG87Wgt1W3N6G97Xz\n",
"C76hcw1RuLV7tNUHfM/GS48s2Xf30MrHIN3x+fTESH4ScpwiN/j/+YzwsZW933nZMmLIHhXJtnFy2XAi2fEuEqBXLnrfhz3uLRe/\n",
"n1lEBmFC+IqME4nY3C3Qj0hgCS4qQK9Ic+mAl26sKeVXyK8GeS6ELxFrDiUO1bxDe5xQlOxtg4MNBMR0zpvx1ChfDMoxSm/UDiEs\n",
"Ru07zCsuw9bB3w1KcfD34FKufqbx4tpYVxzRUwLaD2r/QvhRAzEJqj8CbCMhY0BB0eRxBk6Se0RLGSsltJ8IQZLQfn7Wvewz8R31\n",
"kxOAJCcASUH6kjldXwC9PIvaL2ingptUfxVYUPgL32vTnggqLXDvVm5CO+3DouGbTfbErjSk7zPinA0NHkQfOTosDuK/HGRGOTEs\n",
"DnV/yP/0Enm757mwblygW7A0zqMXunEpJxUTEXTnvFeRenX3k0w31KOyvyvlkjJCquhIpDIKUhkFqSA9quQLriqFm6QhrcA9VSf4\n",
"qI6BVaF/VRhY1ed1GmChyJB60++VjPlXFSlGbTxITeYmQ3GixK8aVWSBY/lF2/t2q4mCaghAarzB9xoC8Uedb3CoyJHE1GMkYg5W\n",
"LzwLCFZHBNJAktQL4XtVoP7RsFtYaMCJNAKSRZLHIFgDRo4zK4kcr/lqFE2FNBfA95r02UP80URxpQkPyubmebFAC/YtKqfIvsj+\n",
"IvhRlP5C+FFUDzGshQiqjQiqLaQGZQoMa/vENW3e0BOClCDWRgLTPlDx2ZPZ9cvAg4dDEx+DJAeFkB4C7eCOgzCnp+FsB0a2jTrC\n",
"tpDSEdT2vMK2cylGO7ZzxDPmYdvwU9vQkwn8yASliolyDVcIHMkElYpJcq3WcIOiTJDpTafYMpWpl+2i+a1NMW060do0RsN2a+l3\n",
"CpWKaX/4eyRMYcY32PQahmxsRLMZahVDOjaDt5ohW5oh3ZsNGIzZ2Ahm80ln5ga2Th1dMD/qC3hvlzd4kzpTu1lMyrHgDYGIZIGM\n",
"acSzxWfpq4fI9b6knQMh1QIlryUqFmNRbanglkg7lvSljCVzRSYUnDVVguXEDEtauibmWQmXUJNaTVFn5ZCuJuYZymorQM6Kvlpn\n",
"TiEt2y2q715PU2aNvsPacSomPlvTkZo66oZgTbgdXHBohIMLDqKSnala7JbUbynJoiDHafjsxfN3zpmZ/cvMb2kc1bdxD0nB96Qd\n",
"38mlmprBd4PFhFWXkd8JZRfo3wVAcHlR2yVwHDBwgfh+W+JHndG2K/irrHMDniuikQPJrojaroGlHAl1+j5XaMf1TNzzm5Tvmk3R\n",
"6IZI5MSxm3MNBnAbB3JDXeEGELid1W/ttsb3BgcI3AEz9xkauE/h4g4NeUIHXliCgzqTsl8U35uCFgiAzNkbO2HsAQvH9B0etfoR\n",
"iKUeU/h6oqvxRCx1gtjTIGSSf8IEmfy0oOYEBjwPdFq8oqY08lIu2ZtEeDkeWhNLvfCAqhcFvPgAdsbe0xd4o2rxVlKGTaRMb5SO\n",
"3vChLrC9tfX7EsWp37R8CfgQIOwHHnp8naeBA+kPIpyfwqme/OIEcOzhHltmMzjViv2KrtjjPgH4xs6nt0BZHZhoxSZvQZYJtsRB\n",
"+AYycQjgFRxphbwUEFI4NAVjsCMO3ZBYEZ1DYdlQ45rzi/GdUIivUH2wqA4d5wyD54Rh8BTGC8wGEGHwnTBcYAhvwbY4rL/0I5ec\n",
"1imcVzj17/D/cFuz6SCQh8Mx9YgL4Ef1uEE4yvZAYxw3D99joViCCcJ5PN5YKiKxh8FQBAJExMFFSRtfAD9KYcacFBmJ0VMAv5GJ\n",
"PbhQolCJRCUUNfCKmkIoCuiKMuwBXcHOOGo8qGoK4ihqh41xNLTTM5WIpoOipg70xdEod6MToja1301q8lcc1ChxkOHjoKeJYxPG\n",
"4+CGExPK4iC8xcHkL86MzYJTrdwAQW5gLJGBc4/6cwNiuYOn8ITcKORyN7mNh6bs1+AmO+MU8Bdk+BRYICXe21PQeqfUQ1sKMJYC\n",
"/0wdAyc641SwZ2OcCoQlB9OpUFBqcbfnJg620lChJErptOma0iY/JhGchhorjfLb5Pj8F8FpY+J0lOrpVJBPgE7H2DLZF6fzBU4L\n",
"OIrQdFqAs60MeFHGpIAMPCFQrGdMmZgxCMtAO5NR+K7xHaJ05iYFBGfiATkZJtNHszkpIBM1aHI0nYnRcTL/5p1t3V3k3ywdx887\n",
"3LofsIjOooIKZVxWcQ0pMlFGJ4fT2TMeylbsoQ/Inn4sO3g8cWrSTDZCUDYVdDakPYjReZAjk5Pp5HwrDzDA0XSyjM6DOjTPPKD2\n",
"BoEiqDCarm0gxgK1p4arjdlQ7cLSRIgCfotJuGT8vwQJpmQSTInzFMYGxW64pPBlv4eVTCdZCniVjm8WptJF/JY6jkN2TX5XPNWk\n",
"JgWXTXQow+Cy+NdSGVRjGOuWYXBWNvmrbKJPWeP4YLecwjuSY6ENLgd3dsHlwVP5atryGRSUozYsh26QeosDrQoMhSqonPABf8X4\n",
"TXGiVUBuRfMUlJNAViVifwG5hdRbidhfidhWCeXc7vctAVeVSC7F0rlq0mOx/a1CgVUF69bEhiJwq4qn4DsF10TyrZ7AUE31NHJj\n",
"NV2zA+cTHKCd7gk31e8vyTp7id5YXQetUR0lhbhQh/xv7XyZMPnWAbJYPBdg24Bt75G/t75OoYHaRuncGxPF3mDee5ynOcfqPcZt\n",
"/J3UMnmxBTOmFnAnbFvg+D3/J/0DpZ50FA==\n",
"\"\"\",\n",
"}\n",
"os.makedirs(\"data\", exist_ok=True)\n",
"for _name, _packed in _DATA.items():\n",
" with open(os.path.join(\"data\", _name), \"wb\") as _f:\n",
" _f.write(zlib.decompress(base64.b64decode(_packed)))\n",
"print(\"Файлы данных:\", \", \".join(sorted(_DATA)))\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": [
"Поставщик прислал «Кофейной лавке» прайс-лист на 2026 год. Файл набирали вручную — и это видно."
],
"id": "text-10"
},
{
"cell_type": "code",
"metadata": {},
"source": [
"# Прайс поставщика\n",
"import pandas as pd\n",
"\n",
"supplier = pd.read_csv(\"data/supplier_prices.csv\")\n",
"supplier.head(6)"
],
"execution_count": null,
"outputs": [],
"id": "load"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Названия написаны как попало, в цене стоит знак рубля, в себестоимости вместо числа встречается «нет данных».\n",
"В этом и следующих уроках мы приведём таблицу в порядок. Начнём с типов.\n",
"\n",
"## Числа, которые стали текстом"
],
"id": "text-14"
},
{
"cell_type": "code",
"metadata": {},
"source": [
"# Типы столбцов\n",
"supplier.dtypes"
],
"execution_count": null,
"outputs": [],
"id": "dtypes"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"`price` и `cost` — это цены, но их тип — `str`, текст. Причина: тип у столбца один, и если хотя бы одно\n",
"значение не число («нет данных», `1 560 ₽`), pandas читает текстом **весь** столбец. `stock` (остаток\n",
"на складе) — числа, но дробные: в нём есть пропуски.\n",
"\n",
"Текстовый столбец с цифрами опасен тем, что не всегда даёт ошибку. Сложение для строк — это склейка,\n",
"умножение на число — повтор:"
],
"id": "text-21"
},
{
"cell_type": "code",
"metadata": {},
"source": [
"# «Сумма» и «удвоение» текста\n",
"print(supplier[\"cost\"].head(3).sum())\n",
"print((supplier[\"cost\"].head(3) * 2).tolist())"
],
"execution_count": null,
"outputs": [],
"id": "text-sum"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"А вот среднее по тексту посчитать нельзя:"
],
"id": "text-30"
},
{
"cell_type": "code",
"metadata": {},
"source": [
"# Среднее по текстовому столбцу\n",
"# Эта ячейка показывает ошибку TypeError: она перехвачена, чтобы «Выполнить всё» не останавливалось.\n",
"try:\n",
" supplier[\"cost\"].mean()\n",
"except Exception as error:\n",
" print(f\"{type(error).__name__}: {error}\")"
],
"execution_count": null,
"outputs": [],
"id": "text-mean"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"> **Типичная ошибка: Cannot perform reduction 'mean' with string dtype.**\n",
">\n",
"> Ошибка значит, что столбец текстовый. Проверьте `таблица.dtypes`: если там `str`, а вы ждали числа, в столбце\n",
"> есть значения, которые не удалось прочитать как числа."
],
"id": "component-35"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## astype и to_numeric\n",
"\n",
"Метод `astype` из прошлого модуля переводит столбец в указанный тип. Но он требует, чтобы подошли **все**\n",
"значения:"
],
"id": "text-39"
},
{
"cell_type": "code",
"metadata": {},
"source": [
"# astype спотыкается о «нет данных»\n",
"# Эта ячейка показывает ошибку ValueError: она перехвачена, чтобы «Выполнить всё» не останавливалось.\n",
"try:\n",
" supplier[\"cost\"].astype(int)\n",
"except Exception as error:\n",
" print(f\"{type(error).__name__}: {error}\")"
],
"execution_count": null,
"outputs": [],
"id": "astype-fail"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Функция `pd.to_numeric` с параметром `errors=\"coerce\"` («принудить») поступает мягче: всё, что не получилось\n",
"превратить в число, заменяет пропуском `NaN`:"
],
"id": "text-46"
},
{
"cell_type": "code",
"metadata": {},
"source": [
"# Что не число — то пропуск\n",
"answers = pd.Series([\"12\", \"7\", \"нет\", \"3.5\", \"?\"])\n",
"pd.to_numeric(answers, errors=\"coerce\")"
],
"execution_count": null,
"outputs": [],
"id": "coerce"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Упражнение 1. Себестоимость числами\n",
"\n",
"Сохраните в `cost_num` столбец `cost` таблицы `supplier`, переведённый в числа (нечисловые значения —\n",
"пропуски). В `n_bad` — сколько значений не распозналось, в `cost_total` — сумму распознанных.\n",
"\n",
"Подсказка 1
\n",
"\n",
"`pd.to_numeric(supplier[\"cost\"], errors=\"coerce\")`.\n",
"\n",
"Подсказка 2
\n",
"\n",
"Нераспознанные — пропуски: `cost_num.isna().sum()`. Сумма пропускает `NaN` сама.\n",
"\n",
"Решение
\n",
"\n",
"```python\n",
"cost_num = pd.to_numeric(supplier[\"cost\"], errors=\"coerce\")\n",
"n_bad = cost_num.isna().sum()\n",
"cost_total = cost_num.sum()\n",
"```\n",
"\n",
"Подсказка 1
\n",
"\n",
"`delivery[\"rating\"] = delivery[\"rating\"].astype(\"Int64\")` — и так же для `days`.\n",
"\n",
"Подсказка 2
\n",
"\n",
"Число пятёрок — сумма маски `delivery[\"rating\"] == 5`.\n",
"\n",
"Решение
\n",
"\n",
"```python\n",
"delivery = pd.read_csv(\"data/delivery_h1.csv\")\n",
"delivery[\"rating\"] = delivery[\"rating\"].astype(\"Int64\")\n",
"delivery[\"days\"] = delivery[\"days\"].astype(\"Int64\")\n",
"fives = (delivery[\"rating\"] == 5).sum()\n",
"```\n",
"\n",
"Ответ
\n",
"\n",
"`[1, 2]`\n",
"\n",
"`astype(int)` отбрасывает дробную часть: 1.7 → 1. Чтобы получить 2, сначала округлите: `.round().astype(int)`.\n",
"\n",
"Подсказка 1
\n",
"\n",
"Сначала заполнить, потом сменить тип: `supplier[\"stock\"].fillna(0).astype(int)`.\n",
"\n",
"Решение
\n",
"\n",
"```python\n",
"stock_int = supplier[\"stock\"].fillna(0).astype(int)\n",
"total_stock = stock_int.sum()\n",
"```\n",
"\n",
"