python_lectures/python_lesson_part_6.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "79308666",
   "metadata": {},
   "source": [
    "## Содержание:\n",
    "- Операции с векторами и матрицами\n",
    "- Библиотека Matplotlib\n",
    "- Введение в Pandas\n",
    "- Описательные статистики в Python\n",
    "- Pandas – работа с несколькими файлами"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44068a2e",
   "metadata": {},
   "source": [
    "# Операции с векторами и матрицами\n",
    "\n",
    "#### Скалярное произведение векторов"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "009ffe92",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([3, 1, 5, 2])\n",
    "b = np.array([2, 5, 2, 4])\n",
    "\n",
    "# <a, b> = 3 * 2 + 1 * 5 + 5 * 2 + 2 * 4\n",
    "\n",
    "print(a @ b)  # python 3 style\n",
    "print(a.dot(b))\n",
    "print(np.dot(a, b))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "199ec0cc",
   "metadata": {},
   "source": [
    "Размерность должна совпадать"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "777e38ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([3, 1, 5, 2])\n",
    "b = np.array([2, 5, 2, 4, 4])\n",
    "print(a @ b)  # python 3 style"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f668dd3",
   "metadata": {},
   "source": [
    "#### Умножение матриц\n",
    "  \n",
    "Операция умножения определена для двух матриц, таких что число столбцов первой равно числу строк второй.\n",
    "\n",
    "![Ошибка загрузки](https://github.com/akazachkov/python_notebook/blob/master/python_lectures/_add_material_lesson_python/matrix_multiplication.gif?raw=true)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5356fe6b",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([[1, 2], [2, 0]])\n",
    "b = np.array([[2, 5], [1, 3]])\n",
    "# print(a)\n",
    "# print(b)\n",
    "print(a @ b)\n",
    "print(a.dot(b))\n",
    "print(np.dot(a, b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f2810367",
   "metadata": {},
   "outputs": [],
   "source": [
    "# c[0][0] = 1 * 2 + 2 * 1 = 4\n",
    "# c[0][1] = 1 * 5 + 2 * 3 = 11\n",
    "# c[1][0] = 2 * 2 + 0 * 1 = 4\n",
    "# c[1][1] = 2 * 5 + 0 * 3 = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c52cddb9",
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f429e8bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e4ba7320",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([[1, 2], [2, 0]])\n",
    "b = np.array([1, 2])\n",
    "print(a @ b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e01e521a",
   "metadata": {},
   "source": [
    "**!!!Не путайте покоординатное умножение с матричным!!!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2b014609",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a * b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "747ca9eb",
   "metadata": {},
   "source": [
    "#### Умножение матриц и векторов"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "89c0c342",
   "metadata": {},
   "outputs": [],
   "source": [
    "m = np.array([[1, 2], [0, 1], [2, 4]])\n",
    "print(m)\n",
    "v = np.array([2, 5])\n",
    "print(\"v = \",v)\n",
    "m @ v"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4e68185",
   "metadata": {},
   "source": [
    "## Полезные фукнции и методы для работы с массивами\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f72ce37c",
   "metadata": {},
   "source": [
    "**1. Замена элементов по индексу**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "be10d27b",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([5, 78, 23, 2, 9, 10, 13, 99, 12, 3])\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a1a735c0",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.put(a, ind = [0, 2], v = [-44, -55])\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5adf33c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.put(a, [0, 2], [-44, -55])\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b46e4b8",
   "metadata": {},
   "source": [
    "**2. Выделение массива по условию**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e3e23b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Замена элементов массива по условию: a if a < 0 else 0\n",
    "\n",
    "np.where(a < 0, a, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f4a23078",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Выбор элементов по условию\n",
    "\n",
    "a[np.where(a < 0)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac7975e3",
   "metadata": {},
   "source": [
    "**3. Сортировка**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "42af7d2d",
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "748a5dce",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Сортировка\n",
    "\n",
    "np.sort(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "13c7c8b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Индексы сортированного списка\n",
    "\n",
    "np.argsort(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7aec4fc5",
   "metadata": {},
   "source": [
    "**4. Any и All для сложных логических условий**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "514e52b7",
   "metadata": {},
   "source": [
    "`Any` возвращает True, если хотя бы один элемент `True`\n",
    "\n",
    "`All` возвращает True, если все элементы `True`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "811b5dbf",
   "metadata": {},
   "outputs": [],
   "source": [
    "any([True, True, False, True, False, False, False])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1781784b",
   "metadata": {},
   "outputs": [],
   "source": [
    "all([True, True, False, True, False, False, False])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ca1a3ebe",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Сравнение векторов\n",
    "\n",
    "np.array([1, 1, 0, 0]) == np.array([1, 1, 0, 2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f653a24",
   "metadata": {},
   "outputs": [],
   "source": [
    "all(np.array([1, 1, 0, 0]) == np.array([1, 1, 0, 2]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "218b4c00",
   "metadata": {},
   "outputs": [],
   "source": [
    "any(np.array([1, 1, 0, 0]) == np.array([1, 1, 0, 2]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ef952af",
   "metadata": {},
   "source": [
    "**5. Функции delet, insert и append не меняю массив, а возращают новый, в котором удалены, вставлены в середину или добавлены элементы**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eeeef3d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2fa048bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.delete(a, [2, 5])  # Удалить элементы по индексу\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d1ab0105",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.insert(a, 2, [0, 0])  # Вставить элементы под индексом\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8d665e00",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.append(a, [1, 2, 3])  # Вставить элементы в конец массива\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d5cfd64",
   "metadata": {},
   "source": [
    "**6. Копия массива**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53fdd677",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.linspace(0, 1, 11)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e1f0daae",
   "metadata": {},
   "outputs": [],
   "source": [
    "b = a[2:5]\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "322dafe2",
   "metadata": {},
   "outputs": [],
   "source": [
    "b[0] = -0.2\n",
    "a  # Исходный массив изменился"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4548271",
   "metadata": {},
   "outputs": [],
   "source": [
    "b = a.copy()\n",
    "b[1:5] = 0\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c988495",
   "metadata": {},
   "source": [
    "Время выполнения"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7f9a93ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "sum_value = 0\n",
    "for i in range(10**8):\n",
    "    sum_value += i\n",
    "print(sum_value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "911feb40",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "sum_value = sum(range(10**8))\n",
    "print(sum_value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "945f2a11",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "sum_value = np.arange(10**8).sum()\n",
    "print(sum_value)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ba35785",
   "metadata": {},
   "source": [
    "Результат вычислений третьего варианта отличается от первых двух вариантов. С чем это связано, нужно разбираться.\n",
    "\n",
    "Если вычислять 10**4, то результат во всех случаях будет одинаковый. Но уже нет наглядной разницы во времени выполнения кода.\n",
    "\n",
    "Начиная с 10**5, третий вариант начинает выдавать результат, отличный от вычислений первых двух."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2835dea7",
   "metadata": {},
   "source": [
    "# Библиотека Matplotlib\n",
    "\n",
    "Matplotlib – популярная Python-библиотека для визуализации данных.\n",
    "\n",
    "Кроме официальной документации (https://matplotlib.org/stable/gallery/index.html), есть и сторонние сайты где можно посмотреть примеры построения графиков. Например, https://datavizcatalogue.com/RU/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0b03203f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "# %matplotlib inline  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8470ab25",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "plt.plot((0, 1, 2, 3, 4, 5, 6, 7), (0, 5, 7, 5, 4, 6, 7, 0));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "61c6843a",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "plt.plot((0, 1, 2, 3, 4, 5, 6, 7), (0, 5, 7, 5, 4, 6, 7))  # Количество значений должно быть одинаковое"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dc729d38",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot((0, 5, 7, 5, 4, 6, 7, 0));  # Если значения координаты Х \"не нужны\", их можно опустить"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4dc970f",
   "metadata": {},
   "source": [
    "Изменение вида графиков"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4a5631d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot((0, 1, 2, 3, 4, 5, 6, 7), (0, 5, 7, 5, 4, 6, 7, 0), \"o\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3f8c1fc1",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot((0, 1, 2, 3, 4, 5, 6, 7), (0, 5, 7, 5, 4, 6, 7, 0), \"--o\");"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cccb826d",
   "metadata": {},
   "source": [
    "Зададим диапазон переменной x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "156f62ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(-5,5, 200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b56aa25a",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(x, x ** 2);  # Парабола "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "09fe8f54",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(x, np.sin(x), \"--\");"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6aac61ea",
   "metadata": {},
   "source": [
    "Создадим график рассеивания красного цвета"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf206faf",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.random.random(100)\n",
    "y = np.random.random(100)\n",
    "plt.plot(x, y, \"o\", c = \"red\"); "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47ca32a0",
   "metadata": {},
   "source": [
    "Для отображения точечного графика предназначена функция scatter()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "be15d3f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.scatter(x, y, c = \"green\");"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da48e2ca",
   "metadata": {},
   "source": [
    "Для дальнейшей настройки визуализации возьмем функцию экспоненциального распределения"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0e4572bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "data1 = np.random.exponential(5, 20)\n",
    "data2 = np.random.exponential(5, 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1c83b5eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(data1)\n",
    "plt.scatter(range(len(data2)),data2, c = \"r\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d2d9521b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Добавим название\n",
    "\n",
    "plt.plot(data1)\n",
    "plt.scatter(range(len(data2)),data2, c = \"r\")\n",
    "plt.title(\"Результаты\", fontdict = {\"fontsize\" : 20})  # fontdict настройки отображения названия графика\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f6f6438d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Подпишем оси\n",
    "\n",
    "plt.plot(data1)\n",
    "plt.scatter(range(len(data2)),data2, c = \"r\")\n",
    "plt.title(\"Результаты\", fontdict = {\"fontsize\" : 20})\n",
    "plt.xlabel(\"Номер попытки\")\n",
    "plt.ylabel(\"Результат\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b17e1a0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Добавим сетку\n",
    "\n",
    "plt.plot(data1)\n",
    "plt.scatter(range(len(data2)),data2, c = \"r\")\n",
    "plt.title(\"Результаты\", fontdict = {\"fontsize\" : 20})\n",
    "plt.xlabel(\"Номер попытки\")\n",
    "plt.ylabel(\"Результат\")\n",
    "plt.grid()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "68734dfa",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Добавим легенду\n",
    "\n",
    "plt.plot(data1, label = \"Первый игрок\")\n",
    "plt.scatter(range(len(data2)),data2, c = \"r\", label = \"Второй игрок\")\n",
    "plt.title(\"Результаты\", fontdict = {\"fontsize\" : 20})\n",
    "plt.xlabel(\"Номер попытки\")\n",
    "plt.ylabel(\"Результат\")\n",
    "plt.grid()\n",
    "plt.legend(loc = \"best\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f8484f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Настроим ось х\n",
    "\n",
    "plt.plot(data1, label = \"Первый игрок\")\n",
    "plt.scatter(range(len(data2)),data2, c = \"r\", label = \"Второй игрок\")\n",
    "plt.title(\"Результаты\", fontdict = {\"fontsize\" : 20})\n",
    "plt.xlabel(\"Номер попытки\")\n",
    "plt.ylabel(\"Результат\")\n",
    "plt.grid()\n",
    "plt.legend(loc = \"best\")\n",
    "plt.xticks(range(0, 21, 4))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0678a961",
   "metadata": {},
   "source": [
    "Более подробнее возможные настройки можно посмотреть по ссылке https://matplotlib.org/stable/gallery/index\n",
    "\n",
    "Создание гистограмм"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ff95e2a",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.bar(range(len(data1)),data1);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "08bb9b1a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Изменим ширину\n",
    "plt.bar(range(len(data1)),data1, width = 1);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da641a5d",
   "metadata": {},
   "source": [
    "Круговая диаграмма"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "20100ef9",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.pie(data1);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c191bb73",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.pie([1,12,8,7,9], autopct = \"%.1f%%\");"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9dc4fe1c",
   "metadata": {},
   "source": [
    "Диаграмма размаха"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d38594c",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.boxplot(data1);  # Оранжевая линия медиана элементов "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f6dd556",
   "metadata": {},
   "source": [
    "Объектный подход к построению графиков"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bff4dce4",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axes = plt.subplots()  # Функция возвращает кортеж из двух значений\n",
    "axes.plot(data1);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96248774",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axes = plt.subplots() \n",
    "axes.plot(data1);\n",
    "axes.set_title('График')  # Добавим подпись\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0e5f43e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axes = plt.subplots() \n",
    "axes.plot(data1);\n",
    "axes.set_title('График')\n",
    "axes.set_xlim(0, 20)  # Изменим ось х\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "654d6f09",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Несколько графиков в одной области\n",
    "\n",
    "fig, axes = plt.subplots(nrows = 2, ncols = 3, figsize = (10, 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53c21fe9",
   "metadata": {},
   "outputs": [],
   "source": [
    "axes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8021ed19",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axes = plt.subplots(nrows = 2, ncols = 3, figsize = (10, 5))\n",
    "axes[0][0].axes.plot(data1);\n",
    "axes[1][1].axes.plot(data2);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c1cdff28",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Пример использования enumerate\n",
    "\n",
    "values = [\"a\", \"b\", \"c\"]\n",
    "for v in values:\n",
    "    print(v)\n",
    "print()\n",
    "\n",
    "for i, v in enumerate(values):\n",
    "    print(i, v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "28947a23",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axes = plt.subplots(nrows = 2, ncols = 3, figsize = (10, 8))\n",
    "for row, row_axes in enumerate(axes):\n",
    "    for column, ax in enumerate(row_axes):\n",
    "        ax.plot(np.random.exponential((column + 1), 20))\n",
    "        ax.set_title(\"Колонка {} строка {}\". format(column + 1, row + 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c3e430d3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Сохранение изображения\n",
    "\n",
    "fig.savefig(\"res.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90e79179",
   "metadata": {},
   "source": [
    "3D графики"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2d76b90b",
   "metadata": {},
   "outputs": [],
   "source": [
    "t = np.linspace(0, 4 * np.pi, 100)\n",
    "plt.figure()\n",
    "plt.polar(t, t);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f8e893d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "t = np.linspace(0, 4 * np.pi, 100)\n",
    "x = np.cos(t)\n",
    "y = np.sin(t)\n",
    "z = t / (4 * np.pi)\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(projection = \"3d\")\n",
    "ax.plot(x, y, z)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "48617180",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Изменим угол отображения\n",
    "\n",
    "t = np.linspace(0, 4 * np.pi, 100)\n",
    "x = np.cos(t)\n",
    "y = np.sin(t)\n",
    "z = t / (4 * np.pi)\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(projection = \"3d\")\n",
    "ax.elve, ax.azim = 45, 30\n",
    "ax.plot(x, y, z)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5d7f524",
   "metadata": {},
   "source": [
    "Библиотека seaborn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bac090fe",
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "06649b78",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sinplot(a = 1):\n",
    "    x = np.linspace(0, 14, 100)\n",
    "    for i in range(1, 7):\n",
    "        plt.plot(x, np.sin(x + i * 0.5) * (7 - i) * a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07e80807",
   "metadata": {},
   "outputs": [],
   "source": [
    "sinplot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db5cbe23",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize = (15, 10))\n",
    "for i, context in enumerate([\"notebook\", \"paper\", \"talk\", \"poster\"]):\n",
    "    sns.set(context = context)\n",
    "    plt.subplot(2, 2, i + 1)\n",
    "    sinplot()\n",
    "    plt.title(context)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6120b0e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize = (15, 10))\n",
    "for i, style in enumerate([\"darkgrid\", \"whitegrid\", \"ticks\", \"dark\", \"white\"]):\n",
    "    sns.set(style = style)\n",
    "    plt.subplot(3, 2, i + 1)\n",
    "    sinplot()\n",
    "    plt.title(style)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "531b32fa",
   "metadata": {},
   "source": [
    "# Введение в Pandas\n",
    "\n",
    "Pandas – это библиотека на Python, предназначенная для обработки и анализа структурированных табличных данных."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ca4c1e0",
   "metadata": {},
   "source": [
    "![Ошибка загрузки](https://nustat.github.io/DataScience_Intro_python/Datasets/series_dataframe.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75e2334a",
   "metadata": {},
   "source": [
    "Чтобы не писать название библиотеки целиком каждый раз, когда понадобится ее использовать, принято сокращать название библиотеки и импортировать ее как \"pd\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "40cf52bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3886ce3",
   "metadata": {},
   "source": [
    "**Series** – это объект библиотеки pandas, спроектированный для представления одномерных структур данных, похожих на массивы, но с дополнительными возможностями. Его структура проста, ведь он состоит из двух связанных между собой массивов. Основной содержит данные (данные любого типа NumPy), а в дополнительном, index, хранятся метки.\n",
    "\n",
    "**Dataframe** – это табличная структура данных, напоминающая таблицы из Microsoft Excel. Ее главная задача – позволить использовать многомерные Series. Dataframe состоит из упорядоченной коллекции колонок, каждая из которых содержит значение разных типов (числовое, строковое, булевое и так далее)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2bd580e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = pd.Series([1, 2, 3, 4])  # Автоматически индексы от 0 и до количества элементов"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ae6bd2a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f1ac0ae4",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = pd.Series([1, 2, 3, 4], index = [\"a\", \"b\", \"c\", \"d\"])  # Зададим свои индексы\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eaf48121",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = pd.Series([1, 2, 3, 4], index = [\"a\", \"a\", \"b\", \"b\"])  # Допустимо совпадение индексов\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "576b8b4f",
   "metadata": {},
   "outputs": [],
   "source": [
    "s[\"a\"]  # Обращение к индексу"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "314bb396",
   "metadata": {},
   "source": [
    "В Pandas есть тип данных датафрейм (DataFrame), в котором удобно хранить таблицы с данными. Создадим объект такого типа самостоятельно:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "80e5b973",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame()  # Создали пустой датафрейм с помощью метода DataFrame() библиотеки pandas (pd)\n",
    "df['a'] = [10, 20, 30]  # Создаем колонку \"а\" и помещаем в нее столбец с данными – [10, 20, 30]\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "57f30323",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "683c12c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "df['b'] = ['one', 'two'] \n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19502dd7",
   "metadata": {},
   "outputs": [],
   "source": [
    "df['b'] = ['one', 'two', 'three']\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f3ebc1e",
   "metadata": {},
   "source": [
    "Чаще всего приходится работать с уже готовыми наборами данных. Такие данные обычно хранятся в формтае xls(x) – для работы в Excel, или в формате csv – comma-separated value. Попробуем импортировать csv файл с данными о пассажирах Титаника."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "20612b87",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.read_csv('https://raw.githubusercontent.com/rogovich/Data/master/data/titanic/train.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "43940b25",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.read_csv(\"train.csv\")  # Так бы выглядела ссылка, если файл был локальный"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d84db0b7",
   "metadata": {},
   "source": [
    "По умолчанию разделитель запятая. При помощи sep можно изменить разделитель. Например:\n",
    "\n",
    "data = pd.read_csv(\"train.csv\", sep = \";\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b6158e0",
   "metadata": {},
   "source": [
    "Функция read_csv читает данные из файла формата csv и преобразует в pandas.DataFrame. Аналогичная функция read_excel может читать данные в офрмате xls(x).\n",
    "\n",
    "Посмотрим на наши данные:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f869d49c",
   "metadata": {},
   "outputs": [],
   "source": [
    "data  # Отобразится первые пять и последние пять строчек"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c72f4235",
   "metadata": {},
   "source": [
    "Можно считать не все данные, а определенное количество первых строк и определенные столбцы"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7c7ad9e",
   "metadata": {},
   "outputs": [],
   "source": [
    "data_1 = pd.read_csv('https://raw.githubusercontent.com/rogovich/Data/master/data/titanic/train.csv', nrows = 15, usecols = [\"Name\", \"Age\"])\n",
    "data_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c4259444",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.head()  # Функция head() показывает первые строки датафрейма, по умолчанию 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "652a2028",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.head(10)  # Можно передать аргументом количество строк, которые хотите увидеть"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ef5b8731",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.tail()  # Можно посмотреть последние записи"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0698f3fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.tail(10)  # Можно посмотреть последние 10 записей"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a18c2469",
   "metadata": {},
   "source": [
    "По столбцам идут признаки, по строкам – объекты (пассажиры)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fdef02d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.shape  # Функция shape показывает размерность датафрейма (строк, столбцов)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "98041018",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.columns  # Список столбцов"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1843d70",
   "metadata": {},
   "source": [
    "Описание признаков:\n",
    "\n",
    "**PassengerId** – id пассажира\n",
    "\n",
    "**Survived** – бинарная переменная: выжил пассажир (1) или нет (0)\n",
    "\n",
    "**Pclass** – класс пассажира\n",
    "\n",
    "**Name** – имя пассажира\n",
    "\n",
    "**Sex** – пол пассажира\n",
    "\n",
    "**Age** – возраст пассажира\n",
    "\n",
    "**SibSp** – количество родственников (братьев, сестер, супругов) пассажира на борту\n",
    "\n",
    "**Parch** – количество родственников (родителей / детей) пассажира на борту\n",
    "\n",
    "**Ticket** – номер билета\n",
    "\n",
    "**Fare** – тариф (стоимость билета)\n",
    "\n",
    "**Cabin** – номер кабины\n",
    "\n",
    "**Embarked** – порт, в котором пассажир сел на борт: C – Cherbourg, S – Southampton, Q – Queenstown"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9f89908f",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.dtypes  # Тип данных в столбцах"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d414c433",
   "metadata": {},
   "source": [
    "Так можно обратиться к столбцу:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0ae35534",
   "metadata": {},
   "outputs": [],
   "source": [
    "data['Age']  # Выведется 5 первых и 5 последних элементов"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "94d86f12",
   "metadata": {},
   "outputs": [],
   "source": [
    "data['Age'].head()  # Выведется 5 первых элементов"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "834bc9ab",
   "metadata": {},
   "source": [
    "Второй способ:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "93f608c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.Age.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e12f1488",
   "metadata": {},
   "source": [
    "Или к нескольким столбцам сразу:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "425c95ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "data[['Age', 'Sex']].head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c205202",
   "metadata": {},
   "source": [
    "Обращение к строке:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bba81456",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.loc[0]  # Обращение к имени строки"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b57b2095",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.iloc[0]  # Обращение к индексу строки"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "01777686",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.loc[1:3]  # Строки с 1 по 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "829816a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.iloc[1:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "22c7b1a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.loc[1:3, 'Survived':'Sex']  # Строки с 1 по 3, колонки от Survived до Sex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "65281ab8",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.iloc[1:3, 1:5]  # Строки с 1 по 3 (не включительно), колонки от 1 до 5 (не включительно)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0beb73c5",
   "metadata": {},
   "source": [
    "__loc__ возвращает данные на основе индекса, а __iloc__ –  основываясь исключительно на позиции индекса, начиная с 0.\n",
    "\n",
    "Пример:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75f648cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame()\n",
    "df['Name'] =  ['Иван', 'Сергей', 'Виктор', 'Виктория']\n",
    "df['Num'] = [85, 90, 80, 95]\n",
    "df.index = [\"один\", \"пять\", \"два\", \"три\"]\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ffff065",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.loc[\"один\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c2127752",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.iloc[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "edd35fc4",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.loc[\"один\":\"два\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db07c461",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.iloc[1:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25c77cdc",
   "metadata": {},
   "source": [
    "Можем сделать индексом даже колоноку с именем. И тоже сможем обращаться к объектам через .loc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eb8e4474",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.index = df.Name\n",
    "print(df)\n",
    "df.loc['Иван']['Num']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2c7784ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.loc['Иван':'Виктор']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8d6eaf7",
   "metadata": {},
   "source": [
    "Вернемся к данным о пассажирах Титаника.\n",
    "\n",
    "Можно выбирать объекты, удовлетворяющие каким-то свойствам, например, все пассажиры-женщины:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d0a34b64",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.Sex == 'female'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e4b2a6ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "data[data.Sex == 'female'].head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ad0c1ef",
   "metadata": {},
   "source": [
    "Пассажиры первого класса:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "91eab6db",
   "metadata": {},
   "outputs": [],
   "source": [
    "data[data.Pclass == 1].head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5eb2caf9",
   "metadata": {},
   "source": [
    "Пассажиры первого или второго классов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "77ee36ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "data[(data.Pclass == 1) or (data.Pclass == 2)].head()  # Так не получится"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f229dbbe",
   "metadata": {},
   "outputs": [],
   "source": [
    "data[(data.Pclass == 1) | (data.Pclass == 2)].head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c097a7d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "data[data.Pclass.isin([1, 2])].head()  # isin совпадение с 1 или 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cfe8eb51",
   "metadata": {},
   "source": [
    "Пассажиры младше 18:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "743e2c12",
   "metadata": {},
   "outputs": [],
   "source": [
    "data[data.Age < 18].head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84e6aaee",
   "metadata": {},
   "source": [
    "Девушки в возрасте от 18 до 25, путешествующие в одиночку (без каких-либо родственников):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5be58e38",
   "metadata": {},
   "outputs": [],
   "source": [
    "data[(data.Sex == 'female') & (data.Age > 18) & (data.Age < 25) & (data.SibSp == 0) & (data.Parch == 0)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cae3aa26",
   "metadata": {},
   "source": [
    "Количество найденных совпадений "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c58b6732",
   "metadata": {},
   "outputs": [],
   "source": [
    "data[(data.Sex == 'female') & (data.Age > 18) & (data.Age < 25) & (data.SibSp == 0) & (data.Parch == 0)].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5dfd238f",
   "metadata": {},
   "outputs": [],
   "source": [
    "data[(data.Sex == 'female') & (data.Age.between(19, 24)) & (data.SibSp == 0) &(data.Parch == 0)].shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50dbe92a",
   "metadata": {},
   "source": [
    "Создадим новый признак. Подсчитаем сколько всего родственников путешествовало с каждым пассажиром, для этого сложим столбцы SibSp и Parch и поместим сумму в новый столбец FamilySize."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b008c04e",
   "metadata": {},
   "outputs": [],
   "source": [
    "data['FamilySize'] = data['SibSp'] + data['Parch']\n",
    "data.head(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2dda532f",
   "metadata": {},
   "source": [
    "Создадим переменную, которая бы нам показывала, что пассажир ехал в одиночку. Такой пассажир путешествовал без родственников. Напишем условие с помощью lambda функции (1, если FamilySize равно 0 и 0 во всех остальных случаях) и применим ее к столбцу FamilySize с помощью метода .apply()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4827d20a",
   "metadata": {},
   "outputs": [],
   "source": [
    "data['Alone'] = data['FamilySize'].apply(lambda x: 1 if x == 0 else 0)\n",
    "data.head(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d8be7c5",
   "metadata": {},
   "source": [
    "Из каждого имени пассажира достанем его титул. Сначала потренируемся на одном пассажире."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7e8d76fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.loc[0]['Name']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "111fbe94",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.loc[0]['Name'].split(\",\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9ba161dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.loc[0]['Name'].split(\",\")[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db7d50df",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.loc[0]['Name'].split(\",\")[1].split(\".\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c3f383dc",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.loc[0]['Name'].split(\",\")[1].split(\".\")[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7cb301d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.loc[0]['Name'].split(\",\")[1].split(\".\")[0].strip()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f1014e7",
   "metadata": {},
   "source": [
    "Напишем функцию, которая будет забирать титул из имени, а потом применим ее к колонке Name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b726021",
   "metadata": {},
   "outputs": [],
   "source": [
    "def return_title(full_name):\n",
    "    return(full_name.split(',')[1].split('.')[0].strip())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5ce5625",
   "metadata": {},
   "source": [
    "Теперь сформируем новый столбец family_name из столбца Name с помощью написанной нами функции:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "211b7ea9",
   "metadata": {},
   "outputs": [],
   "source": [
    "data['Title'] = data.Name.apply(return_title)\n",
    "data.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c1c7525",
   "metadata": {},
   "source": [
    "Полезно посмотреть, какие значения содержатся в столбце. Для категориальных данных можно посчитать частоту встречаемости каждого значения с помошью функции value_counts:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "677e2293",
   "metadata": {},
   "outputs": [],
   "source": [
    "data['Title'].value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b0ac553",
   "metadata": {},
   "source": [
    "Очень много уникальных значений с малым количеством частоты встречаемости. Чаще всего это плохо влияет на статистический анализ. Переименуем все такие данные в Misc (другие)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8ecf6f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "data['Title'] = data['Title'].apply(lambda x: 'Misc' if x not in ['Mr', 'Miss', 'Mrs', 'Master'] else x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7573c8b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "data['Title'].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "88764a3d",
   "metadata": {},
   "outputs": [],
   "source": [
    "data['Pclass'].value_counts()  # Количество пассажиров в зависимости от класса"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e9ebe0f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "data['Embarked'].value_counts()  # В каком порту садились"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc78e0c9",
   "metadata": {},
   "source": [
    "Для количественных данных удобнее смотреть минимальные/максимальные/средние значения:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2034447d",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(data['Age'].min())\n",
    "print(data['Age'].max())\n",
    "print(data['Age'].mean())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "194b8132",
   "metadata": {},
   "source": [
    "В Pandas есть функция describe(), которая делает удобную сводную таблицу по всем количественным столбцам сразу (обратите внимание, что для Pandas количественные данные = все, что представлено числами, что, разумеется, неверно в общем случае):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ddf5063",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88484c60",
   "metadata": {},
   "source": [
    "    count: общее количество непустых значений\n",
    "    среднее: среднее значение значений столбца\n",
    "    std: стандартное отклонение значений столбца\n",
    "    min: минимальное значение из столбца\n",
    "    25%: 25 процентилей\n",
    "    50%: 50 процентилей\n",
    "    75%: 75 процентилей\n",
    "    max: максимальное значение из столбца\n",
    "\n",
    "Процентиль – это значение, которое заданная случайная величина не превышает с фиксированной вероятностью, заданной в процентах."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e789fef2",
   "metadata": {},
   "outputs": [],
   "source": [
    "data['Embarked'].unique()  # Уникальные значения"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4a3b321",
   "metadata": {},
   "outputs": [],
   "source": [
    "data[['Age', 'Fare']].describe()  # Также можно применять только к отдельным колонкам"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b54f88be",
   "metadata": {},
   "source": [
    "Данные можно сортировать:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "292727b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.info()  # Сначала нужно посмотреть информацию"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0fcda7be",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.isnull()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6942b477",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.isnull().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e7a7b95",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = data.dropna(how = 'any')  # Удалит строку если есть хотя бы один пропуск\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7a3e027a",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "370c6ae1",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.sort_values(by = ['Age'])  # Сортируем по возрасту, по умолчанию сортировка по возрастанию"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ee71a4ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.sort_values(by = ['Age'], ascending = False)  # Сортируем по возрасту, теперь по убыванию"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "de0b89c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.sort_values(by = ['Age', 'Fare'], ascending = False).head(10)  # Сортируем сперва по возрасту (по убыванию),\n",
    "                                                                # Потом стоимости билета  (по убыванию)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f30505cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.sort_values(by = ['Age', 'Fare'], ascending = [False, True]).head(15)  # Сортируем сперва по возрасту (по убыванию),\n",
    "                                                                        # Потом стоимости билета  (по возрастанию)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "072d4eec",
   "metadata": {},
   "source": [
    "Сохранение датафрейма:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "855b2ee2",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.to_csv('new_titanic.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ff5ca9e",
   "metadata": {},
   "source": [
    "# Описательные статистики в Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4a6cb6ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "849e8120",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.read_csv('https://raw.githubusercontent.com/rogovich/Data/master/data/titanic/train.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41485fd8",
   "metadata": {},
   "source": [
    "Описание признаков:\n",
    "\n",
    "**PassengerId** – id пассажира\n",
    "\n",
    "**Survived** – бинарная переменная: выжил пассажир (1) или нет (0)\n",
    "\n",
    "**Pclass** – класс пассажира\n",
    "\n",
    "**Name** – имя пассажира\n",
    "\n",
    "**Sex** – пол пассажира\n",
    "\n",
    "**Age** – возраст пассажира\n",
    "\n",
    "**SibSp** – количество родственников (братьев, сестер, супругов) пассажира на борту\n",
    "\n",
    "**Parch** – количество родственников (родителей / детей) пассажира на борту\n",
    "\n",
    "**Ticket** – номер билета\n",
    "\n",
    "**Fare** – тариф (стоимость билета)\n",
    "\n",
    "**Cabin** – номер кабины\n",
    "\n",
    "**Embarked** – порт, в котором пассажир сел на борт: C – Cherbourg, S – Southampton, Q – Queenstown"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b72af62e",
   "metadata": {},
   "source": [
    "**Максимальное и минимальное значения**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e289ca1",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.Age.min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b468ab7",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.Age.max()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8c0067a",
   "metadata": {},
   "source": [
    "**Меры центральной тенденции**\n",
    "\n",
    "Меры среднего уровня дают усредненную характеристику совокупности объектов по определенному признаку.\n",
    "\n",
    "В зависимости от типа шкалы измерения применяются следующие меры среднего уровня:\n",
    "- для количественных данных – среднее значение (арифметическое среднее), медиана, мода\n",
    "\n",
    "- для категориальных: для порядковых данных – медиана, мода; для номинальных данных – мода\n",
    "\n",
    "На самом деле таких мер довольно много, например: взвешенное среднее – среднее значение, учитывающее весовые коэффициенты для каждого значения, гармоническое среднее – количество наблюдений, деленное на сумму инвертированных значений наблюдений, и так далее."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2330c625",
   "metadata": {},
   "source": [
    "**Среднее значение (математическое ожидание)**\n",
    "\n",
    "*Математическое ожидание* вычисляется по формуле:\n",
    "\n",
    "$$\n",
    " {\\displaystyle {\\bar {x}}={\\frac {1}{n}}\\sum _{i=1}^{n}x_{i}={\\frac {1}{n}}(x_{1}+\\ldots +x_{n})}\n",
    " $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c010a093",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.Age.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "843bfcab",
   "metadata": {},
   "source": [
    "**Немного усложним задачу**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6177c2b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "data[['Pclass', 'Age']].groupby('Pclass').mean()  # Среднее в зависимости от класса пассажира"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c7e018e",
   "metadata": {},
   "source": [
    "**Медиана**\n",
    "\n",
    "Если $x_1, x_2, ..., x_n$ – упорядоченные по возрастанию или убыванию числовые значения рассматриваемого признака,\n",
    "$n$ – объем выборки, то *медиана* – это средний элемент для нечетного  $n$ и полуcумма средних элементов для чётного $n$.\n",
    "\n",
    "Для порядковой шкалы медиана является такой точкой на шкале, которая делит всю совокупность опрошенных на две равных части – тех, кто отметил градации меньше этой точки (либо равные ей), и тех, кто отметил градации больше этой точки."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36edf711",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.Age.median()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9aeac35a",
   "metadata": {},
   "source": [
    "**Мода**\n",
    "\n",
    "Мода – значение во множестве наблюдений, которое встречается наиболее часто."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0968ed11",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.Pclass.mode()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e42f5b24",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.Pclass.value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d3f4fc4",
   "metadata": {},
   "source": [
    "**Меры разброса**\n",
    "\n",
    "Меры разброса показывают, насколько хорошо данные значения представляют совокупность. Как меры разброса применяются:\n",
    "\n",
    "- дисперсия случайной величины и среднеквадратическое отклонение\n",
    "\n",
    "- коэффициент вариации (это отношение среднеквадратического отклонения к среднему значению, выраженное в процентах, показывает однородность выборки)\n",
    "\n",
    "- и так далее"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "018d3615",
   "metadata": {},
   "source": [
    "**Дисперсия и среднеквадратическое отклонение**\n",
    "\n",
    "*Дисперсия* значений признака является суммой квадратов отклонений этих значений от их среднего, деленной на число наблюдений:\n",
    "$$\n",
    "\\sigma^2={\\dfrac {\\sum \\limits _{i=1}^{n}\\left(x_{i}-{\\bar {x}}\\right)}{n}}^{2}\n",
    "$$\n",
    "*Среднеквадратическое отклонение*, *стандартное отклонение* или *стандартный разброс* – квадратный корень из дисперсии, равный $\\sigma$\n",
    "\n",
    "Стандартное отклонение измеряется в тех же единицах, что и сама случайная величина, а дисперсия измеряется в квадратах этой единицы измерения."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e436a677",
   "metadata": {},
   "outputs": [],
   "source": [
    "data[['Pclass', 'Age']].groupby('Pclass').std()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b6f3d9b",
   "metadata": {},
   "source": [
    "**Квантили**\n",
    "\n",
    "Квантиль – значение, которое заданная случайная величина не превышает с фиксированной вероятностью. Если вероятность задана в процентах, то квантиль называется процентилем или перцентилем.\n",
    "\n",
    "Например, фраза «для развитых стран 99-процентиль продолжительности жизни составляет 100 лет» означает, что ожидается, что 99 % людей проживут не более, чем 100 лет.\n",
    "\n",
    "Относительно нашего датасета фраза \"75%-перцентиль возраста пассажиров Титаника равна 38 лет\" означает, что 75% пассажиров были не старше 38 лет."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59dd2635",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.Age.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be7fdf2f",
   "metadata": {},
   "source": [
    "    count: общее количество непустых значений\n",
    "    среднее: среднее значение значений столбца\n",
    "    std: стандартное отклонение значений столбца\n",
    "    min: минимальное значение из столбца\n",
    "    25%: 25 процентилей\n",
    "    50%: 50 процентилей\n",
    "    75%: 75 процентилей\n",
    "    max: максимальное значение из столбца\n",
    "\n",
    "Процентиль – это значение, которое заданная случайная величина не превышает с фиксированной вероятностью, заданной в процентах."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8a0d6266",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.Age.hist(bins = 25)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5222017b",
   "metadata": {},
   "source": [
    "**Описание массива нечисловых данных**\n",
    "\n",
    "В качестве базовой описательной статистики для категориальных признаков можно использовать следующий набор характеристик:\n",
    "\n",
    "- количество уникальных представителей массива\n",
    "\n",
    "- частоты встречаемости этих представителей\n",
    "\n",
    "- наиболее часто встречающиеся представители (мода распределения)\n",
    "\n",
    "- наиболее редко встречающиеся представители"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3e0823d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.Pclass.unique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a237f0e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.Pclass.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "572fd8d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.Pclass.mode()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "658de00a",
   "metadata": {},
   "source": [
    "## Работа с пропущенными значениями."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb67c7e7",
   "metadata": {},
   "source": [
    "Вернемся к info(). Из 891 наблюдения у нас только 714 ненулевых значений. Значит, у этих пассажиров возраст неизвестен."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bc75b7f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "caa73617",
   "metadata": {},
   "outputs": [],
   "source": [
    "data['Age'].median()  # Вспомним какая у нас медиана"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "40f4b773",
   "metadata": {},
   "outputs": [],
   "source": [
    "data['Age_Median'] = data['Age'].fillna(data['Age'].median())  # Сохраняю результат заполнения в новую колонку"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "92a3fe44",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.head()  # А у всех остальных – их нормальный возраст"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0056c568",
   "metadata": {},
   "source": [
    "Или можно просто удалить пропущенные значения:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9b82b4b8",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.dropna()  # По всем колонкам"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e52d3bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.dropna(subset = [\"Age\"])  # По одному столбцу"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c06e94fd",
   "metadata": {},
   "source": [
    "Сгруппируем данные по столбцу Survived (выжил пассажир (1) или нет (0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fbcdd8a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.groupby([\"Survived\"]).groups"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d65fe059",
   "metadata": {},
   "source": [
    "Подсчитаем средний возраст по каждой группе"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4cba445f",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.groupby([\"Survived\"])[[\"Age\"]].mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9368e32",
   "metadata": {},
   "source": [
    "Найдем в каждой группе самого пожилого человека и с самое большое количество сопровождающих. Для этого воспользуемся agg(), чтобы применить несколько функций"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c8433fb5",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.groupby([\"Survived\"]).agg({\"SibSp\":max, \"Age\":max})"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f877172",
   "metadata": {},
   "source": [
    "Изменим название городов, вместо букв будет полное название"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "051d69a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "data[\"Port\"] = data[\"Embarked\"].apply(lambda x: \"Шербур\" if x == \"C\" else (\"Саутгемптон\" if x == \"S\" else \"Квинстаун\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6cd535d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fb7f6312",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.pivot_table(\"Survived\", index = \"Pclass\", columns = \"Sex\")  # Создадим сводную таблицу"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24d1e87d",
   "metadata": {},
   "source": [
    "Количество выживших в зависимости от класса, порта посадки и пола"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b747aef",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.pivot_table(\"Survived\", index = [\"Pclass\", \"Port\"], columns = \"Sex\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c75b39f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "table = data.pivot_table(\"Survived\", index = \"Pclass\", columns = \"Sex\")\n",
    "table.plot();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65424130",
   "metadata": {},
   "source": [
    "# Pandas – работа с несколькими файлами"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5950f845",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c2a41614",
   "metadata": {},
   "outputs": [],
   "source": [
    "eur = pd.read_csv(\"_add_material_lesson_python\\eur_quotes.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7cc06723",
   "metadata": {},
   "outputs": [],
   "source": [
    "eur = pd.read_csv(\"_add_material_lesson_python\\eur_quotes.csv\", sep = \";\")\n",
    "eur"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4a6d2e20",
   "metadata": {},
   "outputs": [],
   "source": [
    "eur.rename(columns = {\"price\": \"eur\"}, inplace = True)\n",
    "eur"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6b91df9b",
   "metadata": {},
   "outputs": [],
   "source": [
    "usd = pd.read_csv(\"_add_material_lesson_python\\usd_quotes.csv\", sep = \";\")\n",
    "usd.rename(columns = {\"price\": \"usd\"}, inplace = True)\n",
    "usd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75e27a80",
   "metadata": {},
   "outputs": [],
   "source": [
    "jpy = pd.read_csv(\"_add_material_lesson_python\\jpy_quotes.csv\", sep = \";\")\n",
    "jpy.rename(columns = {\"price\": \"jpy\"}, inplace = True)\n",
    "jpy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f42f8570",
   "metadata": {},
   "source": [
    "## Объединение по дате"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1fd9599d",
   "metadata": {},
   "outputs": [],
   "source": [
    "result = pd.merge(eur,\n",
    "                 usd,\n",
    "                 on = 'updated')\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fa1e3e4",
   "metadata": {},
   "source": [
    "Посмотрим на размерности получившихся таблиц:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3520b282",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"eur размерности: {}\".format(eur.shape))\n",
    "print(\"usd размерности: {}\".format(usd.shape))\n",
    "print(\"Разность: {}\".format(usd.shape[0] - eur.shape[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13c3c4a3",
   "metadata": {},
   "source": [
    "Сравнение таблиц eur и usd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8dbb3c7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "eur['updated'].isin(usd['updated']).value_counts()  # Даты которые есть в таблице eur, но нет в таблице usd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fdc73003",
   "metadata": {},
   "outputs": [],
   "source": [
    "usd['updated'].isin(eur['updated']).value_counts()  # Даты которые есть в таблице usd, но нет в таблице eur"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02ba7739",
   "metadata": {},
   "source": [
    "Сравнение таблиц jpy и usd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "000f69e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "usd['updated'].isin(jpy['updated']).value_counts()  # Даты которые есть в таблице usd, но нет в таблице jpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e607c98f",
   "metadata": {},
   "outputs": [],
   "source": [
    "jpy['updated'].isin(usd['updated']).value_counts()  # Даты которые есть в таблице jpy, но нет в таблице usd"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d26e5cb2",
   "metadata": {},
   "source": [
    "Сравнение таблиц jpy и eur"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d6c21da0",
   "metadata": {},
   "outputs": [],
   "source": [
    "eur['updated'].isin(jpy['updated']).value_counts()  # Даты которые есть в таблице eur, но нет в таблице jpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3fa88997",
   "metadata": {},
   "outputs": [],
   "source": [
    "jpy['updated'].isin(eur['updated']).value_counts()  # Даты которые есть в таблице jpy, но нет в таблице eur"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "160c95b1",
   "metadata": {},
   "source": [
    "## Left merge"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3b662271",
   "metadata": {},
   "outputs": [],
   "source": [
    "result = pd.merge(jpy,\n",
    "                 eur,\n",
    "                 on = 'updated', how = 'left')\n",
    "print(\"eur размерностиs: {}\".format(eur.shape))\n",
    "print(\"jpy размерности: {}\".format(jpy.shape))\n",
    "print(\"result размерности: {}\".format(result.shape))\n",
    "print(\"Всего {} пропущенных значений.\".format(\n",
    "        result['eur'].isnull().sum()))\n",
    "\n",
    "# Все те даты которые были в левой таблице останутся. Для тех значений, которые отсутствуют в правой будет стоять Nan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "52b7cefe",
   "metadata": {},
   "outputs": [],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a74fd8df",
   "metadata": {},
   "source": [
    "## Right merge "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "557fdcb1",
   "metadata": {},
   "outputs": [],
   "source": [
    "result = pd.merge(jpy,\n",
    "                 eur,\n",
    "                 on = 'updated', how = 'right')\n",
    "print(\"eur размерностиs: {}\".format(eur.shape))\n",
    "print(\"jpy размерностиs: {}\".format(jpy.shape))\n",
    "print(\"result размерности: {}\".format(result.shape))\n",
    "print(\"Всего {} пропущенных значений.\".format(\n",
    "        result['jpy'].isnull().sum()))\n",
    "\n",
    "# Все те даты которые были в правой таблице останутся. Для тех значений, которые отсутствуют в левой будет стоять Nan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "360f80c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10c94004",
   "metadata": {},
   "source": [
    "## Outer merge "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4431142",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Всего {} уникальных значений для updated.\".format(\n",
    "        pd.concat([jpy['updated'], eur['updated']]).unique().shape[0]))\n",
    "\n",
    "result = pd.merge(jpy,\n",
    "                 eur,\n",
    "                 on = 'updated', how = 'outer', indicator = True)\n",
    "\n",
    "print(\"Получаем в таблице {} строк.\".format(result.shape))\n",
    "\n",
    "# Забираем данные из обеих таблиц, если данных нет, то ставим пропуски"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4601aa96",
   "metadata": {},
   "outputs": [],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "764c3cbb",
   "metadata": {},
   "source": [
    "## Final merge"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42b0be56",
   "metadata": {},
   "source": [
    "Если необходимо выполнить merge для трех и более таблиц, то это делается поэтапно, сначала две, потом к полученному результату третью и т.д."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "20572116",
   "metadata": {},
   "outputs": [],
   "source": [
    "result = pd.merge(jpy,\n",
    "                 eur,\n",
    "                 on = 'updated')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7bd5c508",
   "metadata": {},
   "outputs": [],
   "source": [
    "result = pd.merge(result,\n",
    "                 usd,\n",
    "                 on = 'updated')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dfef48b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ba61a4a",
   "metadata": {},
   "outputs": [],
   "source": [
    "result.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "30d77014",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.dates as mdates\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "863b8c7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(result[\"updated\"], result[\"jpy\"])\n",
    "plt.plot(result[\"updated\"], result[\"eur\"])\n",
    "plt.plot(result[\"updated\"], result[\"usd\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cfa5a1a0",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax.plot(result['updated'], result['jpy'], label = 'JPY')\n",
    "ax.plot(result['updated'], result['eur'], label = 'EUR')\n",
    "ax.plot(result['updated'], result['usd'], label = 'USD')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c66202d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "result_2 = result[::-1]\n",
    "result_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f899fd2",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax.plot(result_2['updated'], result_2['jpy'], label = 'JPY')\n",
    "ax.plot(result_2['updated'], result_2['eur'], label = 'EUR')\n",
    "ax.plot(result_2['updated'], result_2['usd'], label = 'USD')\n",
    "\n",
    "# Добавление легенды\n",
    "plt.legend()\n",
    "\n",
    "# Установка названия оси X\n",
    "ax.set_xlabel('Date')\n",
    "\n",
    "# Установка названия оси Y\n",
    "ax.set_ylabel('Currency')\n",
    "\n",
    "# Установка заголовка графика\n",
    "plt.title('Currency Rates')\n",
    "\n",
    "# Отображение сетки\n",
    "plt.grid(True)\n",
    "\n",
    "ax.xaxis.set_major_locator(mdates.DayLocator(interval = 180))\n",
    "ax.tick_params(axis = 'x', labelrotation = 90)\n",
    "\n",
    "# Отображение графика\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}