{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!-- dom:TITLE: Введение в библиотеку `pandas` -->\n",
    "# Введение в библиотеку `pandas`\n",
    "<!-- dom:AUTHOR: С.В. Лемешевский Email:sergey.lemeshevsky@gmail.com at Институт математики НАН Беларуси -->\n",
    "<!-- Author: -->  \n",
    "**С.В. Лемешевский** (email: `sergey.lemeshevsky@gmail.com`), Институт математики НАН Беларуси\n",
    "\n",
    "Date: **Mar 31, 2020**\n",
    "\n",
    "Библиотека `pandas` содержит структуры данных и инструменты\n",
    "управления данными, предназначенные для очистки данных и быстрого и\n",
    "простого анализа данных в Python. Библиотека `pandas` часто\n",
    "используется в тандеме с инструментами для численных расчетов, такими\n",
    "как NumPy и SciPy, библиотеками для анализа данных, такими как\n",
    "`statmodels` и `scikit-learn`, и библиотеками для визуализации, такими\n",
    "как `matplotlib`.\n",
    "\n",
    "Ниже будем использовать следующее соглашение для импорта библиотеки\n",
    "`pandas`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!-- Common Mako variable and functions -->\n",
    "<!-- -*- coding: utf-8 -*- -->\n",
    "\n",
    "\n",
    "\n",
    "# Структуры данных в `pandas`\n",
    "<div id=\"pandas:data-struct\"></div>\n",
    "\n",
    "Чтобы начать работать с `pandas`, рассмотрим две основные структуры:\n",
    "`Series` и `DataFrame`. Они не являются универсальными решениями любых\n",
    "задач, однако эти структуры предоставляют прочный легкий в\n",
    "использовании фундамент для большинства приложений."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Класс `Series`\n",
    "<div id=\"pandas:data-struct:series\"></div>\n",
    "\n",
    "`Series` (*ряд*) — объект, типа одномерного массива, содержащий\n",
    "последовательность значений (типов, аналогичных типам NumPy) и\n",
    "связанный с ним массив меток данных,\n",
    "называемых *индексами*. Создадим простейший объект типа `Series`\n",
    "только из массива данных:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj = pd.Series([4, 7, -5, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Строковое представление объекта `Series` в интерактивном режиме\n",
    "отображает индексы слева, а данные справа. Так как мы не определили\n",
    "индексы, то по умолчанию индексы содержат целые числа от `0` до `N-1`\n",
    "(где `N` — длина массива данных). Можно получить представление в виде\n",
    "массива и индексы ряда с помощью атрибутов `values` и `index`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj.index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Часто желательно создать ряд с индексами, идентифицирующими каждую\n",
    "точку данный с меткой:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj2 = pd.Series([4, 7, -5, 3], index=['d', 'b', 'a', 'c'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj2.index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В отличие от массивов NumPy, можно использовать метки при индексации\n",
    "при выборе отдельных значений или набора значений:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj2['a']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj2['d'] = 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj2[['c', 'a', 'd']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Использование функций NumPy или операций подобных NumPy, таких как\n",
    "фильтрация с помощью булевых массивов, умножение на скаляр или\n",
    "вычисление математических функций, сохраняет значения индексов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj2[obj2 > 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj2 * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "np.exp(obj2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ряды можно рассматривать как словари фиксированной длины:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "'b' in obj2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "'e' in obj2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если имеются данные, содержащиеся в словаре, можно создать ряд из\n",
    "него:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj3 = pd.Series(sdata)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если передается только словарь, то индексами ряда будут ключи словаря\n",
    "в том порядке, в котором были при создании словаря. Можно изменить\n",
    "порядок индекса передавая ключи словаря в порядке, который нужен:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "states = ['California', 'Ohio', 'Oregon', 'Texas']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj4 = pd.Series(sdata, index=states)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Здесь три значения, найденные в `sdata`, были размещены в\n",
    "соответствующих местах, но так как не было найдено значение для\n",
    "`'California'`, оно отображается как `NaN` (не число), которое в\n",
    "`pandas` используется для обозначение пропущенных значений или\n",
    "значений «NA» (*not available*). Поскольку `'Юта'` не была включена в `states`,\n",
    "этот элемент исключается из результирующего объекта. Функции `isnull`\n",
    "и `notnull` в `pandas` используются для обнаружения отсутствующих\n",
    "данных:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "pd.isnull(obj4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "pd.notnull(obj4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Класс `Series` также имеет эти методы:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj4.isnull()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Полезное свойство `Series` заключается в том, что она автоматически\n",
    "происходит выравнивание по индексам в арифметических операциях:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj3 + obj4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как объекты `Series`, так и из индексы имеют атрибут `name`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj4.name = 'population'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj4.index.name = 'state'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можно изменять индексы рядов присваиванием:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj.index = ['Bob', 'Steve', 'Jeff', 'Ryan']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Класс `DataFrame`\n",
    "<div id=\"pandas:data-struct:df\"></div>\n",
    "\n",
    "`DataFrame` представляет собой прямоугольную таблицу данных и содержит\n",
    "упорядоченную коллекцию столбцов, каждый из которых может иметь\n",
    "различный тип значения (числовой, строковый, логический и\n",
    "т.д.). `DataFrame` имеет индексы столбцов и строк.\n",
    "\n",
    "Есть много способов создания объекта `DataFrame`, хотя один из\n",
    "наиболее распространенных — это использование списков, словарей или\n",
    "массивов NumPy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada', 'Nevada'],\n",
    "        'year': [2000, 2001, 2002, 2001, 2002, 2003], \n",
    "        'pop': [1.5, 1.7, 3.6, 2.4, 2.9, 3.2]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame = pd.DataFrame(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Полученный в результате `DataFrame` получит автоматически индексацию\n",
    "для строк (как в `Series`), а индексом столбцов будут ключи словаря:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если используется блокнот Jupyter, объекты `DataFrame` будут\n",
    "отображаться в виде более удобной для просмотра HTML-таблицы.\n",
    "\n",
    "Для больших DataFrames метод head выбирает только первые пять строк:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можно задавать другой порядок столбцов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "pd.DataFrame(data, columns=['year', 'state', 'pop'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если передать столбец, который не содержится в словаре, то в\n",
    "результате будет столбец с отсутствующими значениями:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame2 = pd.DataFrame(data, columns=['year', 'state', 'pop', 'debt'], index=['one', 'two', 'three', 'four', 'five', 'six'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame2.columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "К столбцу `DataFrame` можно получить доступ как к ряду с помощью\n",
    "нотацией подобной словарю или через атрибут:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame2['state']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame2.year"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Замечание.**\n",
    ">\n",
    "> IPython предоставлет доступ по атрибуту (например, `frame2.year`) \n",
    "> по автодополнению с помощью клавиши <TAB>.\n",
    "> \n",
    "> Вариант `frame2[column]` работает для любых имен столбцов, в то время\n",
    "> как `frame2.column` работает только если имя столбца является\n",
    "> допустимым в Python именем переменной.\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "К строкам можно получить доступ по позиции или с помощью специального\n",
    "атрибута `loc`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame2.loc['three']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можно менять значения столбцов. Например, пустой столбцу `debt` можно\n",
    "присвоить скалярное значение или массив:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame2['debt'] = 16.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame2['debt'] = np.arange(6.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При присваивании столбцу списка или массива, их длина должна быть той\n",
    "же, что и длина `DataFrame`. Если присваивать объект `Series`, то его\n",
    "метки будут выровнены по индексу `DataFrame`, при этом будут\n",
    "вставляться отсутствующие значения для любых «дыр»:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "val = pd.Series([-1.2, -1.5, -1.7], index=['two', 'four', 'five'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame2['debt'] = val"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При присваивании отсутствующего столбца в объекте `DataFrame`\n",
    "добавится новый столбец. Ключевое слово `del` удаляет столбец, как и\n",
    "для словарей:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame2['eastern'] = frame2.state == 'Ohio'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Предупреждение.**\n",
    ">\n",
    "> Новый столбец не может быть добавлен с помощью синтаксиса `frame2.eastern`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "del frame2['eastern']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame2.columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Предупреждение.**\n",
    ">\n",
    "> Столбец, возвращаемый при индексации `DataFrame`, является\n",
    "> представлением данных, а не копией. Таким образом, любые\n",
    "> изменения в объекте `Series` будут отражены в объекте\n",
    "> `DataFrame`. Столбец можно явно скопировать с помощью метода\n",
    "> `Series.copy`.\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "Другой распространенной формой представления данных является вложенный\n",
    "словарь словарей:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "pop = {'Nevada': {2001: 2.4, 2002: 2.9}, 'Ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если вложенный словарь передать в конструктор `DataFrame`, `pandas`\n",
    "интерпретирует ключи внешнего словаря как столбцы, а внутренние ключи\n",
    "— как индексы:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame3 = pd.DataFrame(pop)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можно транспонировать `DataFrame`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame3.T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можно задать порядок индексов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "pd.DataFrame(pop, index=[2001, 2002, 2003])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Словари рядов обрабатываются практически также:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "pdata = {'Ohio': frame3['Ohio'][:-1], 'Nevada': frame3['Nevada'][:2]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "pd.DataFrame(pdata)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Полный список параметров, которые можно передавать в конструктор\n",
    "`DataFrame`, можно найти в таблице [pandas:data-struct:tbl:1](#pandas:data-struct:tbl:1).\n",
    "\n",
    "Если для индекса и столбцов DataFrame установлены атрибуты `name`, они\n",
    "также будут отображены:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame3.index.name = 'year'; frame3.columns.name = 'state'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как и в случае `Series`, атрибут `values` возвращает данные,\n",
    "содержащиеся в `DataFrame`, в виде двумерного массива:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame3.values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Таблица 1 : Возможные входные данные для конструктора `DataFrame` <div id=\"pandas:data-struct:tbl:1\"></div>\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "<table border=\"1\">\n",
    "<thead>\n",
    "<tr><th align=\"left\">                        Тип                        </th> <th align=\"left\">                                                                         Примечания                                                                        </th> </tr>\n",
    "</thead>\n",
    "<tbody>\n",
    "<tr><td align=\"left\">   Двумерный <code>ndarray</code>                                    </td> <td align=\"left\">   Матрица данных, передающаяся с необязательными метками строк и столбцов                                                                                        </td> </tr>\n",
    "<tr><td align=\"left\">   <code>dict</code> массивов, <code>list</code>, <code>tuple</code>                       </td> <td align=\"left\">   Каждая последовательность становится столбцом в <code>DataFrame</code>. Все последовательности должны быть одинаковой длины                                               </td> </tr>\n",
    "<tr><td align=\"left\">   Структурированный массив (или массив записей) NumPy    </td> <td align=\"left\">   Обрабатывается как предыдущий случай                                                                                                                           </td> </tr>\n",
    "<tr><td align=\"left\">   <code>dict</code> объектов типа <code>Series</code>                          </td> <td align=\"left\">   Каждое значение становится столбцом. Индексы из каждой серии объединяются вместе, чтобы сформировать индекс строки результата, если не передан явный индекс    </td> </tr>\n",
    "<tr><td align=\"left\">   <code>dict</code> объектов типа <code>dict</code>                            </td> <td align=\"left\">   Каждый внутренний словарь становится столбцом. Ключи объединяются для формирования индекса строки, как в предыдущем случае                                     </td> </tr>\n",
    "<tr><td align=\"left\">   <code>list</code> объектов <code>dict</code> или <code>Series</code>                    </td> <td align=\"left\">   Каждый элемент становится строкой в <code>DataFrame</code>. Оббъединение ключей <code>dict</code> или индексов <code>Series</code> становится метками столбцов <code>DataFrame</code>                      </td> </tr>\n",
    "<tr><td align=\"left\">   <code>list</code> объектов <code>list</code> или <code>tuple</code>                     </td> <td align=\"left\">   Обрабатывается как случай двумерного массива                                                                                                                   </td> </tr>\n",
    "<tr><td align=\"left\">   <code>DataFrame</code>                                            </td> <td align=\"left\">   Используются индексы <code>DataFrame</code> , если не переданы другие                                                                                                     </td> </tr>\n",
    "<tr><td align=\"left\">   маскированный массив NumPy                             </td> <td align=\"left\">   Как случай двумерного массива, за исключением того, что маскированные значения становятся пропущенными (NA) значениями в итоговом <code>DataFrame</code>                  </td> </tr>\n",
    "</tbody>\n",
    "</table>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Объекты типа `Index`\n",
    "<div id=\"pandas:data-struct:index\"></div>\n",
    "\n",
    "Объекты типа `Index` в `pandas` отвечают за хранение меток осей и\n",
    "других метаданных (таких как имя или имя оси). \n",
    "\n",
    "Любой массив или другая последовательность меток, которые используются\n",
    "при создании `Series` или `DataFrame`, преобразуется в `Index`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj = pd.Series(range(3), index=['a', 'b', 'c'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "index = obj.index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "index[1:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Объекты `Index` — неизменяемый тип и не может изменяться\n",
    "пользователем:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "index[1] = 'd'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Неизменяемость делает более безопасным совместное использование объектов\n",
    "`Index`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "labels = pd.Index(np.arange(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj2 = pd.Series([1.5, -2.5, 0], index=lables)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj2.index is lables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "С объектами `Index` можно работать как с массивами фиксированного\n",
    "размера:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame3.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "'Ohio' in frame3.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "2003 in frame3.index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В отличие от множеств Python объекты `Index` могут содержать\n",
    "повторяющиеся метки:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "dup_labels = pd.Index(['foo', 'foo', 'bar', 'bar'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "dup_labels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Каждый объект `Index` имеет ряд методов и свойств. Некоторые полезные\n",
    "из них приведены в таблице [pandas:data-struct:tbl:2](#pandas:data-struct:tbl:2). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Таблица 2 : Некоторые методы и свойства `Index` <div id=\"pandas:data-struct:tbl:2\"></div>\n",
    "\n",
    "\n",
    "<table border=\"1\">\n",
    "<thead>\n",
    "<tr><th align=\"left\">    Метод     </th> <th align=\"left\">                                            Описание                                           </th> </tr>\n",
    "</thead>\n",
    "<tbody>\n",
    "<tr><td align=\"left\">   <code>append</code>          </td> <td align=\"left\">   Добавляет дополнительные объекты <code>Index</code>, создавая новый объект <code>Index</code>                            </td> </tr>\n",
    "<tr><td align=\"left\">   <code>difference</code>      </td> <td align=\"left\">   Возвращает разность множеств как <code>Index</code>                                                           </td> </tr>\n",
    "<tr><td align=\"left\">   <code>intersection</code>    </td> <td align=\"left\">   Возвращает пересечение множеств                                                                    </td> </tr>\n",
    "<tr><td align=\"left\">   <code>union</code>           </td> <td align=\"left\">   Возвращает объединение множеств                                                                    </td> </tr>\n",
    "<tr><td align=\"left\">   <code>isin</code>            </td> <td align=\"left\">   Возвращает логический массив, указывающий, содержится ли каждое значение в переданной коллекции    </td> </tr>\n",
    "<tr><td align=\"left\">   <code>delete</code>          </td> <td align=\"left\">   Возвращает новый объект <code>Index</code> с удаленным элементом по индексу <code>i</code>                               </td> </tr>\n",
    "<tr><td align=\"left\">   <code>drop</code>            </td> <td align=\"left\">   Возвращает новый объект <code>Index</code>, удаляя переданные значения                                        </td> </tr>\n",
    "<tr><td align=\"left\">   <code>insert</code>          </td> <td align=\"left\">   Возвращает новый объект <code>Index</code>, вставляя по индексу <code>i</code> элемент                                   </td> </tr>\n",
    "<tr><td align=\"left\">   <code>is_monotonic</code>    </td> <td align=\"left\">   Возвращает <code>True</code>, если каждый элемент больше либо равен предыдущего                               </td> </tr>\n",
    "<tr><td align=\"left\">   <code>is_unique</code>       </td> <td align=\"left\">   Возвращает <code>True</code>, если объект <code>Index</code> не содержит дупликатов                                      </td> </tr>\n",
    "<tr><td align=\"left\">   <code>unique</code>          </td> <td align=\"left\">   Возвращает массив уникальных занчений в объекте <code>Index</code>                                            </td> </tr>\n",
    "</tbody>\n",
    "</table>\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "<!-- Local Variables: -->\n",
    "<!-- doconce-chapter-nickname: \"pandas\" -->\n",
    "<!-- doconce-section-nickname: \"data-struct\" -->\n",
    "<!-- End: -->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Основная функциональность\n",
    "<div id=\"pandas:functionality\"></div>\n",
    "\n",
    "Приведем основные подходы к работе с данными, содержащимися в `Series`\n",
    "и `DataFrame`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Переиндексация\n",
    "<div id=\"pandas:functionality:reindex\"></div>\n",
    "\n",
    "Важный метод в объектах `pandas` — это `reindex`, который создает\n",
    "новый объект с данными, согласованными с новым индексом. Рассмотрим\n",
    "пример:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj = pd.Series([4.5, 7.2, -5.3, 3.6], index=['d', 'b', 'a', 'c'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вызов `reindex` в объекте `Series` переупорядочивает данные в\n",
    "соответствии с новым индексом, вводя пропущенные значения, если\n",
    "какие-либо значения индекса еще не присутствовали:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj2 = obj.reindex(['a', 'b', 'c', 'd', 'e'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ля упорядоченных данных, таких как временные ряды, может быть\n",
    "желательно выполнить некоторую интерполяцию или заполнение значений\n",
    "при переиндексации. Аргумент `method` позволяет нам сделать это,\n",
    "используя метод такой как `ffill` (forward-fill), который заполняет\n",
    "«вперед» значениями ряд:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj3 = pd.Series(['blue', 'purple', 'yellow'], index=[0, 2, 4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj3.reindex(range(6), method='ffill')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В объектах `DataFrame` метод `reindex` может изменять либо индекс\n",
    "(строки), столбцы, либо и то и то. Когда передается только одна\n",
    "последовательность, то переиндексируются строки:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame = pd.DataFrame(np.arange(9).reshape((3, 3)), index=['a', 'c', 'd'], columns=['Ohio', 'Texas', 'California'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame2 = frame.reindex(['a', 'b', 'c', 'd'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Столбцы переиндексируются с помощью аргумента `columns`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "states = ['Texas', 'Utah', 'California']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame.reindex(columns=states)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В таблице [pandas:functionality:tbl:1](#pandas:functionality:tbl:1) представлены аргументы\n",
    "функции `reindex`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Таблица 3 : Аргументы функции `reindex` <div id=\"pandas:functionality:tbl:1\"></div>\n",
    "\n",
    "\n",
    "<table border=\"1\">\n",
    "<thead>\n",
    "<tr><th align=\"left\">  Аргумент  </th> <th align=\"left\">                                                                  Описание                                                                  </th> </tr>\n",
    "</thead>\n",
    "<tbody>\n",
    "<tr><td align=\"left\">   <code>index</code>         </td> <td align=\"left\">   Новая последовательность для использования в качестве индекса. Может быть экземпляром <code>Index</code> или любой последовательности Python               </td> </tr>\n",
    "<tr><td align=\"left\">   <code>method</code>        </td> <td align=\"left\">   Метод интерполяции (заполнения): <code>ffil</code> (forward-fill) — прямое заполнение, <code>bfill</code> (backward-fill) — обратное заполнение                       </td> </tr>\n",
    "<tr><td align=\"left\">   <code>fill_value</code>    </td> <td align=\"left\">   Подставляется это значения при заполнении пропущенных данных, которые появляются при переиндексации                                             </td> </tr>\n",
    "<tr><td align=\"left\">   <code>limit</code>         </td> <td align=\"left\">   При заполнении задает максимальный размер шага (по количеству элементов) заполнения                                                             </td> </tr>\n",
    "<tr><td align=\"left\">   <code>tolerance</code>     </td> <td align=\"left\">   При заполнении задает максимальный размер шага (в абсолютном числовом расстоянии) для заполнения неточных совпадений                            </td> </tr>\n",
    "<tr><td align=\"left\">   <code>level</code>         </td> <td align=\"left\">   Сопоставляет простой <code>Index</code> на уровне <code>MultiIndex</code>; в противном случае выбирает подмножество                                                   </td> </tr>\n",
    "<tr><td align=\"left\">   <code>copy</code>          </td> <td align=\"left\">   Если <code>True</code>, всегда копирует данные, даже если новый индекс эквивалентен старому; если <code>False</code> не копирует данные, если индексы эквивалентны    </td> </tr>\n",
    "</tbody>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Удаление записей с оси\n",
    "<div id=\"pandas:functionality:drop\"></div>\n",
    "\n",
    "Удалить одну или несколько записей легко, если имеется массив или\n",
    "список индексов, которые не содержат эти записи. Поскольку это может\n",
    "потребовать некоторых операций над множествами, метод `drop`\n",
    "возвращает новый объект с указанными значениями, удаленными с оси:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj = pd.Series(np.arange(5.), index=['a', 'b', 'c', 'd', 'e'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "new_obj = obj.drop('c')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj.drop(['d', 'c'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В `DataFrame` значения индекса могут быть удалены с любой оси:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "data = pd.DataFrame(np.arange(16).reshape((4, 4)), index=['Ohio', 'Colorado', 'Utah', 'New York'], columns=['one', 'two', 'three', 'four'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вызов `drop` с последовательностью меток удаляет значения из меток\n",
    "строк (ось `0`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "data.drop(['Colorado', 'Ohio'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Удалить значения в столбцах можно передавая параметр `axis=1` или\n",
    "`axis=columns`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "data.drop('two', axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "data.drop(['two', 'four'], axis='columns')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Многие функции, такие как `drop`, которые изменяют размер или форму\n",
    "`Series` или `DataFrame`, могут изменять сам объект (*in-place*) без\n",
    "создания нового объекта:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj.drop('c', inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Предупреждение.**\n",
    ">\n",
    "> Будьте осторожны с параметром `inplace`, так как происходит **удаление**\n",
    "> данных.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Арифметические операции и выравнивание данных\n",
    "<div id=\"pandas:functionality:arithm\"></div>\n",
    "\n",
    "Важной особенностью `pandas` для некоторых приложений является поведение\n",
    "арифметических операций между объектами с разными индексами. При\n",
    "сложении объекты в случае, когда любые пары индексов отличаются,\n",
    "соответствующий индекс в результате является объединением исходных\n",
    "индексов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "s1 = pd.Series([7.3, -2.5, 3.4, 1.5], index=['a', 'c', 'd', 'e'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "s2 = pd.Series([-2.1, 3.6, -1.5, 4, 3.1], index=['a', 'c', 'e', 'f', 'g'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "s1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "s2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "s1 + s2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Выравнивание данных вводит пропущенные значения в местах\n",
    "меток, которые не пересекаются. Пропущенные значения будут\n",
    "распространяться в дальнейших арифметических вычислениях.\n",
    "\n",
    "В случае `DataFrame` выравнивание осуществляется как для строк, так и\n",
    "для столбцов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "df1 = pd.DataFrame(np.arange(9.).reshape((3, 3)), columns=list('bcd'), \n",
    "      \t           index=['Ohio', 'Texas', 'Colorado'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "df2 = pd.DataFrame(np.arange(12.).reshape((4, 3)), columns=list('bde'), \n",
    "               \t   index=['Utah', 'Ohio', 'Texas', 'Oregon'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "df1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "df2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Сумма введенных объектов вернет новый объект `DataFrame`, чьи индексы\n",
    "и столбцы являются объединениями индексов и столбцов двух складываемых\n",
    "объектов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "df1 + df2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Так как столбцы `'c'` и `'e'` не находятся одновременно в обоих\n",
    "объектах `DataFrame`, в результате они содержат отсутствующие\n",
    "значения. Такое же происходит и со строками.\n",
    "\n",
    "Если сложить объекты `DataFrame` без общих меток столбцов или строк,\n",
    "результат будет содержать все отсутствующие значения:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "df1 = pd.DataFrame({'A': [1, 2]})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "df2 = pd.DataFrame({'B': [3, 4]})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "df1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "df2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "df1 - df2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Арифметические методы с заполнением значений\n",
    "\n",
    "<div id=\"pandas:functionality:aritm:fill\"></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "df1 = pd.DataFrame(np.arange(12.).reshape((3, 4)), columns=list('abcd'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "df2 = pd.DataFrame(np.arange(20.).reshape((4, 5)), columns=list('abcde'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "df2.loc[1, 'b'] = np.nan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "df1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "df2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Сложение этих объектов приводит к значениям NA в местах, которые не\n",
    "перекрываются:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "df1 + df2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для заполнения отсутствующих значений можно воспользоваться функцией\n",
    "`add` с дополнительным аргументом `fill_value`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "df1.add(df2, fill_value=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В таблице [pandas:functionality:tbl:2](#pandas:functionality:tbl:2) представлены методы для\n",
    "арифметических операций. У каждого из них есть аналог, начинающийся с\n",
    "буквы `r`, у которого переставлены  аргументы. Приведенные ниже\n",
    "примеры эквивалентны:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "1 / df1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "df1.rdiv(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Соответственно, при переиндексации `Series` или `DataFrame` вы также\n",
    "можете указать другое значение заполнения:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "df1.reindex(columns=df2.columns, fill_value=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Таблица 4 : Гибкие арифметические методы <div id=\"pandas:functionality:tbl:2\"></div>\n",
    "\n",
    "\n",
    "<table border=\"1\">\n",
    "<thead>\n",
    "<tr><th align=\"left\">         Метод         </th> <th align=\"left\">          Описание          </th> </tr>\n",
    "</thead>\n",
    "<tbody>\n",
    "<tr><td align=\"left\">   <code>add</code>, <code>radd</code>              </td> <td align=\"left\">   Сложение (<code>+</code>)                  </td> </tr>\n",
    "<tr><td align=\"left\">   <code>sub</code>, <code>rsub</code>              </td> <td align=\"left\">   Вычитание (<code>-</code>)                 </td> </tr>\n",
    "<tr><td align=\"left\">   <code>div</code>, <code>rdiv</code>              </td> <td align=\"left\">   Деление (<code>/</code>)                   </td> </tr>\n",
    "<tr><td align=\"left\">   <code>floordiv</code>, <code>rfloordiv</code>    </td> <td align=\"left\">   Целочисленное деление (<code>//</code>)    </td> </tr>\n",
    "<tr><td align=\"left\">   <code>mul</code>, <code>rmul</code>              </td> <td align=\"left\">   Умножение (<code>*</code>)                 </td> </tr>\n",
    "<tr><td align=\"left\">   <code>pow</code>, <code>rpow</code>              </td> <td align=\"left\">   Возведение в степень (<code>**</code>)     </td> </tr>\n",
    "</tbody>\n",
    "</table>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Операции между объектами `DataFrame` и `Series`\n",
    "<div id=\"pandas:functionality:df-s\"></div>\n",
    "\n",
    "Как и для массивов NumPy разной размерности, существуют арифметические\n",
    "операции между объектами `DataFrame` и `Series`. В качестве примера\n",
    "рассмотрим разность между двумерным массивом и одной из его строк:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "arr = np.arange(12.).reshape((3, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "arr[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "arr - arr[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При вычитании `arr[0]` из `arr`, операция осуществляется для каждой\n",
    "строки. Операции между `DataFrame` и `Series` производятся аналогично."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame = pd.DataFrame(np.arange(12.).reshape((4, 3)), \n",
    "                     columns=list('bde'), \n",
    "                     index=['Utah', 'Ohio', 'Texas', 'Oregon'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "series = frame.iloc[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "series"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "По умолчанию арифметические операции между `DataFrame` и `Series`\n",
    "приводят индексы объекта `Series` к столбцам объекта `DataFrame`,\n",
    "распространяя операцию по строкам:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame - series"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если значение индекса не найдено ни в столбцах `DataFrame`, ни в индексе\n",
    "`Series`, объекты будут переиндексированы для формирования\n",
    "объединения:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "series2 = pd.Series(range(3), index=['b', 'e', 'f'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame + series2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если вместо согласования по столбцам нужно согласовывать операцию по\n",
    "строкам, нужно использовать арифметический метод:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "series3 = frame['d']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "series3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame.sub(series3, axis='index')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Применение функций и отображение\n",
    "<div id=\"pandas:functionality:fuc\"></div>\n",
    "\n",
    "Универсальные функции NumPy также работают с объектами `pandas`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame = pd.DataFrame(np.random.randn(4, 3), columns=list('bde'), index=['Utah', 'Ohio', 'Texas', 'Oregon'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "np.abs(frame)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Другой частой операцией является применение функции к одномерным\n",
    "массивам для каждого столбца или строки. Метод `apply` объекта\n",
    "`DataFrame` выполняет это:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "f = lambda x: x.max() - x.min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame.apply(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В результате мы получили объект `Series`, у которого индекс совпадает\n",
    "со столбцами объекта `DataFrame`.\n",
    "\n",
    "Если задать параметр `axis = 'columns'` в функции `apply`, функция\n",
    "будет применяться к строкам:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame.apply(f, axis='columns')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Многие из наиболее распространенных статистических методов\n",
    "(например, `sum` и `mean`) являются методами `DataFrame`, поэтому \n",
    "использование `apply` не обязательно. \n",
    "\n",
    "Функция, передаваемая в `apply`, не обязана возвращать скалярное\n",
    "значение, она может также возвращать объект `Series`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "def f(x): \n",
    "    return pd.Series([x.min(), x.max()], index=['min', 'max'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame.apply(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Также можно использовать поэлементные функции. Предположим, нужно\n",
    "получить форматированную строку для каждого значения в объекте\n",
    "`frame`. Это можно реализовать с помощью функции `applymap`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "format = lambda x: '%.2f' % x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame.applymap(format)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В функции `applymap` используется метод `map` класса `Series`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame['e'].map(format)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Сортировка и ранжирование\n",
    "<div id=\"pandas:functionality:sorting\"></div>\n",
    "\n",
    "Одна из важных встроенных операций — это сортировка данных. Для того,\n",
    "чтобы выполнить лексикографическую сортировку по индексам строк или\n",
    "столбцов, можно использовать функцию `sort_index`, которая возвращает\n",
    "новый отсортированный объект:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj = pd.Series(range(4), index=['d', 'a', 'b', 'c'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj.sort_index()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Объект `DataFrame` можно сортировать по индексам на любой оси:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame = pd.DataFrame(np.arange(8).reshape((2, 4)), index=['three', 'one'], columns=['d', 'a', 'b', 'c'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame.sort_index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame.sort_index(axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Данные сортируются по возрастанию по умолчанию, но могут быть\n",
    "отсортированы также по убыванию:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame.sort_index(axis=1, ascending=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для сортировки объекта `Series` по значениям используется метод\n",
    "`sort_values`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj = pd.Series([4, 7, -3, 2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj.sort_values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Все пропущенные значения по умолчанию сортируются в конец объекта\n",
    "`Series`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj = pd.Series([4, np.nan, 7, np.nan, -3, 2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj.sort_values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При сортировке объекта `DataFrame` можно использовать данные в одном\n",
    "или нескольких столбцах в качестве ключей для сортировки. Чтобы\n",
    "выполнить это, необходимо передать имя одного или нескольких столбцов\n",
    "параметру `by` метода `sort_vlues`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame = pd.DataFrame({'b': [4, 7, -3, 2], 'a': [0, 1, 0, 1]})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame.sort_values(by='b')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для сортировки по нескольким столбцам, необходимо передать список\n",
    "имен столбцов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame.sort_values(by=['a', 'b'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Ранжирование* заключается в присвоении *ранга* от единицы до числа значений в \n",
    "массиве. Объекты `Series` и `DataFrame` имеют метод `rank`, который по\n",
    "умолчанию разрывает связи, присваивая каждой группе среднее значение\n",
    "ранга:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj = pd.Series([7, -5, 7, 4, 2, 0, 4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj.rank()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ранги также могут быть назначены в соответствии с порядком, в котором\n",
    "они наблюдаются в данных:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj.rank(method='first')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Здесь вместо использования среднего ранга $6.5$ для записей с\n",
    "индексами `0` и `2` они вместо этого были установлены на $6$ и $7$,\n",
    "потому что метка $0$ предшествует метке $2$ в данных.\n",
    "\n",
    "В таблице [pandas:functionality:tbl:3](#pandas:functionality:tbl:3) представлен перечень методов\n",
    "построения ранга.\n",
    "\n",
    "Объект `DataFrame` может вычислять ранги по строкам или по столбцам:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame = pd.DataFrame({'b': [4.3, 7, -3, 2], 'a': [0, 1, 0, 1], 'c': [-2, 5, 8, -2.5]})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame.rank(axis='columns')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Таблица 5 : Методы ранжирования <div id=\"pandas:functionality:tbl:3\"></div>\n",
    "\n",
    "\n",
    "<table border=\"1\">\n",
    "<thead>\n",
    "<tr><th align=\"left\">  Метод  </th> <th align=\"left\">                                                       Описание                                                      </th> </tr>\n",
    "</thead>\n",
    "<tbody>\n",
    "<tr><td align=\"left\">   <code>average</code>    </td> <td align=\"left\">   Используется по умолчанию. Присваивает среднее значение ранга каждому значению в группе                                  </td> </tr>\n",
    "<tr><td align=\"left\">   <code>min</code>        </td> <td align=\"left\">   Использует минимальный ранг для всей группы                                                                              </td> </tr>\n",
    "<tr><td align=\"left\">   <code>max</code>        </td> <td align=\"left\">   Использует максимальный ранг для всей группы                                                                             </td> </tr>\n",
    "<tr><td align=\"left\">   <code>first</code>      </td> <td align=\"left\">   Присваивает ранги в порядке появления значений в данных                                                                  </td> </tr>\n",
    "<tr><td align=\"left\">   <code>dense</code>      </td> <td align=\"left\">   Как <code>method = 'min'</code>, но ранги между группами всегда увеличиваются на 1, а не на количество равных элементов в группе    </td> </tr>\n",
    "</tbody>\n",
    "</table>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Индексация с повторяющимися метками\n",
    "<div id=\"pandas:functionality:dupl\"></div>\n",
    "\n",
    "В рассматриваемых выше примерах индексы имели единственные значения,\n",
    "без повторений. Хотя многие функции библиотеки `pandas` (например,\n",
    "`reindex`) требуют, чтобы метки были уникальными, это не\n",
    "обязательно. Рассмотрим ряд с повторяющимися индексами:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj = pd.Series(range(5), index=['a', 'a', 'b', 'b', 'c'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "У объекта `Index` есть атрибут `is_unique`, который дает информацию\n",
    "являются ли метки индекса уникальными:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj.index.is_unique"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В случае, когда несколько данных имеют одинаковые метки, обращение по\n",
    "этому индексу вернет объект `Series`, в то время как для меток без\n",
    "дублирования возвращается скалярное значение:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj['a']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj['c']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Та же логика распространяется и на индексирование строк в `DataFrame`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "df = pd.DataFrame(np.random.randn(4, 3), index=['a', 'a', 'b', 'b'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "df.loc['b']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!-- Local Variables: -->\n",
    "<!-- doconce-chapter-nickname: \"pandas\" -->\n",
    "<!-- doconce-section-nickname: \"functionality\" -->\n",
    "<!-- End: -->\n",
    "\n",
    "# Описательная и сводная статистика\n",
    "<div id=\"pandas:statistics\"></div>\n",
    "\n",
    "Объекты\t`pandas` оснащены набором общих математических и\n",
    "статистических методов. Большинство из них попадают в категорию\n",
    "сводной статистики. В отличие от соответствующих методов массивов\n",
    "NumPy методы объектов `pandas` имеют встроенную обработку  пропущенных\n",
    "значений. Рассмотрим небольшой объект `DataFrame`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "df = pd.DataFrame([[1.4, np.nan], [7.1, -4.5], [np.nan, np.nan], [0.75, -1.3]], index=['a', 'b', 'c', 'd'], columns=['one', 'two'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вызов метода `sum` возвращает суммы значений по столбцам:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "df.sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Чтобы получить суммы значений по строкам нужно передать параметр\n",
    "`axis='columns'` или `axis=1`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "df.sum(axis='columns')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Значения NA исключаются, если только весь срез (в данном случае строка\n",
    "или столбец) не равен NA. Это поведение можно изменить с помощью\n",
    "параметра `skipna`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "df.mean(axis='columns', skipna=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Некоторые методы, такие как `idxmin` и `idxmax`, возвращают косвенную \n",
    "статистику, такую как значение индекса, где достигаются минимальные\n",
    "или максимальные значения:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "df.idxmax()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Есть методы являются аккумулирующими:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "df.cumsum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Метод `describe` возвращает множественную суммарную статистику:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "df.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "На нечисловых данных метод `describe` возвращает следующую информацию:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj = pd.Series(['a', 'a', 'b', 'c'] * 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "obj.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В таблице [pandas:statistics:tbl:1](#pandas:statistics:tbl:1) представлен полный список\n",
    "методов сводной статистики и связанных с этим методов:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Таблица 6 : Описательная и сводная статистика <div id=\"pandas:statistics:tbl:1\"></div>\n",
    "\n",
    "\n",
    "<table border=\"1\">\n",
    "<thead>\n",
    "<tr><th align=\"left\">      Метод       </th> <th align=\"left\">                                       Описание                                       </th> </tr>\n",
    "</thead>\n",
    "<tbody>\n",
    "<tr><td align=\"left\">   <code>count</code>               </td> <td align=\"left\">   Количество нечисловых значений                                                            </td> </tr>\n",
    "<tr><td align=\"left\">   <code>describe</code>            </td> <td align=\"left\">   Вычисляет сводную статистику для ряда или для каждого столбца объекта <code>DataFrame</code>         </td> </tr>\n",
    "<tr><td align=\"left\">   <code>min</code>, <code>max</code>          </td> <td align=\"left\">   Вычисляет минимальное и максимальное значение                                             </td> </tr>\n",
    "<tr><td align=\"left\">   <code>argmin</code>, <code>argmax</code>    </td> <td align=\"left\">   Возвращают индекс (целое число), где расположено минимальное или максимальное значение    </td> </tr>\n",
    "<tr><td align=\"left\">   <code>idxmin</code>, <code>idxmax</code>    </td> <td align=\"left\">   Возвращают метку индекса, где расположено минимальное или максимальное значение           </td> </tr>\n",
    "<tr><td align=\"left\">   <code>quantile</code>            </td> <td align=\"left\">   Вычисляет квантиль выборки от 0 до 1                                                      </td> </tr>\n",
    "<tr><td align=\"left\">   <code>sum</code>                 </td> <td align=\"left\">   Сумма значений                                                                            </td> </tr>\n",
    "<tr><td align=\"left\">   <code>mean</code>                </td> <td align=\"left\">   Среднее значение                                                                          </td> </tr>\n",
    "<tr><td align=\"left\">   <code>median</code>              </td> <td align=\"left\">   Медиана (50-процентная квантиль) значений                                                 </td> </tr>\n",
    "<tr><td align=\"left\">   <code>mad</code>                 </td> <td align=\"left\">   Среднее абсолютное отклонение от среднего значения                                        </td> </tr>\n",
    "<tr><td align=\"left\">   <code>prod</code>                </td> <td align=\"left\">   Произведение значений                                                                     </td> </tr>\n",
    "<tr><td align=\"left\">   <code>var</code>                 </td> <td align=\"left\">   Дисперсия множества выборки значений                                                      </td> </tr>\n",
    "<tr><td align=\"left\">   <code>std</code>                 </td> <td align=\"left\">   Стандартное отклонение выборки значений                                                   </td> </tr>\n",
    "<tr><td align=\"left\">   <code>skew</code>                </td> <td align=\"left\">   Асимметрия (третий момент) выборки значений                                               </td> </tr>\n",
    "<tr><td align=\"left\">   <code>kurt</code>                </td> <td align=\"left\">   Эксцесс (четвертый момент) выборки значений                                               </td> </tr>\n",
    "<tr><td align=\"left\">   <code>cumsum</code>              </td> <td align=\"left\">   Накопленная сумма значений                                                                </td> </tr>\n",
    "<tr><td align=\"left\">   <code>cummin</code>, <code>cummax</code>    </td> <td align=\"left\">   Совокупный минимум и максимум                                                             </td> </tr>\n",
    "<tr><td align=\"left\">   <code>cumprod</code>             </td> <td align=\"left\">   Накопленное произведение значений                                                         </td> </tr>\n",
    "<tr><td align=\"left\">   <code>diff</code>                </td> <td align=\"left\">   Вычисляет первую арифметическую разность (полезно для временных рядов)                    </td> </tr>\n",
    "<tr><td align=\"left\">   <code>pct_change</code>          </td> <td align=\"left\">   Вычисляет процентные изменения                                                            </td> </tr>\n",
    "</tbody>\n",
    "</table>\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "<!-- Local Variables: -->\n",
    "<!-- doconce-chapter-nickname: \"pandas\" -->\n",
    "<!-- doconce-section-nickname: \"statistics\" -->\n",
    "<!-- End: -->\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Чтение и запись данных\n",
    "<div id=\"pandas:rwdata\"></div>\n",
    "\n",
    "В библиотеке `pandas` реализованы функции чтения табличных данных в\n",
    "объект `DataFrame`. В таблице [pandas:rwdata:tbl:1](#pandas:rwdata:tbl:1) представлены\n",
    "некоторые из таких функций.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Таблица 7 : Функции чтения данных <div id=\"pandas:rwdata:tbl:1\"></div>\n",
    "\n",
    "\n",
    "<table border=\"1\">\n",
    "<thead>\n",
    "<tr><th align=\"left\">    Функция     </th> <th align=\"left\">                                                                Описание                                                               </th> </tr>\n",
    "</thead>\n",
    "<tbody>\n",
    "<tr><td align=\"left\">   <code>read_csv</code>          </td> <td align=\"left\">   Загружает разделенные значения из файла или файлоподобного объекта; в качестве разделителя по умолчанию используется запятая               </td> </tr>\n",
    "<tr><td align=\"left\">   <code>read_table</code>        </td> <td align=\"left\">   Загружает разделенные значения из файла или файлоподобного объекта; в качестве разделителя по умолчанию используется табуляция (<code>'\\t'</code>)    </td> </tr>\n",
    "<tr><td align=\"left\">   <code>read_fwf</code>          </td> <td align=\"left\">   Читает данные в формате со столбцами фиксированной длины (без разделителей)                                                                </td> </tr>\n",
    "<tr><td align=\"left\">   <code>read_clipboard</code>    </td> <td align=\"left\">   Версия функции <code>read_table</code>, которая читает данные из буфера обмена                                                                        </td> </tr>\n",
    "<tr><td align=\"left\">   <code>read_excel</code>        </td> <td align=\"left\">   Читает данные из файлов формата <code>.xls</code> или <code>.xlsx</code>                                                                                         </td> </tr>\n",
    "<tr><td align=\"left\">   <code>read_hdf</code>          </td> <td align=\"left\">   Читает файлы вормата HDF5, записанные с помощью библиотеки <code>pandas</code>                                                                        </td> </tr>\n",
    "<tr><td align=\"left\">   <code>read_html</code>         </td> <td align=\"left\">   Читает все таблицы из заданного документа HTML                                                                                             </td> </tr>\n",
    "<tr><td align=\"left\">   <code>read_json</code>         </td> <td align=\"left\">   Читает данные из JSON (JavsScript Object Notation)                                                                                         </td> </tr>\n",
    "<tr><td align=\"left\">   <code>read_msgpack</code>      </td> <td align=\"left\">   Читает данные <code>pandas</code> закодированные с помощью двоичного формата MessagePack                                                              </td> </tr>\n",
    "<tr><td align=\"left\">   <code>read_pickle</code>       </td> <td align=\"left\">   Читает любой объект, сохраненный в формате Python pickle                                                                                   </td> </tr>\n",
    "<tr><td align=\"left\">   <code>read_sas</code>          </td> <td align=\"left\">   Читает набор данных SAS, хранящийся в одном из пользовательских форматов хранения системы SAS                                              </td> </tr>\n",
    "<tr><td align=\"left\">   <code>read_sql</code>          </td> <td align=\"left\">   Читает результат запроса SQL (используя SQLAlchemy) как объект <code>DataFrame</code>                                                                 </td> </tr>\n",
    "</tbody>\n",
    "</table>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Библиотека `pandas` поддерживает нативную работу со многими\n",
    "реляционными БД.\n",
    "\n",
    "Можно не только загружать данные из локальных файлов, но и из\n",
    "Интернета — достаточно вместо адреса на локальном компьютере указать\n",
    "прямю ссылку на файл.\n",
    "\n",
    "Также существует дополнительный пакет, который называется\n",
    "`pandas_datareader`. Если он не установлен, его можно установить через\n",
    "`conda` или `pip`. Он загружает данные из некоторых\n",
    "источников. Загрузим с помощью `pandas_datareader` некоторые данные\n",
    "для некоторых биржевых тикеров:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "import pandas_datareader.data as web\n",
    "\n",
    "all_data = {ticker: web.get_data_yahoo(ticker)\n",
    "            for ticker in ['AAPL', 'IBM', 'MSFT', 'GOOG']}\n",
    "price = pd.DataFrame({ticker: data['Adj Close']\n",
    "                      for ticker, data in all_data.items()})\n",
    "volume = pd.DataFrame({ticker: data['Volume']\n",
    "                       for ticker, data in all_data.items()})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вычислим изменение процентные изменения цен:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "returns = price.pct_change()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "returns.tail()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Метод `corr` объекта `Series` вычисляет корреляцию перекрывающихся,\n",
    "выровненных по индексу значений в двух объектах\n",
    "`Series`. Соответственно `cov` вычисляет ковариацию:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "returns['MSFT'].corr(returns['IBM'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "returns['MSFT'].cov(returns['IBM'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Поскольку `MSFT` является допустимым атрибутом Python, мы также можем\n",
    "выбрать эти столбцы, используя более краткий синтаксис"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "returns.MSFT.corr(returns.IBM)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Методы `corr` и `cov` объекта `DataFrame` возвращают полные матрицы\n",
    "корреляции или ковариации:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "returns.corr()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "returns.cov()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Используя метод `corrwith` объекта `DataFrame`, можно вычислять попарные\n",
    "корреляции между столбцами или строками `DataFrame` с другими\n",
    "объектами `Series` или `DataFrame`. Передача в качестве аргумента ряда\n",
    "возвращает ряд со значением корреляции, вычисленным для каждого\n",
    "столбца:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "returns.corrwith(returns.IBM)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!-- Local Variables: -->\n",
    "<!-- doconce-chapter-nickname: \"pandas\" -->\n",
    "<!-- doconce-section-nickname: \"rwdata\" -->\n",
    "<!-- End: -->\n",
    "\n",
    "# Задания\n",
    "<div id=\"pandas:exer\"></div>\n",
    "\n",
    "\n",
    "Предлагается поработать с\n",
    "[набором данных](https://data.lacity.org/A-Safe-City/Crime-Data-from-2010-to-2019/63jg-8b9z)\n",
    "о преступности в Лос-Анджелесе.\n",
    "\n",
    "Результат работы должен быть в виде блокнота Jupyter. Все задачи в\n",
    "одном блокноте, например, `pandas-da-ans.ipynb`.\n",
    "\n",
    "Для построения графических данных смотрите главу [Графическая \n",
    "визуализация данных](visual.ipynb)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Быстрый анализ данных\n",
    "<div id=\"pandas:exer:1\"></div>\n",
    "\n",
    "* Загрузите [случайную выборку](src-pandas/la-crimes-sample.csv.zip) из этого набора.\n",
    "\n",
    "* Сколько строк и столбцов в таблице?\n",
    "\n",
    "* Каковы названия столбцов?\n",
    "\n",
    "* Какие типы данных у столбцов?\n",
    "\n",
    "* Сколько в каждом из них уникальных значений?\n",
    "\n",
    "* Сколько пропущенных значений?\n",
    "\n",
    "* Постройте распределения числовых переменных?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Жертвы\n",
    "<div id=\"pandas:exer:2\"></div>\n",
    "\n",
    "В наборе данных имеется информация о Возрасте, Поле, и Происхождении\n",
    "каждой жертвы. Есть ли связь между этими признаками? \n",
    "\n",
    "* Верно ли, что женщины чаще оказываются жертвами по сравнению с мужчинами?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Преступления, пол и возраст\n",
    "<div id=\"pandas:exer:3\"></div>\n",
    "\n",
    "* Изучите распределение количества преступлений по возрасту. Какова тенденция? Люди какого возраста чаще всего подвергаются преступлениям? Есть ли локальные минимумы? Используйте типы графиков `hist` и `density`. \n",
    "\n",
    "* Как различается вероятность женщин и мужчин стать жертвой в зависимости от возраста? Постройте визуализацию. В каком возрастном промежутке мужчины чаще становятся жетрвами преступлений?\n",
    "\n",
    "* Определите 10 самых распространенных преступлений в Лос-Анджелесе. Постройте график.\n",
    "\n",
    "* От каких преступлений чаще старадют женщины, а от каких мужчины?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Происхождение\n",
    "<div id=\"pandas:exer:4\"></div>\n",
    "\n",
    "\n",
    "## Таблица 8\n",
    "\n",
    "\n",
    "<table border=\"1\">\n",
    "<thead>\n",
    "<tr><th align=\"left\">Символ</th> <th align=\"left\">        Происхождение         </th> </tr>\n",
    "</thead>\n",
    "<tbody>\n",
    "<tr><td align=\"left\">   <code>'A'</code>     </td> <td align=\"left\">   Other Asian                       </td> </tr>\n",
    "<tr><td align=\"left\">   <code>'B'</code>     </td> <td align=\"left\">   Black                             </td> </tr>\n",
    "<tr><td align=\"left\">   <code>'C'</code>     </td> <td align=\"left\">   Chinese                           </td> </tr>\n",
    "<tr><td align=\"left\">   <code>'D'</code>     </td> <td align=\"left\">   Cambodian                         </td> </tr>\n",
    "<tr><td align=\"left\">   <code>'F'</code>     </td> <td align=\"left\">   Filipino                          </td> </tr>\n",
    "<tr><td align=\"left\">   <code>'G'</code>     </td> <td align=\"left\">   Guamanian                         </td> </tr>\n",
    "<tr><td align=\"left\">   <code>'H'</code>     </td> <td align=\"left\">   Hispanic/Latin/Mexican            </td> </tr>\n",
    "<tr><td align=\"left\">   <code>'I'</code>     </td> <td align=\"left\">   American Indian/Alaskan Native    </td> </tr>\n",
    "<tr><td align=\"left\">   <code>'J'</code>     </td> <td align=\"left\">   Japanesea                         </td> </tr>\n",
    "<tr><td align=\"left\">   <code>'K'</code>     </td> <td align=\"left\">   Korean                            </td> </tr>\n",
    "<tr><td align=\"left\">   <code>'L'</code>     </td> <td align=\"left\">   Laotian                           </td> </tr>\n",
    "<tr><td align=\"left\">   <code>'O'</code>     </td> <td align=\"left\">   Other                             </td> </tr>\n",
    "<tr><td align=\"left\">   <code>'P'</code>     </td> <td align=\"left\">   Pacific Islander                  </td> </tr>\n",
    "<tr><td align=\"left\">   <code>'S'</code>     </td> <td align=\"left\">   Samoan                            </td> </tr>\n",
    "<tr><td align=\"left\">   <code>'U'</code>     </td> <td align=\"left\">   Hawaiian                          </td> </tr>\n",
    "<tr><td align=\"left\">   <code>'V'</code>     </td> <td align=\"left\">   Vietnamese                        </td> </tr>\n",
    "<tr><td align=\"left\">   <code>'W'</code>     </td> <td align=\"left\">   White                             </td> </tr>\n",
    "<tr><td align=\"left\">   <code>'X'</code>     </td> <td align=\"left\">   Unknown                           </td> </tr>\n",
    "<tr><td align=\"left\">   <code>'Z'</code>     </td> <td align=\"left\">   Asian Indian                      </td> </tr>\n",
    "</tbody>\n",
    "</table>\n",
    "\n",
    "\n",
    "* Люди какого происхождения чаще всего подвергаются преступлениям?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Место проишествия\n",
    "<div id=\"pandas:exer:5\"></div>\n",
    "\n",
    "* Отсортируйте районы, по количеству преступлений. Постройте график, показывающий самые безопасный и опасный районы.\n",
    "\n",
    "* Люди какого происхождения чаще всего страдают от преступлений в каждом из районов? Не забудьте нормировать на общее количество жертв.\n",
    "<!-- Local Variables: -->\n",
    "<!-- doconce-chapter-nickname: \"pandas\" -->\n",
    "<!-- doconce-section-nickname: \"exer\" -->\n",
    "<!-- End: -->\n",
    "<!-- Local Variables: -->\n",
    "<!-- doconce-chapter-nickname: \"pandas\" -->\n",
    "<!-- End: -->"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.2"
  },
  "toc-autonumbering": false,
  "toc-showcode": false,
  "toc-showmarkdowntxt": false,
  "toc-showtags": false
 },
 "nbformat": 4,
 "nbformat_minor": 4
}