pandas_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Введение\" data-toc-modified-id=\"Введение-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Введение</a></span><ul class=\"toc-item\"><li><span><a href=\"#Основные-типы-данных\" data-toc-modified-id=\"Основные-типы-данных-1.1\"><span class=\"toc-item-num\">1.1&nbsp;&nbsp;</span>Основные типы данных</a></span></li></ul></li><li><span><a href=\"#Series\" data-toc-modified-id=\"Series-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Series</a></span><ul class=\"toc-item\"><li><span><a href=\"#Создание-Series-из-List\" data-toc-modified-id=\"Создание-Series-из-List-2.1\"><span class=\"toc-item-num\">2.1&nbsp;&nbsp;</span>Создание Series из List</a></span></li><li><span><a href=\"#Создание-Series-из-ndarray-(numpy)\" data-toc-modified-id=\"Создание-Series-из-ndarray-(numpy)-2.2\"><span class=\"toc-item-num\">2.2&nbsp;&nbsp;</span>Создание Series из ndarray (numpy)</a></span></li><li><span><a href=\"#Создание-Series-из-словаря-(dict)\" data-toc-modified-id=\"Создание-Series-из-словаря-(dict)-2.3\"><span class=\"toc-item-num\">2.3&nbsp;&nbsp;</span>Создание Series из словаря (dict)</a></span></li><li><span><a href=\"#Обращение-к--элементам-Series\" data-toc-modified-id=\"Обращение-к--элементам-Series-2.4\"><span class=\"toc-item-num\">2.4&nbsp;&nbsp;</span>Обращение к  элементам Series</a></span><ul class=\"toc-item\"><li><span><a href=\"#Обращение-к-одному-элементу\" data-toc-modified-id=\"Обращение-к-одному-элементу-2.4.1\"><span class=\"toc-item-num\">2.4.1&nbsp;&nbsp;</span>Обращение к одному элементу</a></span></li><li><span><a href=\"#Перечисление\" data-toc-modified-id=\"Перечисление-2.4.2\"><span class=\"toc-item-num\">2.4.2&nbsp;&nbsp;</span>Перечисление</a></span></li><li><span><a href=\"#Срезы\" data-toc-modified-id=\"Срезы-2.4.3\"><span class=\"toc-item-num\">2.4.3&nbsp;&nbsp;</span>Срезы</a></span></li><li><span><a href=\"#Обращение-с-условием:\" data-toc-modified-id=\"Обращение-с-условием:-2.4.4\"><span class=\"toc-item-num\">2.4.4&nbsp;&nbsp;</span>Обращение с условием:</a></span></li></ul></li><li><span><a href=\"#Работа-с-Series\" data-toc-modified-id=\"Работа-с-Series-2.5\"><span class=\"toc-item-num\">2.5&nbsp;&nbsp;</span>Работа с Series</a></span></li><li><span><a href=\"#Добавление-элемента\" data-toc-modified-id=\"Добавление-элемента-2.6\"><span class=\"toc-item-num\">2.6&nbsp;&nbsp;</span>Добавление элемента</a></span></li><li><span><a href=\"#Функция-Series.add\" data-toc-modified-id=\"Функция-Series.add-2.7\"><span class=\"toc-item-num\">2.7&nbsp;&nbsp;</span>Функция <a href=\"https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.add.html#pandas.Series.add\" target=\"_blank\">Series.add</a></a></span></li><li><span><a href=\"#Другие-полезные-функции:\" data-toc-modified-id=\"Другие-полезные-функции:-2.8\"><span class=\"toc-item-num\">2.8&nbsp;&nbsp;</span>Другие полезные функции:</a></span></li></ul></li><li><span><a href=\"#Создание-DataFrame\" data-toc-modified-id=\"Создание-DataFrame-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Создание DataFrame</a></span><ul class=\"toc-item\"><li><span><a href=\"#Создание-DataFrame-из-набора-массивов\" data-toc-modified-id=\"Создание-DataFrame-из-набора-массивов-3.1\"><span class=\"toc-item-num\">3.1&nbsp;&nbsp;</span>Создание DataFrame из набора массивов</a></span></li><li><span><a href=\"#Создание-DataFrame-из-двумерного-массива:\" data-toc-modified-id=\"Создание-DataFrame-из-двумерного-массива:-3.2\"><span class=\"toc-item-num\">3.2&nbsp;&nbsp;</span>Создание DataFrame из двумерного массива:</a></span></li><li><span><a href=\"#Создание-из-словаря:\" data-toc-modified-id=\"Создание-из-словаря:-3.3\"><span class=\"toc-item-num\">3.3&nbsp;&nbsp;</span>Создание из словаря:</a></span></li><li><span><a href=\"#Чтение-из-файла-Exel,-CSV\" data-toc-modified-id=\"Чтение-из-файла-Exel,-CSV-3.4\"><span class=\"toc-item-num\">3.4&nbsp;&nbsp;</span>Чтение из файла Exel, CSV</a></span></li><li><span><a href=\"#Дополнение-(latex-в-названиях)\" data-toc-modified-id=\"Дополнение-(latex-в-названиях)-3.5\"><span class=\"toc-item-num\">3.5&nbsp;&nbsp;</span>Дополнение (latex в названиях)</a></span></li></ul></li><li><span><a href=\"#Работа-c-DataFrame\" data-toc-modified-id=\"Работа-c-DataFrame-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Работа c DataFrame</a></span><ul class=\"toc-item\"><li><span><a href=\"#Обращение-к-элементам-DataFrame\" data-toc-modified-id=\"Обращение-к-элементам-DataFrame-4.1\"><span class=\"toc-item-num\">4.1&nbsp;&nbsp;</span>Обращение к элементам DataFrame</a></span><ul class=\"toc-item\"><li><span><a href=\"#Указание-срезов\" data-toc-modified-id=\"Указание-срезов-4.1.1\"><span class=\"toc-item-num\">4.1.1&nbsp;&nbsp;</span>Указание срезов</a></span></li><li><span><a href=\"#Методы-.iloc,-.loc\" data-toc-modified-id=\"Методы-.iloc,-.loc-4.1.2\"><span class=\"toc-item-num\">4.1.2&nbsp;&nbsp;</span>Методы .iloc, .loc</a></span></li><li><span><a href=\"#Логические-выражения\" data-toc-modified-id=\"Логические-выражения-4.1.3\"><span class=\"toc-item-num\">4.1.3&nbsp;&nbsp;</span>Логические выражения</a></span></li></ul></li></ul></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Введение\n",
    "Библиотека Pandas используется для работы с таблицами."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Подключим необходимые библиотеки (установка аналогично установки Numpy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Основные типы данных\n",
    "Pandas добавляет два новых типа данных Series, DataFrame.\n",
    "* Series - упорядочный ассоциативный массив\n",
    "* DataFrame - Упорядочный двумерный ассоциатиный массив (ну или просто таблица)\n",
    "Начнем с Series"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Series\n",
    "Напомним, что Series - упорядочный ассоциативный массив, то есть мы можем обратиться, как по индексу, так и по ключу (метке). Отметим, что как и в Numpy, в Series должны быть данные одного типа.\n",
    "\n",
    "Создать Series можно из:\n",
    "* List (массив)\n",
    "* Dict (словарь)\n",
    "* ndarray (массив из Numpy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Создание Series из List\n",
    "Создадим Series из List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0     1\n",
       "1     2\n",
       "2    43\n",
       "3    12\n",
       "dtype: int64"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = pd.Series([1,2,43,12])\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если хотим создать Series со своими ключами:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    1\n",
       "b    2\n",
       "c    3\n",
       "d    4\n",
       "e    5\n",
       "dtype: int64"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = pd.Series([ 1 , 2 , 3 , 4 , 5 ], [ 'a' , 'b' , 'c' , 'd' , 'e' ])\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "center"
   },
   "source": [
    "Обратимся по ключу:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "cell_style": "center"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s['a']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Обратимся по индексу:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "cell_style": "center"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Создание Series из ndarray (numpy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Создадим массив в Numpy\n",
    "narr = np.array([ 1 , 2 , 3 , 4 , 5 ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    1\n",
       "1    2\n",
       "2    3\n",
       "3    4\n",
       "4    5\n",
       "dtype: int64"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = pd.Series(narr)\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если хотим со своими индексами:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    1\n",
       "b    2\n",
       "c    3\n",
       "d    4\n",
       "e    5\n",
       "dtype: int64"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = pd.Series(narr, [ 'a' , 'b' , 'c' , 'd' , 'e' ])\n",
    "# либо s = pd.Series(narr, index = ['a','b','c','d','e'])\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Создание Series из словаря (dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a     1\n",
       "b     2\n",
       "c     4\n",
       "d    13\n",
       "e    49\n",
       "f     1\n",
       "dtype: int64"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = {'a' : 1 , 'b' : 2, 'c' : 4,'d' : 13, 'e' : 49, 'f' : 1}\n",
    "s = pd.Series(d)\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Обращение к  элементам Series\n",
    "### Обращение к одному элементу\n",
    "Как уже было отмечено можно обращаться, как по меткам (если они созданы), либо по номеру элемента (всегда), например:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s['a']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Перечисление\n",
    "Можно перечислить несколько элементов, срез, логическое выражение:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a     1\n",
       "b     2\n",
       "c     4\n",
       "d    13\n",
       "e    49\n",
       "f     1\n",
       "dtype: int64"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    1\n",
       "c    4\n",
       "dtype: int64"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# перечисление нескольких элементов:\n",
    "s[[0,2]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    1\n",
       "c    4\n",
       "dtype: int64"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# по меткам:\n",
    "s[['a','c']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Срезы\n",
    "Срез это последовательная часть массива или весь массив. Синтаксис:\n",
    "`Имя_массива[начало:конец]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a     1\n",
       "b     2\n",
       "c     4\n",
       "d    13\n",
       "dtype: int64"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[0:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "d    13\n",
       "e    49\n",
       "dtype: int64"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[3:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можно по меткам:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "c     4\n",
       "d    13\n",
       "dtype: int64"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s['c':'d']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можно указывать отрицательные индексы это означает отсчет с конца:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b     2\n",
       "c     4\n",
       "d    13\n",
       "e    49\n",
       "dtype: int64"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[1:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если пропустить индекс, это означает начало или конец:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a     1\n",
       "b     2\n",
       "c     4\n",
       "d    13\n",
       "dtype: int64"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[:4]  # c начала до 5 элемента"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "c     4\n",
       "d    13\n",
       "e    49\n",
       "f     1\n",
       "dtype: int64"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[2:] # c 3 элемента до конца"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a     1\n",
       "b     2\n",
       "c     4\n",
       "d    13\n",
       "e    49\n",
       "f     1\n",
       "dtype: int64"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[:] # весь массив"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Обращение с условием:\n",
    "Синтаксис следующий: `Имя_массива[Имя_массива условие]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a     1\n",
       "b     2\n",
       "c     4\n",
       "d    13\n",
       "e    49\n",
       "f     1\n",
       "dtype: int64"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b     2\n",
       "c     4\n",
       "d    13\n",
       "e    49\n",
       "dtype: int64"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s [s > 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b     2\n",
       "c     4\n",
       "d    13\n",
       "dtype: int64"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s [(s > 1) & (s < 49)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Работа с Series\n",
    "Series и операции над ней, похожи на массивы в Numpy, соответственно операции над ним похожи: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = pd.Series([1,2,3,4,5]) # размер Series\n",
    "s.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    4\n",
       "1    6\n",
       "2    8\n",
       "dtype: int64"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = pd.Series([1,2,3])\n",
    "b = pd.Series([3,4,5])\n",
    "a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    2.0\n",
       "1    4.0\n",
       "2    6.0\n",
       "3    NaN\n",
       "4    NaN\n",
       "dtype: float64"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = pd.Series([1,2,3,4,5]) # Если разные размеры\n",
    "a + c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0     3\n",
       "1     6\n",
       "2     9\n",
       "3    12\n",
       "4    15\n",
       "dtype: int64"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c * 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Функции из Numpy, так же отлично работают:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 3,  4,  5],\n",
       "       [ 6,  8, 10],\n",
       "       [ 9, 12, 15]])"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.outer(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2,  4, -2])"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.cross(a,b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Добавление элемента"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для того, чтобы добавить элемент в конец, можно просто указать номер индекса и значение"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 424,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0     1\n",
       "1     2\n",
       "2     3\n",
       "3     4\n",
       "4     5\n",
       "12    5\n",
       "dtype: int64"
      ]
     },
     "execution_count": 424,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = pd.Series([1,2,3,4,5])\n",
    "c[12] = 5\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Аналогично с ключом"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a       1\n",
       "b       2\n",
       "c       4\n",
       "d      13\n",
       "e      49\n",
       "f       1\n",
       "gg    124\n",
       "dtype: int64"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = pd.Series({'a' : 1 , 'b' : 2, 'c' : 4,'d' : 13, 'e' : 49, 'f' : 1})\n",
    "d['gg'] = 124\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Функция [Series.add](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.add.html#pandas.Series.add)\n",
    "Функция позволяет добавить к Series другую Series. Если метка есть двух сериях, складывает их. Если указана fill_value, тогда если значение есть в одной из серий, это значение складывается со значением fill_value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    1.0\n",
       "b    1.0\n",
       "c    1.0\n",
       "d    NaN\n",
       "dtype: float64"
      ]
     },
     "execution_count": 187,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])\n",
    "b = pd.Series([1, np.nan, 1, np.nan,5], index=['a', 'b', 'd', 'e','f'])\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    1.0\n",
       "b    NaN\n",
       "d    1.0\n",
       "e    NaN\n",
       "f    5.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 188,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    2.0\n",
       "b    NaN\n",
       "c    NaN\n",
       "d    NaN\n",
       "e    NaN\n",
       "f    NaN\n",
       "dtype: float64"
      ]
     },
     "execution_count": 212,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.add(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    2.0\n",
       "b    1.0\n",
       "c    1.0\n",
       "d    1.0\n",
       "e    NaN\n",
       "f    5.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 215,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.add(b,  fill_value=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Другие полезные функции:\n",
    "* [Series.drop_duplicates](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.drop_duplicates.html#pandas.Series.drop_duplicates) - убирает дубликаты\n",
    "* [pandas.Series.value_counts](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.value_counts.html#pandas.Series.value_counts) - подсчет количества элементов (можно использовать для построения гистограмм\n",
    "\n",
    "[Документация](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.html#pandas.Series)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Создание DataFrame\n",
    "Вторая структура данных DataFrame по своей сути является набором Series, образуя таблицу, где Series (или массивы, или массивы Numpy) - строки:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 426,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   0  1  2\n",
       "0  1  2  3\n",
       "1  3  4  5"
      ]
     },
     "execution_count": 426,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = pd.Series([1,2,3])\n",
    "b = pd.Series([3,4,5])\n",
    "\n",
    "d = pd.DataFrame([a,b])\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Создать DataFrame можно из:\n",
    "1. Набора одномерных массивов (Series, Numpy, List [все элементы одинаковые])\n",
    "2. Двумерного массива\n",
    "3. Словаря\n",
    "4. Прочитать Exel, .csv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Создание DataFrame из набора массивов\n",
    "Как уже отмечалось, при таком способе массивы становятся строками таблицы:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 317,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>35.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>21.0</td>\n",
       "      <td>231.0</td>\n",
       "      <td>12.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     0    1     2      3     4\n",
       "0  1.0  2.0   3.0   35.0   NaN\n",
       "1  1.0  2.0  21.0  231.0  12.0\n",
       "2  1.0  2.0   NaN    NaN   NaN"
      ]
     },
     "execution_count": 317,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = pd.Series([1,2,3,35])\n",
    "b = pd.Series([1,2,21,231,12])\n",
    "c = pd.Series([1,2])\n",
    "d = pd.DataFrame([a,b,c])\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как видно из примера, при несоответствии размеров массивов добавляются NaN."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Теперь изменим название колонок:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 318,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>kol1</th>\n",
       "      <th>kol2</th>\n",
       "      <th>kol3</th>\n",
       "      <th>kol4</th>\n",
       "      <th>kol5</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>35.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>21.0</td>\n",
       "      <td>231.0</td>\n",
       "      <td>12.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   kol1  kol2  kol3   kol4  kol5\n",
       "0   1.0   2.0   3.0   35.0   NaN\n",
       "1   1.0   2.0  21.0  231.0  12.0\n",
       "2   1.0   2.0   NaN    NaN   NaN"
      ]
     },
     "execution_count": 318,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.columns = ['kol1','kol2','kol3','kol4','kol5']\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "А индексы начнем с 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 319,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>kol1</th>\n",
       "      <th>kol2</th>\n",
       "      <th>kol3</th>\n",
       "      <th>kol4</th>\n",
       "      <th>kol5</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>35.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>21.0</td>\n",
       "      <td>231.0</td>\n",
       "      <td>12.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   kol1  kol2  kol3   kol4  kol5\n",
       "1   1.0   2.0   3.0   35.0   NaN\n",
       "2   1.0   2.0  21.0  231.0  12.0\n",
       "3   1.0   2.0   NaN    NaN   NaN"
      ]
     },
     "execution_count": 319,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.index = np.arange(1,d.index.size+1,1)\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Создание DataFrame из двумерного массива:\n",
    "В этот раз изменим "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 257,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = [\n",
    "    [123,431,43,54235],\n",
    "    [13,23535,3413,134],\n",
    "    [123,111,222,333,4444]\n",
    "]\n",
    "len(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>kol1</th>\n",
       "      <th>kol2</th>\n",
       "      <th>kol3</th>\n",
       "      <th>kol4</th>\n",
       "      <th>kol5</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>123</td>\n",
       "      <td>431</td>\n",
       "      <td>43</td>\n",
       "      <td>54235</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>13</td>\n",
       "      <td>23535</td>\n",
       "      <td>3413</td>\n",
       "      <td>134</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>123</td>\n",
       "      <td>111</td>\n",
       "      <td>222</td>\n",
       "      <td>333</td>\n",
       "      <td>4444.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   kol1   kol2  kol3   kol4    kol5\n",
       "1   123    431    43  54235     NaN\n",
       "2    13  23535  3413    134     NaN\n",
       "3   123    111   222    333  4444.0"
      ]
     },
     "execution_count": 258,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = pd.DataFrame(data, index = np.arange(1,len(data)+1,1), columns= ['kol1','kol2','kol3','kol4','kol5'])\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Создание из словаря:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>kol1</th>\n",
       "      <th>kol2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   kol1  kol2\n",
       "1     1     4\n",
       "2     2     5\n",
       "3     3     6"
      ]
     },
     "execution_count": 262,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "d = pd.DataFrame({'kol1': [1,2,3],'kol2':[4,5,6]},index = [1,2,3])\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Чтение из файла Exel, CSV\n",
    "Для чтения файла, необходимо,чтобы в файле не было лишних данных, так же файл должен быть в папке с с вашим Notebook, иначе необходимо в названии прописать относительный путь до файла:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 281,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>kol1</th>\n",
       "      <th>kol2</th>\n",
       "      <th>kol3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>32</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "      <td>21</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>6</td>\n",
       "      <td>41</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "      <td>67</td>\n",
       "      <td>21</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   kol1  kol2  kol3\n",
       "1     1     4    32\n",
       "2     2     5    21\n",
       "3     3     6    41\n",
       "4     4    67    21"
      ]
     },
     "execution_count": 281,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "table = pd.read_excel('Untitled.xlsx',header=0,index_col=0)\n",
    "table"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как выглядит exel файл\n",
    "![](exel.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* `header=0`: 1 строка - названия колонок \n",
    "* `index_col=0`: 1 столбец - названия индексов\n",
    "если нет названия колонок или индексов необходимо написать None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Чтение из CVS аналогично, с тем исключением, что надо указать разделитель(если он отличен от запятой):\n",
    "\n",
    "Создадим CSV файл (можно из Exel экспортировать в CSV)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 291,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>46</td>\n",
       "      <td>53</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>345</td>\n",
       "      <td>54</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "      <td>12</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>124</td>\n",
       "      <td>21</td>\n",
       "      <td>21</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>21</td>\n",
       "      <td>124</td>\n",
       "      <td>43</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     0    1   2\n",
       "0    1   46  53\n",
       "1    2  345  54\n",
       "2    3    4  12\n",
       "3  124   21  21\n",
       "4   21  124  43"
      ]
     },
     "execution_count": 291,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = pd.read_csv('csv.csv',header=None)\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`header = None` так, как мы не имеем выделенную строку под названия, если не указать header =0, то он сделает первую строку названиями"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 309,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>1</th>\n",
       "      <th>46</th>\n",
       "      <th>53</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>345</td>\n",
       "      <td>54</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "      <td>12</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>124</td>\n",
       "      <td>21</td>\n",
       "      <td>21</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>21</td>\n",
       "      <td>124</td>\n",
       "      <td>43</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     1   46  53\n",
       "0    2  345  54\n",
       "1    3    4  12\n",
       "2  124   21  21\n",
       "3   21  124  43"
      ]
     },
     "execution_count": 309,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = pd.read_csv('csv.csv')\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Дополнение (Latex в названиях)\n",
    "Названия колонок поддерживают Latex. Не забывайте ставить r, перед строкой, чтобы не надо было экранировать символы (если вы не поняли, что написано, то просто ставьте r, перед строкой, если пишите Latex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 313,
   "metadata": {},
   "outputs": [],
   "source": [
    "data1 = pd.read_csv('csv.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 315,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>$\\pi$</th>\n",
       "      <th>$\\sqrt{e^2}$</th>\n",
       "      <th>$\\frac{1}{2}$</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>$\\pi$</td>\n",
       "      <td>2</td>\n",
       "      <td>345</td>\n",
       "      <td>54</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>$\\phi$</td>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "      <td>12</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>$\\delta$</td>\n",
       "      <td>124</td>\n",
       "      <td>21</td>\n",
       "      <td>21</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>$\\epsilon$</td>\n",
       "      <td>21</td>\n",
       "      <td>124</td>\n",
       "      <td>43</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            $\\pi$  $\\sqrt{e^2}$  $\\frac{1}{2}$\n",
       "$\\pi$           2           345             54\n",
       "$\\phi$          3             4             12\n",
       "$\\delta$      124            21             21\n",
       "$\\epsilon$     21           124             43"
      ]
     },
     "execution_count": 315,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data1 = pd.read_csv('csv.csv')\n",
    "data1.columns = [r'$\\pi$',r'$\\sqrt{e^2}$',r'$\\frac{1}{2}$']\n",
    "data1.index = ['$\\pi$','$\\phi$','$\\delta$','$\\epsilon$']\n",
    "data1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Работа c DataFrame\n",
    "Для примера сделаем табличку из csv, и создадим столбец равный первый + второй (о том, как это делать расскажем позже)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 395,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>I, A</th>\n",
       "      <th>N , 1/c</th>\n",
       "      <th>AB</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>0.20</td>\n",
       "      <td>1.350</td>\n",
       "      <td>1.550</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>0.40</td>\n",
       "      <td>1.400</td>\n",
       "      <td>1.800</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>0.60</td>\n",
       "      <td>1.350</td>\n",
       "      <td>1.950</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>0.80</td>\n",
       "      <td>1.789</td>\n",
       "      <td>2.589</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>1.00</td>\n",
       "      <td>2.679</td>\n",
       "      <td>3.679</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>5</td>\n",
       "      <td>1.20</td>\n",
       "      <td>3.709</td>\n",
       "      <td>4.909</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>6</td>\n",
       "      <td>1.40</td>\n",
       "      <td>4.559</td>\n",
       "      <td>5.959</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>7</td>\n",
       "      <td>1.60</td>\n",
       "      <td>4.989</td>\n",
       "      <td>6.589</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>8</td>\n",
       "      <td>1.80</td>\n",
       "      <td>6.138</td>\n",
       "      <td>7.938</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>9</td>\n",
       "      <td>2.00</td>\n",
       "      <td>6.508</td>\n",
       "      <td>8.508</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>10</td>\n",
       "      <td>2.20</td>\n",
       "      <td>5.498</td>\n",
       "      <td>7.698</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>11</td>\n",
       "      <td>2.40</td>\n",
       "      <td>4.909</td>\n",
       "      <td>7.309</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>12</td>\n",
       "      <td>2.60</td>\n",
       "      <td>3.639</td>\n",
       "      <td>6.239</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>13</td>\n",
       "      <td>2.80</td>\n",
       "      <td>2.729</td>\n",
       "      <td>5.529</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>14</td>\n",
       "      <td>2.90</td>\n",
       "      <td>2.869</td>\n",
       "      <td>5.769</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>15</td>\n",
       "      <td>3.00</td>\n",
       "      <td>4.029</td>\n",
       "      <td>7.029</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>16</td>\n",
       "      <td>3.20</td>\n",
       "      <td>8.627</td>\n",
       "      <td>11.827</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>17</td>\n",
       "      <td>3.30</td>\n",
       "      <td>11.017</td>\n",
       "      <td>14.317</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>18</td>\n",
       "      <td>3.35</td>\n",
       "      <td>10.027</td>\n",
       "      <td>13.377</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>19</td>\n",
       "      <td>3.40</td>\n",
       "      <td>6.388</td>\n",
       "      <td>9.788</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>20</td>\n",
       "      <td>3.60</td>\n",
       "      <td>2.339</td>\n",
       "      <td>5.939</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>21</td>\n",
       "      <td>3.80</td>\n",
       "      <td>0.860</td>\n",
       "      <td>4.660</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>22</td>\n",
       "      <td>4.00</td>\n",
       "      <td>0.490</td>\n",
       "      <td>4.490</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>23</td>\n",
       "      <td>4.20</td>\n",
       "      <td>0.290</td>\n",
       "      <td>4.490</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>24</td>\n",
       "      <td>4.40</td>\n",
       "      <td>0.490</td>\n",
       "      <td>4.890</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    I, A  N , 1/c      AB\n",
       "0   0.20    1.350   1.550\n",
       "1   0.40    1.400   1.800\n",
       "2   0.60    1.350   1.950\n",
       "3   0.80    1.789   2.589\n",
       "4   1.00    2.679   3.679\n",
       "5   1.20    3.709   4.909\n",
       "6   1.40    4.559   5.959\n",
       "7   1.60    4.989   6.589\n",
       "8   1.80    6.138   7.938\n",
       "9   2.00    6.508   8.508\n",
       "10  2.20    5.498   7.698\n",
       "11  2.40    4.909   7.309\n",
       "12  2.60    3.639   6.239\n",
       "13  2.80    2.729   5.529\n",
       "14  2.90    2.869   5.769\n",
       "15  3.00    4.029   7.029\n",
       "16  3.20    8.627  11.827\n",
       "17  3.30   11.017  14.317\n",
       "18  3.35   10.027  13.377\n",
       "19  3.40    6.388   9.788\n",
       "20  3.60    2.339   5.939\n",
       "21  3.80    0.860   4.660\n",
       "22  4.00    0.490   4.490\n",
       "23  4.20    0.290   4.490\n",
       "24  4.40    0.490   4.890"
      ]
     },
     "execution_count": 395,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_csv('5.4.2_data.csv',decimal = ',') # decimal = ',' используем потому что в csv дробная часть отделена запятой, а не точкой\n",
    "df['AB'] = df.iloc[:,0] + df.iloc[:,1]\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если необходимо посмотреть, только вверх таблички можно использовать метод .head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 392,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>I, A</th>\n",
       "      <th>N , 1/c</th>\n",
       "      <th>AB</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>0.2</td>\n",
       "      <td>1.350</td>\n",
       "      <td>1.550</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>0.4</td>\n",
       "      <td>1.400</td>\n",
       "      <td>1.800</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>0.6</td>\n",
       "      <td>1.350</td>\n",
       "      <td>1.950</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>0.8</td>\n",
       "      <td>1.789</td>\n",
       "      <td>2.589</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.679</td>\n",
       "      <td>3.679</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   I, A  N , 1/c     AB\n",
       "0   0.2    1.350  1.550\n",
       "1   0.4    1.400  1.800\n",
       "2   0.6    1.350  1.950\n",
       "3   0.8    1.789  2.589\n",
       "4   1.0    2.679  3.679"
      ]
     },
     "execution_count": 392,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Обращение к элементам DataFrame\n",
    "Обращаться (выводить элементы можно по разному). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Указание срезов\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 427,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>I, A</th>\n",
       "      <th>N , 1/c</th>\n",
       "      <th>AB</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>0.4</td>\n",
       "      <td>1.40</td>\n",
       "      <td>1.80</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>0.6</td>\n",
       "      <td>1.35</td>\n",
       "      <td>1.95</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   I, A  N , 1/c    AB\n",
       "1   0.4     1.40  1.80\n",
       "2   0.6     1.35  1.95"
      ]
     },
     "execution_count": 427,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[1:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 418,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0      1.550\n",
       "1      1.800\n",
       "2      1.950\n",
       "3      2.589\n",
       "4      3.679\n",
       "5      4.909\n",
       "6      5.959\n",
       "7      6.589\n",
       "8      7.938\n",
       "9      8.508\n",
       "10     7.698\n",
       "11     7.309\n",
       "12     6.239\n",
       "13     5.529\n",
       "14     5.769\n",
       "15     7.029\n",
       "16    11.827\n",
       "17    14.317\n",
       "18    13.377\n",
       "19     9.788\n",
       "20     5.939\n",
       "21     4.660\n",
       "22     4.490\n",
       "23     4.490\n",
       "24     4.890\n",
       "Name: AB, dtype: float64"
      ]
     },
     "execution_count": 418,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df['AB']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 428,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1    1.80\n",
       "2    1.95\n",
       "Name: AB, dtype: float64"
      ]
     },
     "execution_count": 428,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[1:3]['AB']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Методы .iloc, .loc\n",
    "* .iloc - обращается к номерам строк и столбцов\n",
    "* .loc - обращается к меткам строк и столбцов\n",
    "Синтаксис их следующий: \n",
    "\n",
    "`DataFrame.iloc[номер строки1:номер строки2, номер столбца1:номер столбца2]` будет выведена матрица от строки 1 до 2 (не включая) и столбцов 1 до 2(не включая). `.loс` - аналогично только вместо номеров необходимо использовать метки (и концы входят в вывод)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 405,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>I, A</th>\n",
       "      <th>N , 1/c</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>0.4</td>\n",
       "      <td>1.400</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>0.6</td>\n",
       "      <td>1.350</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>0.8</td>\n",
       "      <td>1.789</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.679</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>5</td>\n",
       "      <td>1.2</td>\n",
       "      <td>3.709</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>6</td>\n",
       "      <td>1.4</td>\n",
       "      <td>4.559</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>7</td>\n",
       "      <td>1.6</td>\n",
       "      <td>4.989</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>8</td>\n",
       "      <td>1.8</td>\n",
       "      <td>6.138</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>9</td>\n",
       "      <td>2.0</td>\n",
       "      <td>6.508</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   I, A  N , 1/c\n",
       "1   0.4    1.400\n",
       "2   0.6    1.350\n",
       "3   0.8    1.789\n",
       "4   1.0    2.679\n",
       "5   1.2    3.709\n",
       "6   1.4    4.559\n",
       "7   1.6    4.989\n",
       "8   1.8    6.138\n",
       "9   2.0    6.508"
      ]
     },
     "execution_count": 405,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.iloc[1:10,0:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 429,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>I, A</th>\n",
       "      <th>N , 1/c</th>\n",
       "      <th>AB</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>0.4</td>\n",
       "      <td>1.400</td>\n",
       "      <td>1.800</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>0.6</td>\n",
       "      <td>1.350</td>\n",
       "      <td>1.950</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>0.8</td>\n",
       "      <td>1.789</td>\n",
       "      <td>2.589</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.679</td>\n",
       "      <td>3.679</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>5</td>\n",
       "      <td>1.2</td>\n",
       "      <td>3.709</td>\n",
       "      <td>4.909</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   I, A  N , 1/c     AB\n",
       "1   0.4    1.400  1.800\n",
       "2   0.6    1.350  1.950\n",
       "3   0.8    1.789  2.589\n",
       "4   1.0    2.679  3.679\n",
       "5   1.2    3.709  4.909"
      ]
     },
     "execution_count": 429,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.loc[1:5,'I, A':'AB']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "По своей сути мы передаем два среза, поэтому можно использовать те же обозначения, что и в срезах:\n",
    "* df.iloc[:,:] - вся таблица\n",
    "* df.iloc[:,1] - весь 2 столбец\n",
    "* df.icoc[1,:] - вся 2 строка\n",
    "* df.iloc[1:10,1] - 2 - 9 элементы 2 столбца\n",
    "\n",
    "Так же, можно указывать отрицательные индексы"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Логические выражения\n",
    "Аналогично Series логические выражения для DataFrame, необходимо указывать по какому стобцу/cтроке идет проверка:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 430,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>I, A</th>\n",
       "      <th>N , 1/c</th>\n",
       "      <th>AB</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>0.2</td>\n",
       "      <td>1.350</td>\n",
       "      <td>1.550</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>0.4</td>\n",
       "      <td>1.400</td>\n",
       "      <td>1.800</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>0.6</td>\n",
       "      <td>1.350</td>\n",
       "      <td>1.950</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>0.8</td>\n",
       "      <td>1.789</td>\n",
       "      <td>2.589</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.679</td>\n",
       "      <td>3.679</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   I, A  N , 1/c     AB\n",
       "0   0.2    1.350  1.550\n",
       "1   0.4    1.400  1.800\n",
       "2   0.6    1.350  1.950\n",
       "3   0.8    1.789  2.589\n",
       "4   1.0    2.679  3.679"
      ]
     },
     "execution_count": 430,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[df.iloc[:,0]<3].head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.7.4"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {
    "height": "378px",
    "width": "332px"
   },
   "number_sections": true,
   "sideBar": false,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {
    "height": "815px",
    "left": "1411px",
    "top": "110px",
    "width": "247px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}