{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Типы данных\n",
    "\n",
    "У всех элементов массива один тип — целый, дробный или логический. Как его узнать и поменять и почему astype(int) отбрасывает дробную часть.\n",
    "\n",
    "Курс NumPy · урок `np-dtypes` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/numpy/dtypes).\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\"}.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",
    "# ─── Проверка упражнений: тот же раннер, что у задач на сайте ───\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 может хранить что угодно вперемешку: числа, строки, другие списки. Массив NumPy устроен иначе:\n",
    "**все его элементы одного типа** (data type, dtype). Поэтому он такой быстрый и компактный — NumPy заранее\n",
    "знает, сколько места занимает каждое число и как с ним считать.\n",
    "\n",
    "## Какой тип у массива\n",
    "\n",
    "Тип хранит атрибут `dtype`:"
   ],
   "id": "text-9"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Целые, дробные, логические\n",
    "import numpy as np\n",
    "\n",
    "counts = np.array([1, 2, 3])\n",
    "temps = np.array([18.5, 21.0])\n",
    "flags = np.array([True, False])\n",
    "print(counts.dtype, temps.dtype, flags.dtype)"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "kinds"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `int` — целые числа (integer); цифра — сколько бит на число: `int64` — 64 бита, `int32` — 32.\n",
    "- `float64` — дробные числа (floating point).\n",
    "- `bool` — логические значения `True` и `False`."
   ],
   "id": "text-19"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **int32 или int64.** В этом уроке Python работает в браузере, и там целые числа по умолчанию 32-битные: `int32`. В Jupyter на\n",
    "> компьютере вы увидите `int64`. Для курса разницы почти нет: `int32` хранит числа до двух миллиардов с лишним,\n",
    "> а нам таких больших не встретится. Дробные числа везде `float64`."
   ],
   "id": "component-24"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если в данных есть хоть одно дробное число, весь массив становится дробным — одного типа на всех:"
   ],
   "id": "text-29"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Целые и дробное вместе\n",
    "np.array([1, 2.5, 3])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "mixed"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Поменять тип: astype\n",
    "\n",
    "Метод `astype(тип)` возвращает **новый** массив с элементами другого типа; исходный не меняется:"
   ],
   "id": "text-33"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Дробные цены в целые рубли\n",
    "prices = np.array([99.9, 149.5, 20.99])\n",
    "print(prices.astype(int))\n",
    "print(prices)   # исходный массив не изменился"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "astype"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Типичная ошибка: astype(int) не округляет.**\n",
    ">\n",
    "> Перевод в целые **отбрасывает дробную часть**, а не округляет: 149.5 становится 149, а 20.99 — 20.\n",
    "> Для отрицательных чисел тоже «к нулю»: −1.8 → −1. Округлять научимся в модуле о статистике — там есть своя тонкость."
   ],
   "id": "component-40"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 1. Целые рубли\n",
    "\n",
    "Цены в `prices` записаны с копейками. Сохраните в `rubles` массив целых рублей без копеек.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Нужен другой тип элементов — метод `astype(int)`.\n",
    "\n",
    "</details>"
   ],
   "id": "rubles-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "prices = np.array([199.9, 49.5, 1250.75])\n",
    "rubles = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "rubles"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 1 — выполните после своего решения\n",
    "def test_int():\n",
    "    \"rubles — массив целых чисел\"\n",
    "    assert isinstance(rubles, np.ndarray), f\"rubles — это {type(rubles).__name__}, а нужен массив\"\n",
    "    assert rubles.dtype.kind == \"i\", f\"тип rubles — {rubles.dtype}, а нужны целые: вспомните, как поменять тип готового массива\"\n",
    "\n",
    "\n",
    "def test_values():\n",
    "    \"копейки отброшены\"\n",
    "    assert isinstance(rubles, np.ndarray), \"rubles пока не массив — сначала исправьте то, о чём говорит проверка выше\"\n",
    "    assert rubles.tolist() == [199, 49, 1250], f\"в rubles {rubles.tolist()}, а нужны цены без копеек\"\n",
    "\n",
    "_check(test_int, test_values, names=[\"rubles\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "rubles-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "prices = np.array([199.9, 49.5, 1250.75])\n",
    "rubles = prices.astype(int)\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "rubles-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Вопрос.** Что получится: `np.array([1.9, 2.1]).astype(int)`?\n",
    "\n",
    "- `array([2, 2])`\n",
    "- `array([1, 2])`\n",
    "- `array([1.9, 2.1])`\n",
    "\n",
    "<details><summary>Ответ</summary>\n",
    "\n",
    "`array([1, 2])`\n",
    "\n",
    "`astype(int)` отбрасывает дробную часть: от 1.9 остаётся 1, от 2.1 — 2. Округления нет.\n",
    "\n",
    "</details>"
   ],
   "id": "quiz-51"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Тип при создании: dtype=\n",
    "\n",
    "Тип можно задать сразу — параметром `dtype=` у `np.array`, `np.zeros` и других функций:"
   ],
   "id": "text-60"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Сразу нужный тип\n",
    "print(np.zeros(3, dtype=int))\n",
    "print(np.array([1, 2, 3], dtype=float))"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "dtype-arg"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 2. Счётчики посещений\n",
    "\n",
    "Создайте массив `visits` из семи **целых** нулей — счётчики посещений по дням недели.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "`np.zeros` делает дробные нули; целые получатся с параметром `dtype=int`.\n",
    "\n",
    "</details>"
   ],
   "id": "counters-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "visits = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "counters"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 2 — выполните после своего решения\n",
    "def test_visits():\n",
    "    \"visits — семь целых нулей\"\n",
    "    assert isinstance(visits, np.ndarray), f\"visits — это {type(visits).__name__}, а нужен массив\"\n",
    "    assert len(visits) == 7, f\"в visits {len(visits)} счётчиков, а дней недели 7\"\n",
    "    assert visits.dtype.kind == \"i\", f\"тип visits — {visits.dtype}, а нужны целые: тип можно задать прямо при создании массива\"\n",
    "    assert visits.sum() == 0, \"все счётчики должны быть нулями\"\n",
    "\n",
    "_check(test_visits, names=[\"visits\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "counters-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "visits = np.zeros(7, dtype=int)\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "counters-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 3. Оценки как дробные\n",
    "\n",
    "Создайте массив `ratings` из оценок 4, 5, 3, 5 так, чтобы его тип сразу был дробным (`float`).\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Передайте `np.array` параметр `dtype=float`.\n",
    "\n",
    "</details>"
   ],
   "id": "ratings-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "ratings = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "ratings"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 3 — выполните после своего решения\n",
    "def test_ratings():\n",
    "    \"ratings — оценки 4, 5, 3, 5 дробного типа\"\n",
    "    assert isinstance(ratings, np.ndarray), f\"ratings — это {type(ratings).__name__}, а нужен массив\"\n",
    "    assert ratings.dtype == np.float64, f\"тип ratings — {ratings.dtype}, а нужен дробный: тип можно задать прямо при создании массива\"\n",
    "    assert ratings.tolist() == [4, 5, 3, 5], f\"в ratings {ratings.tolist()}\"\n",
    "\n",
    "_check(test_ratings, names=[\"ratings\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "ratings-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "ratings = np.array([4, 5, 3, 5], dtype=float)\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "ratings-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Логические значения — тоже числа\n",
    "\n",
    "`True` при счёте ведёт себя как 1, а `False` — как 0. Поэтому сумма логического массива — это **сколько там\n",
    "`True`**, а среднее — какая это доля. Очень скоро, в модуле о масках, это будет главным способом считать."
   ],
   "id": "text-78"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Сумма True\n",
    "answers = np.array([True, False, True, True, False])\n",
    "print(answers.sum())\n",
    "print(answers.mean())"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "bools"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 4. Кто пришёл\n",
    "\n",
    "В `came` отмечено, пришёл ли каждый из восьми учеников (`True`) или нет. Сохраните в `present` число\n",
    "пришедших, а в `share` — долю пришедших (от 0 до 1).\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Число `True` — это сумма массива, доля — его среднее.\n",
    "\n",
    "</details>"
   ],
   "id": "attendance-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "came = np.array([True, True, False, True, True, True, False, True])\n",
    "present = ...\n",
    "share = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "attendance"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 4 — выполните после своего решения\n",
    "def test_present():\n",
    "    \"present — сколько пришло\"\n",
    "    assert present == 6, f\"present = {present} — это не число пришедших\"\n",
    "\n",
    "\n",
    "def test_share():\n",
    "    \"share — доля пришедших\"\n",
    "    assert share != 75, \"получились проценты, а нужна доля от 0 до 1\"\n",
    "    assert abs(share - 0.75) < 1e-9, f\"share = {share} — это не доля пришедших\"\n",
    "\n",
    "_check(test_present, test_share, names=[\"present\",\"share\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "attendance-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "came = np.array([True, True, False, True, True, True, False, True])\n",
    "present = came.sum()\n",
    "share = came.mean()\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "attendance-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Сколько помещается в число\n",
    "\n",
    "Типы бывают и поменьше: `np.int8` хранит целые только от −128 до 127. Если результат туда не помещается,\n",
    "NumPy не предупреждает — число «перескакивает» через край:"
   ],
   "id": "text-92"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Переполнение int8\n",
    "small = np.array([100, 120], dtype=np.int8)\n",
    "small + 50"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "overflow"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "150 не помещается в 127, и счёт пошёл заново с −128: 150 − 256 = −106. А `dtype=int8` в выводе появился потому,\n",
    "что тип отличается от обычного — такие NumPy дописывает к массиву.\n",
    "\n",
    "Такие маленькие типы нужны редко — чтобы сэкономить память на огромных данных. Главное — знать, что у целого\n",
    "типа есть предел.\n",
    "\n",
    "## Итоги\n",
    "\n",
    "- У массива один тип на все элементы: `dtype` — `int32`/`int64`, `float64`, `bool`.\n",
    "- Есть хоть одно дробное число — весь массив дробный.\n",
    "- `astype(тип)` — новый массив другого типа; `astype(int)` отбрасывает дробную часть.\n",
    "- `dtype=` задаёт тип при создании.\n",
    "- `True` и `False` считаются как 1 и 0: сумма — количество, среднее — доля."
   ],
   "id": "text-99"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Подробнее в справочнике:** [numpy/dtypes](https://ds-edu-trainer.vercel.app/reference/numpy/dtypes)"
   ],
   "id": "more"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python"
  },
  "colab": {
   "provenance": []
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}