4236 lines
118 KiB
Plaintext
4236 lines
118 KiB
Plaintext
{
|
||
"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
|
||
}
|