python3_pandas_es.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Mis notas: Pandas<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Intro\" data-toc-modified-id=\"Intro-0\"><span class=\"toc-item-num\">0&nbsp;&nbsp;</span>Intro</a></span></li><li><span><a href=\"#Objetos-de-Pandas\" data-toc-modified-id=\"Objetos-de-Pandas-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Objetos de Pandas</a></span><ul class=\"toc-item\"><li><span><a href=\"#Series\" data-toc-modified-id=\"Series-1.1\"><span class=\"toc-item-num\">1.1&nbsp;&nbsp;</span><code>Series</code></a></span><ul class=\"toc-item\"><li><span><a href=\"#Creación\" data-toc-modified-id=\"Creación-1.1.1\"><span class=\"toc-item-num\">1.1.1&nbsp;&nbsp;</span>Creación</a></span></li><li><span><a href=\"#Atributos\" data-toc-modified-id=\"Atributos-1.1.2\"><span class=\"toc-item-num\">1.1.2&nbsp;&nbsp;</span>Atributos</a></span></li></ul></li><li><span><a href=\"#DataFrame\" data-toc-modified-id=\"DataFrame-1.2\"><span class=\"toc-item-num\">1.2&nbsp;&nbsp;</span><code>DataFrame</code></a></span><ul class=\"toc-item\"><li><span><a href=\"#Creación\" data-toc-modified-id=\"Creación-1.2.1\"><span class=\"toc-item-num\">1.2.1&nbsp;&nbsp;</span>Creación</a></span></li><li><span><a href=\"#Atributos\" data-toc-modified-id=\"Atributos-1.2.2\"><span class=\"toc-item-num\">1.2.2&nbsp;&nbsp;</span>Atributos</a></span></li><li><span><a href=\"#Métodos\" data-toc-modified-id=\"Métodos-1.2.3\"><span class=\"toc-item-num\">1.2.3&nbsp;&nbsp;</span>Métodos</a></span></li></ul></li><li><span><a href=\"#Index\" data-toc-modified-id=\"Index-1.3\"><span class=\"toc-item-num\">1.3&nbsp;&nbsp;</span><code>Index</code></a></span></li><li><span><a href=\"#Panel-y-Panel4D\" data-toc-modified-id=\"Panel-y-Panel4D-1.4\"><span class=\"toc-item-num\">1.4&nbsp;&nbsp;</span><code>Panel</code> y <code>Panel4D</code></a></span></li></ul></li><li><span><a href=\"#Indexado-y-selección-de-datos\" data-toc-modified-id=\"Indexado-y-selección-de-datos-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Indexado y selección de datos</a></span><ul class=\"toc-item\"><li><span><a href=\"#Series\" data-toc-modified-id=\"Series-2.1\"><span class=\"toc-item-num\">2.1&nbsp;&nbsp;</span>Series</a></span></li><li><span><a href=\"#DataFrame\" data-toc-modified-id=\"DataFrame-2.2\"><span class=\"toc-item-num\">2.2&nbsp;&nbsp;</span>DataFrame</a></span></li><li><span><a href=\"#Multi-indexado\" data-toc-modified-id=\"Multi-indexado-2.3\"><span class=\"toc-item-num\">2.3&nbsp;&nbsp;</span>Multi-indexado</a></span></li></ul></li><li><span><a href=\"#Operaciones-con-datos\" data-toc-modified-id=\"Operaciones-con-datos-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Operaciones con datos</a></span><ul class=\"toc-item\"><li><span><a href=\"#Operaciones-con-valores-no-disponibles\" data-toc-modified-id=\"Operaciones-con-valores-no-disponibles-3.1\"><span class=\"toc-item-num\">3.1&nbsp;&nbsp;</span>Operaciones con valores no disponibles</a></span></li></ul></li><li><span><a href=\"#Combinaciones-de-datasets\" data-toc-modified-id=\"Combinaciones-de-datasets-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Combinaciones de datasets</a></span><ul class=\"toc-item\"><li><span><a href=\"#Concatenación\" data-toc-modified-id=\"Concatenación-4.1\"><span class=\"toc-item-num\">4.1&nbsp;&nbsp;</span>Concatenación</a></span><ul class=\"toc-item\"><li><span><a href=\"#Concatenación-simple\" data-toc-modified-id=\"Concatenación-simple-4.1.1\"><span class=\"toc-item-num\">4.1.1&nbsp;&nbsp;</span>Concatenación simple</a></span></li><li><span><a href=\"#Concatenación-mediante-joins\" data-toc-modified-id=\"Concatenación-mediante-joins-4.1.2\"><span class=\"toc-item-num\">4.1.2&nbsp;&nbsp;</span>Concatenación mediante joins</a></span></li></ul></li><li><span><a href=\"#Merge-y-Join\" data-toc-modified-id=\"Merge-y-Join-4.2\"><span class=\"toc-item-num\">4.2&nbsp;&nbsp;</span>Merge y Join</a></span><ul class=\"toc-item\"><li><span><a href=\"#1-1-join\" data-toc-modified-id=\"1-1-join-4.2.1\"><span class=\"toc-item-num\">4.2.1&nbsp;&nbsp;</span>1-1 join</a></span></li><li><span><a href=\"#N-1-join\" data-toc-modified-id=\"N-1-join-4.2.2\"><span class=\"toc-item-num\">4.2.2&nbsp;&nbsp;</span>N-1 join</a></span></li><li><span><a href=\"#N-M-join\" data-toc-modified-id=\"N-M-join-4.2.3\"><span class=\"toc-item-num\">4.2.3&nbsp;&nbsp;</span>N-M join</a></span></li></ul></li></ul></li><li><span><a href=\"#Agregación-y-agrupamiento\" data-toc-modified-id=\"Agregación-y-agrupamiento-5\"><span class=\"toc-item-num\">5&nbsp;&nbsp;</span>Agregación y agrupamiento</a></span><ul class=\"toc-item\"><li><span><a href=\"#Agregación-simple\" data-toc-modified-id=\"Agregación-simple-5.1\"><span class=\"toc-item-num\">5.1&nbsp;&nbsp;</span>Agregación simple</a></span></li><li><span><a href=\"#Agregación-sobre-subconjuntos:-GroupBy.\" data-toc-modified-id=\"Agregación-sobre-subconjuntos:-GroupBy.-5.2\"><span class=\"toc-item-num\">5.2&nbsp;&nbsp;</span>Agregación sobre subconjuntos: GroupBy.</a></span></li><li><span><a href=\"#Tablas-dinámicas\" data-toc-modified-id=\"Tablas-dinámicas-5.3\"><span class=\"toc-item-num\">5.3&nbsp;&nbsp;</span>Tablas dinámicas</a></span></li></ul></li><li><span><a href=\"#Operaciones-vectorizadas-sobre-cadenas-de-texto\" data-toc-modified-id=\"Operaciones-vectorizadas-sobre-cadenas-de-texto-6\"><span class=\"toc-item-num\">6&nbsp;&nbsp;</span>Operaciones vectorizadas sobre cadenas de texto</a></span></li><li><span><a href=\"#Operaciones-con-series-temporales\" data-toc-modified-id=\"Operaciones-con-series-temporales-7\"><span class=\"toc-item-num\">7&nbsp;&nbsp;</span>Operaciones con series temporales</a></span><ul class=\"toc-item\"><li><span><a href=\"#Secuencias-regulares\" data-toc-modified-id=\"Secuencias-regulares-7.1\"><span class=\"toc-item-num\">7.1&nbsp;&nbsp;</span>Secuencias regulares</a></span></li><li><span><a href=\"#Remuestreo\" data-toc-modified-id=\"Remuestreo-7.2\"><span class=\"toc-item-num\">7.2&nbsp;&nbsp;</span>Remuestreo</a></span></li><li><span><a href=\"#Desplazamiento-temporal\" data-toc-modified-id=\"Desplazamiento-temporal-7.3\"><span class=\"toc-item-num\">7.3&nbsp;&nbsp;</span>Desplazamiento temporal</a></span></li><li><span><a href=\"#Estadísticas-contínuas\" data-toc-modified-id=\"Estadísticas-contínuas-7.4\"><span class=\"toc-item-num\">7.4&nbsp;&nbsp;</span>Estadísticas contínuas</a></span></li></ul></li><li><span><a href=\"#Alto-rendimiento\" data-toc-modified-id=\"Alto-rendimiento-8\"><span class=\"toc-item-num\">8&nbsp;&nbsp;</span>Alto rendimiento</a></span><ul class=\"toc-item\"><li><span><a href=\"#pd.eval()\" data-toc-modified-id=\"pd.eval()-8.1\"><span class=\"toc-item-num\">8.1&nbsp;&nbsp;</span>pd.eval()</a></span></li><li><span><a href=\"#df.eval()\" data-toc-modified-id=\"df.eval()-8.2\"><span class=\"toc-item-num\">8.2&nbsp;&nbsp;</span>df.eval()</a></span></li><li><span><a href=\"#df.query()\" data-toc-modified-id=\"df.query()-8.3\"><span class=\"toc-item-num\">8.3&nbsp;&nbsp;</span>df.query()</a></span></li></ul></li><li><span><a href=\"#Best-of-Pandas-API\" data-toc-modified-id=\"Best-of-Pandas-API-9\"><span class=\"toc-item-num\">9&nbsp;&nbsp;</span>Best of Pandas API</a></span></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Disclaimer**: Este notebook contiene mis notas sobre Pandas, resumiendo básicamente el [capítulo 3](https://jakevdp.github.io/PythonDataScienceHandbook/03.00-introduction-to-pandas.html) de [Python Data Science Handbook](https://jakevdp.github.io/PythonDataScienceHandbook/index.html) escrito por [Jake VanderPlas](http://vanderplas.com/). Recomiendo leer la fuente original e ir ejecutando todos los ejemplos (___learn by doing!___)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Intro"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Pandas](https://pandas.pydata.org/) es una librería clave en el mundo del análisis de datos con Python. Está construida sobre NumPy, y sirve para manipular de forma eficiente estructuras de datos heterogéneos y etiquetados (***dataframes***), pudiendo realizar análisis de datos extensivos.\n",
    "\n",
    "Los arrays de NumPy son perfectos para trabajar con datos limpios y organizados usando operaciones numéricas, pero sus limitaciones son claras cuando necesitamos más flexibilidad (etiquetar datos, trabajar con datos faltantes, operaciones que no encajen con broadcasting, datos heterogéneos, etc). Pandas introduce los objetos `Series` y `DataFrame` para poder llevar a cabo las tareas de acomodar y pulir los datos en crudo con el fin de preparar los datos para su análisis.\n",
    "\n",
    "Para poder usar Pandas, simplemente tendremos que importar la librería :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pandas suele importarse con el alias pd\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Resto de imports\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Objetos de Pandas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `Series`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se trata de un **array unidimensional** de datos homogéneos **indexados**. Los índices son explícitos, lo que diferencia un objeto Series de Pandas de un array de NumPy, y además nos permite usar índices de cualquier tipo aparte de números enteros.\n",
    "\n",
    "Podemos ver el objeto Series también como un caso particular de un diccionario de Python, pero ordenado (permitiendo slicing) y con mejor eficiencia para casos determinados, debido a que todos los índices son del mismo tipo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Creación"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se pueden crear a partir de una lista, un array de NumPy o un diccionario (en este último caso los índices por defecto serán las claves del diccionario ordenadas). Se pueden incluso crear a partir de un escalar, que se repetirá tantas veces como longitud tenga el índice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    0.00\n",
       "1    0.25\n",
       "2    0.50\n",
       "3    0.75\n",
       "4    1.00\n",
       "dtype: float64"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo a partir de una lista sin especificar los índices (por defecto será una secuencia de enteros)\n",
    "pd.Series([0, 0.25, 0.5, 0.75, 1.0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    0.00\n",
       "a    0.25\n",
       "b    0.50\n",
       "c    0.75\n",
       "e    1.00\n",
       "dtype: float64"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo a partir de una lista especificando los índices\n",
    "serie = pd.Series([0, 0.25, 0.5, 0.75, 1.0],\n",
    "                index=[0, 'a', 'b', 'c', 'e'])\n",
    "serie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3    c\n",
       "2    b\n",
       "dtype: object"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo a partir de un diccionario, usando index para quedarnos sólo una parte\n",
    "pd.Series({1:'a', 2:'b', 3:'c'}, index=[3, 2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Atributos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para acceder a los valores del objeto Series usamos el atributo `values`. Obtendremos un **array** de NumPy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.  , 0.25, 0.5 , 0.75, 1.  ])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "serie.values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para acceder a los índices usamos el atributo `index`. Tendremos una especie de array de tipo `Index`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index([0, 'a', 'b', 'c', 'e'], dtype='object')"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "serie.index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `DataFrame`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se trata de un **array bidimensional** de datos **doblemente indexados**; esto es, una matriz de filas y columnas etiquetadas. Podemos verlo también como una versión ordenada de un diccionario de objetos Series."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Creación"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creamos un ejemplo de DataFrame a partir de un **diccionario de diccionarios** (que también podrían ser listas o series):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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>population</th>\n",
       "      <th>community</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Madrid</th>\n",
       "      <td>6578079.0</td>\n",
       "      <td>Comunidad de Madrid</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Barcelona</th>\n",
       "      <td>5609350.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Valencia</th>\n",
       "      <td>2547986.0</td>\n",
       "      <td>Comunidad Valenciana</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Sevilla</th>\n",
       "      <td>1939887.0</td>\n",
       "      <td>Andalucía</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Alicante</th>\n",
       "      <td>1838819.0</td>\n",
       "      <td>Comunidad Valenciana</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Bilbao</th>\n",
       "      <td>NaN</td>\n",
       "      <td>Euskadi</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           population             community\n",
       "Madrid      6578079.0   Comunidad de Madrid\n",
       "Barcelona   5609350.0                   NaN\n",
       "Valencia    2547986.0  Comunidad Valenciana\n",
       "Sevilla     1939887.0             Andalucía\n",
       "Alicante    1838819.0  Comunidad Valenciana\n",
       "Bilbao            NaN               Euskadi"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "provinces_population = {'Madrid': 6578079, 'Barcelona': 5609350, 'Valencia': 2547986, \n",
    "                        'Sevilla': 1939887, 'Alicante': 1838819}\n",
    "provinces_community = {'Madrid': 'Comunidad de Madrid', 'Valencia': 'Comunidad Valenciana', \n",
    "                        'Sevilla': 'Andalucía', 'Alicante': 'Comunidad Valenciana', 'Bilbao': 'Euskadi'}\n",
    "\n",
    "# Creamos un diccionario con 2 claves, una para cada diccionario:\n",
    "provinces = pd.DataFrame({'population': provinces_population, 'community': provinces_community})\n",
    "provinces"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como podemos observar, cuando no coinciden los índices de los diccionarios se rellenarán los huecos con el valor `NaN` (\"Not a Number\")."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos crear un DataFrame de muchas otras maneras; por ejemplo a partir de un único objeto **Series**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "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>valor</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>0.25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>b</th>\n",
       "      <td>0.50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c</th>\n",
       "      <td>0.75</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>e</th>\n",
       "      <td>1.00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   valor\n",
       "0   0.00\n",
       "a   0.25\n",
       "b   0.50\n",
       "c   0.75\n",
       "e   1.00"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# DataFrame creado \n",
    "pd.DataFrame(serie, columns=['valor'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También a partir de una **lista de diccionarios** (cada elemento será una fila):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "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>a</th>\n",
       "      <th>b</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   a  b\n",
       "0  1  1\n",
       "1  2  4\n",
       "2  3  9"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.DataFrame([{'a': i, 'b': i**2} for i in range(1, 4)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "DataFrame creado a partir de un **array bidimensional** de NumPy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.570314</td>\n",
       "      <td>0.439094</td>\n",
       "      <td>0.843945</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.120267</td>\n",
       "      <td>0.674450</td>\n",
       "      <td>0.681001</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          a         b         c\n",
       "1  0.570314  0.439094  0.843945\n",
       "2  0.120267  0.674450  0.681001"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.DataFrame(np.random.rand(2,3), columns=['a', 'b', 'c'], index=[1, 2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También podemos crear un DataFrame directamente a partir de un **array estructurado** de NumPy, indicando el tipo de cada columna:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "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>A</th>\n",
       "      <th>B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   A    B\n",
       "0  1  1.0\n",
       "1  1  1.0\n",
       "2  1  1.0"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.DataFrame(np.ones(3, dtype=[('A', 'i8'), ('B', 'f8')]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otra opción muy común es crear el DataFrame a partir de un **fichero**. Pandas maneja varios formatos:\n",
    " * JSON : `read_json()`\n",
    " * csv : `read_csv()`\n",
    " * xls : `read_excel()`\n",
    "\n",
    "Finalmente, podemos **transponer** el DataFrame usando `.T` como si fuera una matriz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": false
   },
   "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>Madrid</th>\n",
       "      <th>Barcelona</th>\n",
       "      <th>Valencia</th>\n",
       "      <th>Sevilla</th>\n",
       "      <th>Alicante</th>\n",
       "      <th>Bilbao</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>population</th>\n",
       "      <td>6.57808e+06</td>\n",
       "      <td>5.60935e+06</td>\n",
       "      <td>2.54799e+06</td>\n",
       "      <td>1.93989e+06</td>\n",
       "      <td>1.83882e+06</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>community</th>\n",
       "      <td>Comunidad de Madrid</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Comunidad Valenciana</td>\n",
       "      <td>Andalucía</td>\n",
       "      <td>Comunidad Valenciana</td>\n",
       "      <td>Euskadi</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                         Madrid    Barcelona              Valencia  \\\n",
       "population          6.57808e+06  5.60935e+06           2.54799e+06   \n",
       "community   Comunidad de Madrid          NaN  Comunidad Valenciana   \n",
       "\n",
       "                Sevilla              Alicante   Bilbao  \n",
       "population  1.93989e+06           1.83882e+06      NaN  \n",
       "community     Andalucía  Comunidad Valenciana  Euskadi  "
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "provinces.T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos **guardar** el Dataframe en un fichero CSV usando el método `to_csv()`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Atributos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el atributo `index` tendremos los índices de las filas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['Madrid', 'Barcelona', 'Valencia', 'Sevilla', 'Alicante', 'Bilbao'], dtype='object')"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "provinces.index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el atributo `columns` tendremos los índices de las columnas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['population', 'community'], dtype='object')"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "provinces.columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y por último en el atributo `values` estarán todos los valores:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[6578079.0, 'Comunidad de Madrid'],\n",
       "       [5609350.0, nan],\n",
       "       [2547986.0, 'Comunidad Valenciana'],\n",
       "       [1939887.0, 'Andalucía'],\n",
       "       [1838819.0, 'Comunidad Valenciana'],\n",
       "       [nan, 'Euskadi']], dtype=object)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "provinces.values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos acceder a los tipos de las columnas con `dtypes`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "population    float64\n",
       "community      object\n",
       "dtype: object"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "provinces.dtypes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Métodos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pandas nos facilita varios métodos para obtener información básica del DataFrame: `describe()` e `info()`. Así mismo nos da la posibilidad de echar un vistazo a parte del mismo, usando `head()` o `tail()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "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>population</th>\n",
       "      <th>community</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Madrid</th>\n",
       "      <td>6578079.0</td>\n",
       "      <td>Comunidad de Madrid</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Barcelona</th>\n",
       "      <td>5609350.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Valencia</th>\n",
       "      <td>2547986.0</td>\n",
       "      <td>Comunidad Valenciana</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Sevilla</th>\n",
       "      <td>1939887.0</td>\n",
       "      <td>Andalucía</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Alicante</th>\n",
       "      <td>1838819.0</td>\n",
       "      <td>Comunidad Valenciana</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           population             community\n",
       "Madrid      6578079.0   Comunidad de Madrid\n",
       "Barcelona   5609350.0                   NaN\n",
       "Valencia    2547986.0  Comunidad Valenciana\n",
       "Sevilla     1939887.0             Andalucía\n",
       "Alicante    1838819.0  Comunidad Valenciana"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "provinces.head() # 5 primeros elementos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Index: 6 entries, Madrid to Bilbao\n",
      "Data columns (total 2 columns):\n",
      "population    5 non-null float64\n",
      "community     5 non-null object\n",
      "dtypes: float64(1), object(1)\n",
      "memory usage: 304.0+ bytes\n"
     ]
    }
   ],
   "source": [
    "provinces.info() # información sobre el dataframe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "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>population</th>\n",
       "      <th>community</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>5.000000e+00</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>unique</th>\n",
       "      <td>NaN</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>top</th>\n",
       "      <td>NaN</td>\n",
       "      <td>Comunidad Valenciana</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>freq</th>\n",
       "      <td>NaN</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>3.702824e+06</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>2.225873e+06</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>1.838819e+06</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>1.939887e+06</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>2.547986e+06</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>5.609350e+06</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>6.578079e+06</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          population             community\n",
       "count   5.000000e+00                     5\n",
       "unique           NaN                     4\n",
       "top              NaN  Comunidad Valenciana\n",
       "freq             NaN                     2\n",
       "mean    3.702824e+06                   NaN\n",
       "std     2.225873e+06                   NaN\n",
       "min     1.838819e+06                   NaN\n",
       "25%     1.939887e+06                   NaN\n",
       "50%     2.547986e+06                   NaN\n",
       "75%     5.609350e+06                   NaN\n",
       "max     6.578079e+06                   NaN"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "provinces.describe(include='all') # estadísticos más importantes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tenemos algunos métodos muy útiles para analizar los valores de una columna concreta, como `unique()` o `value_counts()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Comunidad de Madrid', nan, 'Comunidad Valenciana', 'Andalucía',\n",
       "       'Euskadi'], dtype=object)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "provinces.community.unique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Comunidad Valenciana    2\n",
       "Comunidad de Madrid     1\n",
       "Andalucía               1\n",
       "Euskadi                 1\n",
       "Name: community, dtype: int64"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "provinces.community.value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos ordenar el dataframe usando `sort_index()` o `sort_values()` indicando la columna o columnas en el parámetro `by`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "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>population</th>\n",
       "      <th>community</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Alicante</th>\n",
       "      <td>1838819.0</td>\n",
       "      <td>Comunidad Valenciana</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Sevilla</th>\n",
       "      <td>1939887.0</td>\n",
       "      <td>Andalucía</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Valencia</th>\n",
       "      <td>2547986.0</td>\n",
       "      <td>Comunidad Valenciana</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Barcelona</th>\n",
       "      <td>5609350.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Madrid</th>\n",
       "      <td>6578079.0</td>\n",
       "      <td>Comunidad de Madrid</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Bilbao</th>\n",
       "      <td>NaN</td>\n",
       "      <td>Euskadi</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           population             community\n",
       "Alicante    1838819.0  Comunidad Valenciana\n",
       "Sevilla     1939887.0             Andalucía\n",
       "Valencia    2547986.0  Comunidad Valenciana\n",
       "Barcelona   5609350.0                   NaN\n",
       "Madrid      6578079.0   Comunidad de Madrid\n",
       "Bilbao            NaN               Euskadi"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "provinces.sort_values(by='population', ascending=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El método `rename()` nos permite cambiar el nombre a columnas (parámetro `columns`) e índices (`index`) usando diccionarios."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `Index`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ya hemos podido usar esta estructura en los ejemplos de Series y DataFrame. Podemos verlo como una especie de array **inmutable**. Que los índices no sean modificables es una medida de seguridad por si varias estructuras comparten el mismo Index.\n",
    "\n",
    "El objeto Index puede verse también como un set ordenado. ¿Por qué? porque podemos calcular la intersección (`&`), la unión (`|`), o la diferencia simétrica (`^`) de dos objetos Index.\n",
    "\n",
    "Podemos construir un objeto Index a partir de una lista:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Int64Index([3, 6, 9, 12, 15], dtype='int64')"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo\n",
    "ind = pd.Index([3, 6, 9, 12, 15])\n",
    "ind"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como en los arrays, podremos acceder a cualquier elemento o hacer slicing con corchetes. Además tendremos acceso a atributos disponibles en los arrays de NumPy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 (5,) 1 int64\n"
     ]
    }
   ],
   "source": [
    "print(ind.size, ind.shape, ind.ndim, ind.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `Panel` y `Panel4D`\n",
    "\n",
    "Pandas proporciona estos 2 objetos para manejar datos con 3 y 4 dimensiones respectivamente, de forma nativa. Aunque en la práctica lo más común es hacer uso del indexado jerárquico o multi-indexado."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexado y selección de datos\n",
    "\n",
    "### Series"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    0.00\n",
       "a    0.25\n",
       "b    0.50\n",
       "c    0.75\n",
       "e    1.00\n",
       "dtype: float64"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo\n",
    "serie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como en Numpy podemos **indexar** sus elementos usando corchetes. También podemos reemplazar su contenido, o añadir un nuevo elemento si el índice no existía."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Obtener elemento especificando su índice\n",
    "serie['e']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    0.00\n",
       "a    0.25\n",
       "b    0.50\n",
       "c    0.75\n",
       "e    1.00\n",
       "f    1.01\n",
       "dtype: float64"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Agregar elemento\n",
    "serie['f'] = 1.01\n",
    "serie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos eliminar un elemento usando `del`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    0.00\n",
       "a    0.25\n",
       "b    0.50\n",
       "c    0.75\n",
       "e    1.00\n",
       "dtype: float64"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del serie['f']\n",
    "serie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El **slicing** tiene una particularidad; si lo hacemos con índices explícitos (los que vemos) el último índice estará incluido en la selección. En cambio, si usamos índices implícitos, el último índice está excluido como siempre. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    0.25\n",
       "b    0.50\n",
       "c    0.75\n",
       "dtype: float64"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Slicing usando índices explícitos\n",
    "serie['a':'c']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    0.00\n",
       "a    0.25\n",
       "dtype: float64"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Slicing usando índices implícitos\n",
    "serie[0:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    0.0\n",
       "e    1.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Indexado múltiple (fancy)\n",
    "serie[[0, 'e']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También podemos hacer **masking** con condiciones:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b    0.5\n",
       "dtype: float64"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "serie[(serie > 0.4) & (serie < 0.6)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si tenemos índices explícitos numéricos, las operaciones de indexado usarán estos índices, pero **las operaciones de slicing usarán los índices implícitos**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "serie2 = pd.Series(['a', 'b', 'c'], index=[2, 3, 4])\n",
    "serie2[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3    b\n",
       "4    c\n",
       "dtype: object"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "serie2[1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para evitar este tipo de confusiones, Pandas proporciona unos atributos especiales para el objeto Series:\n",
    " * `loc` : referencia a los índices explícitos\n",
    " * `iloc` : referencia a los índices implícitos\n",
    " * `ix` : *deprecated*\n",
    " \n",
    "Es recomendable especificar el tipo siempre, y usar índices explícitos en lugar de implícitos cuando podamos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'c'"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo\n",
    "serie2.iloc[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2    a\n",
       "3    b\n",
       "dtype: object"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo\n",
    "serie2.loc[1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### DataFrame"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aprovechamos para etiquetar el index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "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>population</th>\n",
       "      <th>community</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>city</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Madrid</th>\n",
       "      <td>6578079.0</td>\n",
       "      <td>Comunidad de Madrid</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Barcelona</th>\n",
       "      <td>5609350.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Valencia</th>\n",
       "      <td>2547986.0</td>\n",
       "      <td>Comunidad Valenciana</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Sevilla</th>\n",
       "      <td>1939887.0</td>\n",
       "      <td>Andalucía</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Alicante</th>\n",
       "      <td>1838819.0</td>\n",
       "      <td>Comunidad Valenciana</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Bilbao</th>\n",
       "      <td>NaN</td>\n",
       "      <td>Euskadi</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           population             community\n",
       "city                                       \n",
       "Madrid      6578079.0   Comunidad de Madrid\n",
       "Barcelona   5609350.0                   NaN\n",
       "Valencia    2547986.0  Comunidad Valenciana\n",
       "Sevilla     1939887.0             Andalucía\n",
       "Alicante    1838819.0  Comunidad Valenciana\n",
       "Bilbao            NaN               Euskadi"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "provinces.index.name = 'city'\n",
    "provinces"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para obtener una columna del dataframe podemos hacerlo como si de un diccionario de Python se tratara. Indexaremos con corchetes o usaremos el típico acceso a un atributo (provinces.population). La columna no es más que un objeto de tipo Series. \n",
    "\n",
    "*NOTA*: Mejor usar corchetes; lo otro no funciona si la columna se llama igual que un método de DataFrame, o contiene un espacio."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "city\n",
       "Madrid       6578079.0\n",
       "Barcelona    5609350.0\n",
       "Valencia     2547986.0\n",
       "Sevilla      1939887.0\n",
       "Alicante     1838819.0\n",
       "Bilbao             NaN\n",
       "Name: population, dtype: float64"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "provinces['population']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esto también se usa para sustituir una columna o crear una nueva:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "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>population</th>\n",
       "      <th>community</th>\n",
       "      <th>population_M</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>city</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Madrid</th>\n",
       "      <td>6578079.0</td>\n",
       "      <td>Comunidad de Madrid</td>\n",
       "      <td>6.58</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Barcelona</th>\n",
       "      <td>5609350.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>5.61</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Valencia</th>\n",
       "      <td>2547986.0</td>\n",
       "      <td>Comunidad Valenciana</td>\n",
       "      <td>2.55</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Sevilla</th>\n",
       "      <td>1939887.0</td>\n",
       "      <td>Andalucía</td>\n",
       "      <td>1.94</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Alicante</th>\n",
       "      <td>1838819.0</td>\n",
       "      <td>Comunidad Valenciana</td>\n",
       "      <td>1.84</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Bilbao</th>\n",
       "      <td>NaN</td>\n",
       "      <td>Euskadi</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           population             community  population_M\n",
       "city                                                     \n",
       "Madrid      6578079.0   Comunidad de Madrid          6.58\n",
       "Barcelona   5609350.0                   NaN          5.61\n",
       "Valencia    2547986.0  Comunidad Valenciana          2.55\n",
       "Sevilla     1939887.0             Andalucía          1.94\n",
       "Alicante    1838819.0  Comunidad Valenciana          1.84\n",
       "Bilbao            NaN               Euskadi           NaN"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "provinces['population_M'] = round(provinces['population'] / 1000000, 2)\n",
    "provinces"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se pueden seleccionar varias columnas especificando una lista de nombres:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "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>community</th>\n",
       "      <th>population_M</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>city</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Madrid</th>\n",
       "      <td>Comunidad de Madrid</td>\n",
       "      <td>6.58</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Barcelona</th>\n",
       "      <td>NaN</td>\n",
       "      <td>5.61</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Valencia</th>\n",
       "      <td>Comunidad Valenciana</td>\n",
       "      <td>2.55</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Sevilla</th>\n",
       "      <td>Andalucía</td>\n",
       "      <td>1.94</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Alicante</th>\n",
       "      <td>Comunidad Valenciana</td>\n",
       "      <td>1.84</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Bilbao</th>\n",
       "      <td>Euskadi</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                      community  population_M\n",
       "city                                         \n",
       "Madrid      Comunidad de Madrid          6.58\n",
       "Barcelona                   NaN          5.61\n",
       "Valencia   Comunidad Valenciana          2.55\n",
       "Sevilla               Andalucía          1.94\n",
       "Alicante   Comunidad Valenciana          1.84\n",
       "Bilbao                  Euskadi           NaN"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "provinces[['community', 'population_M']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible indexar una **fila** en lugar de una columna, usando índices explícitos o implícitos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "population              6.57808e+06\n",
       "community       Comunidad de Madrid\n",
       "population_M                   6.58\n",
       "Name: Madrid, dtype: object"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "provinces.loc['Madrid']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "population      1.93989e+06\n",
       "community         Andalucía\n",
       "population_M           1.94\n",
       "Name: Sevilla, dtype: object"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "provinces.iloc[3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También podemos seleccionar sólo los valores de una fila indexando sobre el atributo values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1939887.0, 'Andalucía', 1.94], dtype=object)"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "provinces.values[3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para seleccionar un elemento concreto se usa la siguiente notación, donde el primer índice es de fila y el segundo de columna (aquí estamos usando índices explícitos, cosa que indicamos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.58"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "provinces.loc['Madrid', 'population_M']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esto equivale a lo siguiente (notamos cómo cambia el orden):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.58"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "provinces['population_M']['Madrid']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Con índices implícitos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "city\n",
       "Barcelona    5.61\n",
       "Sevilla      1.94\n",
       "Name: population_M, dtype: float64"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "provinces.iloc[[1,3], 2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El **slicing** por defecto, al contrario que el indexado, se hace primero **sobre filas**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "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>population</th>\n",
       "      <th>community</th>\n",
       "      <th>population_M</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>city</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Madrid</th>\n",
       "      <td>6578079.0</td>\n",
       "      <td>Comunidad de Madrid</td>\n",
       "      <td>6.58</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Barcelona</th>\n",
       "      <td>5609350.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>5.61</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           population            community  population_M\n",
       "city                                                    \n",
       "Madrid      6578079.0  Comunidad de Madrid          6.58\n",
       "Barcelona   5609350.0                  NaN          5.61"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "provinces['Madrid':'Barcelona']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aquí no podríamos hacer slicing sobre las columnas por no haber especificado qué indices usar. Lo solucionamos usando `loc` o `iloc`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "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>community</th>\n",
       "      <th>population_M</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>city</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Madrid</th>\n",
       "      <td>Comunidad de Madrid</td>\n",
       "      <td>6.58</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Barcelona</th>\n",
       "      <td>NaN</td>\n",
       "      <td>5.61</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     community  population_M\n",
       "city                                        \n",
       "Madrid     Comunidad de Madrid          6.58\n",
       "Barcelona                  NaN          5.61"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Slicing con índices explícitos\n",
    "provinces.loc[:'Barcelona', 'community':]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "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>community</th>\n",
       "      <th>population_M</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>city</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Madrid</th>\n",
       "      <td>Comunidad de Madrid</td>\n",
       "      <td>6.58</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Barcelona</th>\n",
       "      <td>NaN</td>\n",
       "      <td>5.61</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     community  population_M\n",
       "city                                        \n",
       "Madrid     Comunidad de Madrid          6.58\n",
       "Barcelona                  NaN          5.61"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Slicing con índices implícitos\n",
    "provinces.iloc[:2, 1:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos combinar masking (sujeto a condiciones, con operadores de comparación o métodos como `isin()`) con indexado múltiple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "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>community</th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>city</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Madrid</th>\n",
       "      <td>Comunidad de Madrid</td>\n",
       "      <td>6578079.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Barcelona</th>\n",
       "      <td>NaN</td>\n",
       "      <td>5609350.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     community  population\n",
       "city                                      \n",
       "Madrid     Comunidad de Madrid   6578079.0\n",
       "Barcelona                  NaN   5609350.0"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "provinces.loc[provinces.population_M > 4, ['community', 'population']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NOTA: Podríamos indexar por columna usando índices implícitos escribiendo lo siguiente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "city\n",
       "Madrid       6578079.0\n",
       "Barcelona    5609350.0\n",
       "Valencia     2547986.0\n",
       "Sevilla      1939887.0\n",
       "Alicante     1838819.0\n",
       "Bilbao             NaN\n",
       "Name: population, dtype: float64"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "provinces.iloc[:, 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multi-indexado"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para utilizar más dimensiones de las establecidas para Series (1D) y DataFrame (2D) se utiliza el multi-indexado o indexado jerárquico, que consiste en incorporar distintos niveles para los índices dentro de un objeto `MultiIndex`. \n",
    "\n",
    "Imaginemos que tenemos el siguiente objeto Series y queremos incorporar información temporal:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "city\n",
       "Madrid       6.58\n",
       "Barcelona    5.61\n",
       "Valencia     2.55\n",
       "Sevilla      1.94\n",
       "Alicante     1.84\n",
       "Bilbao        NaN\n",
       "Name: population_M, dtype: float64"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "provinces['population_M']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podríamos vernos tentados de hacerlo usando un nuevo Index compuesto por tuplas (Ciudad, año), y eso es precisamente lo que queremos evitar con MultiIndex.\n",
    "\n",
    "Para crear un objeto multi-indexado lo más sencillo es pasar al constructor un multi-index ya creado previamente. Para ello podemos usar varias formas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MultiIndex([(   'Madrid', 2017),\n",
       "            (   'Madrid', 2018),\n",
       "            ('Barcelona', 2017),\n",
       "            ('Barcelona', 2018),\n",
       "            ( 'Valencia', 2017),\n",
       "            ( 'Valencia', 2018)],\n",
       "           )"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo de creación de multi-index desde arrays\n",
    "index=pd.MultiIndex.from_arrays([['Madrid', 'Madrid', 'Barcelona', 'Barcelona', 'Valencia', 'Valencia'], \n",
    "                                 [2017, 2018, 2017, 2018, 2017, 2018]])\n",
    "index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MultiIndex([(   'Madrid', 2017),\n",
       "            (   'Madrid', 2018),\n",
       "            ('Barcelona', 2017),\n",
       "            ('Barcelona', 2018),\n",
       "            ( 'Valencia', 2017),\n",
       "            ( 'Valencia', 2018)],\n",
       "           )"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo de creación de multi-index desde tuplas\n",
    "index=pd.MultiIndex.from_tuples([('Madrid', 2017), ('Madrid', 2018), ('Barcelona', 2017), \n",
    "                                 ('Barcelona', 2018), ('Valencia', 2017), ('Valencia', 2018)])\n",
    "index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MultiIndex([(   'Madrid', 2017),\n",
       "            (   'Madrid', 2018),\n",
       "            ('Barcelona', 2017),\n",
       "            ('Barcelona', 2018),\n",
       "            ( 'Valencia', 2017),\n",
       "            ( 'Valencia', 2018)],\n",
       "           names=['ciudad', 'año'])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo de creación de multi-index desde un producto de arrays con índices únicos. Asignamos nombres!\n",
    "index=pd.MultiIndex.from_product([['Madrid', 'Barcelona', 'Valencia'], [2017, 2018]], \n",
    "                                 names=['ciudad', 'año'])\n",
    "index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ciudad     año \n",
       "Madrid     2017    6.4\n",
       "           2018    6.5\n",
       "Barcelona  2017    5.5\n",
       "           2018    5.6\n",
       "Valencia   2017    2.5\n",
       "           2018    2.5\n",
       "dtype: float64"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo de creación de objeto Series con multi-index\n",
    "serie = pd.Series([6.4, 6.5, 5.5, 5.6, 2.5, 2.5], index=index)\n",
    "serie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "año\n",
       "2017    6.4\n",
       "2018    6.5\n",
       "dtype: float64"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Accedemos a la información para Madrid usando un índice normal\n",
    "serie['Madrid']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ciudad    año \n",
       "Madrid    2017    6.4\n",
       "          2018    6.5\n",
       "Valencia  2017    2.5\n",
       "          2018    2.5\n",
       "dtype: float64"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Fancy indexing, indicando una lista de índices (doble corchete)\n",
    "serie[['Madrid', 'Valencia']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ciudad\n",
       "Madrid       6.4\n",
       "Barcelona    5.5\n",
       "Valencia     2.5\n",
       "dtype: float64"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Accedemos a la información para el año 2017 usando un índice compuesto\n",
    "serie[:, 2017]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos pasar fácilmente de un objeto Series a un DataFrame usando el método `unstack()`. La operación inversa se lograría con `stack()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "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>año</th>\n",
       "      <th>2017</th>\n",
       "      <th>2018</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ciudad</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Barcelona</th>\n",
       "      <td>5.5</td>\n",
       "      <td>5.6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Madrid</th>\n",
       "      <td>6.4</td>\n",
       "      <td>6.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Valencia</th>\n",
       "      <td>2.5</td>\n",
       "      <td>2.5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "año        2017  2018\n",
       "ciudad               \n",
       "Barcelona   5.5   5.6\n",
       "Madrid      6.4   6.5\n",
       "Valencia    2.5   2.5"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = serie.unstack()\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para facilitar el manejo de los dataframes con multi-index podemos convertir éste en columnas normales usando `reset_index()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "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>ciudad</th>\n",
       "      <th>año</th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Madrid</td>\n",
       "      <td>2017</td>\n",
       "      <td>6.4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Madrid</td>\n",
       "      <td>2018</td>\n",
       "      <td>6.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Barcelona</td>\n",
       "      <td>2017</td>\n",
       "      <td>5.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Barcelona</td>\n",
       "      <td>2018</td>\n",
       "      <td>5.6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Valencia</td>\n",
       "      <td>2017</td>\n",
       "      <td>2.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Valencia</td>\n",
       "      <td>2018</td>\n",
       "      <td>2.5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      ciudad   año  population\n",
       "0     Madrid  2017         6.4\n",
       "1     Madrid  2018         6.5\n",
       "2  Barcelona  2017         5.5\n",
       "3  Barcelona  2018         5.6\n",
       "4   Valencia  2017         2.5\n",
       "5   Valencia  2018         2.5"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "serie_flat = serie.reset_index(name='population')\n",
    "serie_flat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El paso contrario (convertir columnas en multi-index) se usa a veces cuando partimos de datos en crudo. Usaremos en este caso el método `set_index()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "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></th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ciudad</th>\n",
       "      <th>año</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">Madrid</th>\n",
       "      <th>2017</th>\n",
       "      <td>6.4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018</th>\n",
       "      <td>6.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">Barcelona</th>\n",
       "      <th>2017</th>\n",
       "      <td>5.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018</th>\n",
       "      <td>5.6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">Valencia</th>\n",
       "      <th>2017</th>\n",
       "      <td>2.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018</th>\n",
       "      <td>2.5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                population\n",
       "ciudad    año             \n",
       "Madrid    2017         6.4\n",
       "          2018         6.5\n",
       "Barcelona 2017         5.5\n",
       "          2018         5.6\n",
       "Valencia  2017         2.5\n",
       "          2018         2.5"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "serie_flat.set_index(['ciudad', 'año'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La gracia del multi-indexado no es solo pasar de 1 a 2 dimensiones, sino por ejemplo de 2 a 3:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "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></th>\n",
       "      <th>total</th>\n",
       "      <th>over65</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ciudad</th>\n",
       "      <th>año</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">Madrid</th>\n",
       "      <th>2017</th>\n",
       "      <td>6.4</td>\n",
       "      <td>1.4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018</th>\n",
       "      <td>6.5</td>\n",
       "      <td>1.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">Barcelona</th>\n",
       "      <th>2017</th>\n",
       "      <td>5.5</td>\n",
       "      <td>1.1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018</th>\n",
       "      <td>5.6</td>\n",
       "      <td>1.1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">Valencia</th>\n",
       "      <th>2017</th>\n",
       "      <td>2.5</td>\n",
       "      <td>0.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018</th>\n",
       "      <td>2.5</td>\n",
       "      <td>0.5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                total  over65\n",
       "ciudad    año                \n",
       "Madrid    2017    6.4     1.4\n",
       "          2018    6.5     1.5\n",
       "Barcelona 2017    5.5     1.1\n",
       "          2018    5.6     1.1\n",
       "Valencia  2017    2.5     0.5\n",
       "          2018    2.5     0.5"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo\n",
    "df_3 = pd.DataFrame({'total': serie, 'over65': [1.4, 1.5, 1.1, 1.1, 0.5, 0.5]})\n",
    "df_3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las columnas también pueden tener multi-index. Vemos un ejemplo con 4 dimensiones:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "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 tr th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr:last-of-type th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th>ciudad</th>\n",
       "      <th colspan=\"2\" halign=\"left\">Madrid</th>\n",
       "      <th colspan=\"2\" halign=\"left\">Barcelona</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th>medida</th>\n",
       "      <th>t_med</th>\n",
       "      <th>t_max</th>\n",
       "      <th>t_med</th>\n",
       "      <th>t_max</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>año</th>\n",
       "      <th>cuatrimestre</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"4\" valign=\"top\">2017</th>\n",
       "      <th>Q1</th>\n",
       "      <td>10</td>\n",
       "      <td>24</td>\n",
       "      <td>12</td>\n",
       "      <td>22</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Q2</th>\n",
       "      <td>15</td>\n",
       "      <td>34</td>\n",
       "      <td>16</td>\n",
       "      <td>29</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Q3</th>\n",
       "      <td>16</td>\n",
       "      <td>39</td>\n",
       "      <td>15</td>\n",
       "      <td>35</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Q4</th>\n",
       "      <td>11</td>\n",
       "      <td>28</td>\n",
       "      <td>13</td>\n",
       "      <td>27</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"4\" valign=\"top\">2018</th>\n",
       "      <th>Q1</th>\n",
       "      <td>11</td>\n",
       "      <td>26</td>\n",
       "      <td>11</td>\n",
       "      <td>20</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Q2</th>\n",
       "      <td>16</td>\n",
       "      <td>38</td>\n",
       "      <td>17</td>\n",
       "      <td>31</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Q3</th>\n",
       "      <td>15</td>\n",
       "      <td>39</td>\n",
       "      <td>14</td>\n",
       "      <td>34</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Q4</th>\n",
       "      <td>12</td>\n",
       "      <td>31</td>\n",
       "      <td>14</td>\n",
       "      <td>28</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "ciudad            Madrid       Barcelona      \n",
       "medida             t_med t_max     t_med t_max\n",
       "año  cuatrimestre                             \n",
       "2017 Q1               10    24        12    22\n",
       "     Q2               15    34        16    29\n",
       "     Q3               16    39        15    35\n",
       "     Q4               11    28        13    27\n",
       "2018 Q1               11    26        11    20\n",
       "     Q2               16    38        17    31\n",
       "     Q3               15    39        14    34\n",
       "     Q4               12    31        14    28"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index = pd.MultiIndex.from_product([[2017, 2018], ['Q1', 'Q2', 'Q3', 'Q4']],\n",
    "                                   names=['año', 'cuatrimestre'])\n",
    "columns = pd.MultiIndex.from_product([['Madrid', 'Barcelona'], ['t_med', 't_max']],\n",
    "                                     names=['ciudad', 'medida'])\n",
    "data = [[10, 24, 12, 22], [15, 34, 16, 29], [16, 39, 15, 35], [11, 28, 13, 27],\n",
    "       [11, 26, 11, 20], [16, 38, 17, 31], [15, 39, 14, 34], [12, 31, 14, 28]]\n",
    "\n",
    "temp_data = pd.DataFrame(data, index=index, columns=columns)\n",
    "temp_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Y cómo funciona ahora el indexado? Lo vemos con unos ejemplos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "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>medida</th>\n",
       "      <th>t_med</th>\n",
       "      <th>t_max</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>año</th>\n",
       "      <th>cuatrimestre</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"4\" valign=\"top\">2017</th>\n",
       "      <th>Q1</th>\n",
       "      <td>10</td>\n",
       "      <td>24</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Q2</th>\n",
       "      <td>15</td>\n",
       "      <td>34</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Q3</th>\n",
       "      <td>16</td>\n",
       "      <td>39</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Q4</th>\n",
       "      <td>11</td>\n",
       "      <td>28</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"4\" valign=\"top\">2018</th>\n",
       "      <th>Q1</th>\n",
       "      <td>11</td>\n",
       "      <td>26</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Q2</th>\n",
       "      <td>16</td>\n",
       "      <td>38</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Q3</th>\n",
       "      <td>15</td>\n",
       "      <td>39</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Q4</th>\n",
       "      <td>12</td>\n",
       "      <td>31</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "medida             t_med  t_max\n",
       "año  cuatrimestre              \n",
       "2017 Q1               10     24\n",
       "     Q2               15     34\n",
       "     Q3               16     39\n",
       "     Q4               11     28\n",
       "2018 Q1               11     26\n",
       "     Q2               16     38\n",
       "     Q3               15     39\n",
       "     Q4               12     31"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Indexar una columna (indexado parcial)\n",
    "temp_data['Madrid']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "año   cuatrimestre\n",
       "2017  Q1              10\n",
       "      Q2              15\n",
       "      Q3              16\n",
       "      Q4              11\n",
       "2018  Q1              11\n",
       "      Q2              16\n",
       "      Q3              15\n",
       "      Q4              12\n",
       "Name: t_med, dtype: int64"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Indexar una subcolumna\n",
    "temp_data['Madrid']['t_med']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Indexamos hasta un único elemento, índices por defecto\n",
    "temp_data['Madrid']['t_med'][2018]['Q1'] # = temp_data['Madrid','t_med'][2018,'Q1']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Lo mismo pero indicando índices explícitos, lo que implica empezar el indexado por las filas\n",
    "temp_data.loc[2018, 'Q1']['Madrid', 't_med']\n",
    "temp_data.loc[(2018, 'Q1'), ('Madrid', 't_med')] # Equivalente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "cuatrimestre\n",
       "Q1    11\n",
       "Q2    16\n",
       "Q3    15\n",
       "Q4    12\n",
       "Name: (Madrid, t_med), dtype: int64"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Una selección más...\n",
    "temp_data.loc[2018, :]['Madrid', 't_med']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¡Vamos con el Slicing! Para que funcione el slicing los índices tendrán que están ordenados. Si no lo están, podemos usar la función `sortindex()` o `sortlevel()` sobre nuestro objeto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "cuatrimestre\n",
       "Q1    11\n",
       "Q2    16\n",
       "Name: t_med, dtype: int64"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp_data['Madrid']['t_med'][2018]['Q1':'Q2']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y por último el masking:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "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 tr th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr:last-of-type th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th>ciudad</th>\n",
       "      <th colspan=\"2\" halign=\"left\">Madrid</th>\n",
       "      <th colspan=\"2\" halign=\"left\">Barcelona</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th>medida</th>\n",
       "      <th>t_med</th>\n",
       "      <th>t_max</th>\n",
       "      <th>t_med</th>\n",
       "      <th>t_max</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>año</th>\n",
       "      <th>cuatrimestre</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"4\" valign=\"top\">2017</th>\n",
       "      <th>Q1</th>\n",
       "      <td>NaN</td>\n",
       "      <td>24</td>\n",
       "      <td>NaN</td>\n",
       "      <td>22</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Q2</th>\n",
       "      <td>NaN</td>\n",
       "      <td>34</td>\n",
       "      <td>16.0</td>\n",
       "      <td>29</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Q3</th>\n",
       "      <td>16.0</td>\n",
       "      <td>39</td>\n",
       "      <td>NaN</td>\n",
       "      <td>35</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Q4</th>\n",
       "      <td>NaN</td>\n",
       "      <td>28</td>\n",
       "      <td>NaN</td>\n",
       "      <td>27</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"4\" valign=\"top\">2018</th>\n",
       "      <th>Q1</th>\n",
       "      <td>NaN</td>\n",
       "      <td>26</td>\n",
       "      <td>NaN</td>\n",
       "      <td>20</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Q2</th>\n",
       "      <td>16.0</td>\n",
       "      <td>38</td>\n",
       "      <td>17.0</td>\n",
       "      <td>31</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Q3</th>\n",
       "      <td>NaN</td>\n",
       "      <td>39</td>\n",
       "      <td>NaN</td>\n",
       "      <td>34</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Q4</th>\n",
       "      <td>NaN</td>\n",
       "      <td>31</td>\n",
       "      <td>NaN</td>\n",
       "      <td>28</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "ciudad            Madrid       Barcelona      \n",
       "medida             t_med t_max     t_med t_max\n",
       "año  cuatrimestre                             \n",
       "2017 Q1              NaN    24       NaN    22\n",
       "     Q2              NaN    34      16.0    29\n",
       "     Q3             16.0    39       NaN    35\n",
       "     Q4              NaN    28       NaN    27\n",
       "2018 Q1              NaN    26       NaN    20\n",
       "     Q2             16.0    38      17.0    31\n",
       "     Q3              NaN    39       NaN    34\n",
       "     Q4              NaN    31       NaN    28"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Masking\n",
    "temp_data[temp_data > 15]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos hacer agregaciones sobre un índice concreto usando el parámetro `level`. En el siguiente ejemplo agrupamos por año y se pierden los Q's:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "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 tr th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr:last-of-type th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th>ciudad</th>\n",
       "      <th colspan=\"2\" halign=\"left\">Madrid</th>\n",
       "      <th colspan=\"2\" halign=\"left\">Barcelona</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>medida</th>\n",
       "      <th>t_med</th>\n",
       "      <th>t_max</th>\n",
       "      <th>t_med</th>\n",
       "      <th>t_max</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>año</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2017</th>\n",
       "      <td>16</td>\n",
       "      <td>39</td>\n",
       "      <td>16</td>\n",
       "      <td>35</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018</th>\n",
       "      <td>16</td>\n",
       "      <td>39</td>\n",
       "      <td>17</td>\n",
       "      <td>34</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "ciudad Madrid       Barcelona      \n",
       "medida  t_med t_max     t_med t_max\n",
       "año                                \n",
       "2017       16    39        16    35\n",
       "2018       16    39        17    34"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp_data_max = temp_data.max(level='año')\n",
    "temp_data_max"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También sobre columnas haciendo uso de `axis=1` o `axis='columns'`. En el siguiente ejemplo agrupamos por medida y se pierden las ciudades:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "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>medida</th>\n",
       "      <th>t_med</th>\n",
       "      <th>t_max</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>año</th>\n",
       "      <th>cuatrimestre</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"4\" valign=\"top\">2017</th>\n",
       "      <th>Q1</th>\n",
       "      <td>12</td>\n",
       "      <td>24</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Q2</th>\n",
       "      <td>16</td>\n",
       "      <td>34</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Q3</th>\n",
       "      <td>16</td>\n",
       "      <td>39</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Q4</th>\n",
       "      <td>13</td>\n",
       "      <td>28</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"4\" valign=\"top\">2018</th>\n",
       "      <th>Q1</th>\n",
       "      <td>11</td>\n",
       "      <td>26</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Q2</th>\n",
       "      <td>17</td>\n",
       "      <td>38</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Q3</th>\n",
       "      <td>15</td>\n",
       "      <td>39</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Q4</th>\n",
       "      <td>14</td>\n",
       "      <td>31</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "medida             t_med  t_max\n",
       "año  cuatrimestre              \n",
       "2017 Q1               12     24\n",
       "     Q2               16     34\n",
       "     Q3               16     39\n",
       "     Q4               13     28\n",
       "2018 Q1               11     26\n",
       "     Q2               17     38\n",
       "     Q3               15     39\n",
       "     Q4               14     31"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp_data_max = temp_data.max(level='medida', axis='columns')\n",
    "temp_data_max"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operaciones con datos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pandas hereda las **ufuncs** de NumPy, teniendo en cuenta un par de cosas:\n",
    "* ufuncs unarias: se conservan los índices de filas y columnas\n",
    "* ufuncs binarias: se alinean automáticamente los índices de los dos objetos de entrada\n",
    "\n",
    "En el caso de que los índices no casen, aparecen los valores `NaN`. Estos valores se pueden cambiar por otros si en lugar de usar el operador usamos la función correspondiente. Ejemplo: `A+B` --> `A.add(B, fill_value=0)`\n",
    "\n",
    "Relación entre operador y su método equivalente en Pandas:\n",
    " * `+` = add()\n",
    " * `-` = sub(), subtract()\n",
    " * `*` = mul(), multiply()\n",
    " * `/` = truediv(), div(), divide()\n",
    " * `//` = floordiv()\n",
    " * `**` = pow()\n",
    " * `%` = mod()\n",
    " \n",
    "Podemos perfectamente hacer operaciones entre objetos Series y objetos DataFrame:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "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>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "      <th>d</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>zero</th>\n",
       "      <td>0.706814</td>\n",
       "      <td>0.913568</td>\n",
       "      <td>0.912268</td>\n",
       "      <td>0.534946</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>one</th>\n",
       "      <td>0.967640</td>\n",
       "      <td>0.387097</td>\n",
       "      <td>0.144750</td>\n",
       "      <td>0.802595</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>two</th>\n",
       "      <td>0.085871</td>\n",
       "      <td>0.300056</td>\n",
       "      <td>0.562634</td>\n",
       "      <td>0.979322</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             a         b         c         d\n",
       "zero  0.706814  0.913568  0.912268  0.534946\n",
       "one   0.967640  0.387097  0.144750  0.802595\n",
       "two   0.085871  0.300056  0.562634  0.979322"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo\n",
    "df = pd.DataFrame(np.random.rand(3, 4), columns=['a', 'b', 'c', 'd'], index=['zero', 'one', 'two'])\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las operaciones por defecto con DataFrames se realizan por filas..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "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>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "      <th>d</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>zero</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>one</th>\n",
       "      <td>0.260826</td>\n",
       "      <td>-0.526471</td>\n",
       "      <td>-0.767518</td>\n",
       "      <td>0.267649</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>two</th>\n",
       "      <td>-0.620943</td>\n",
       "      <td>-0.613512</td>\n",
       "      <td>-0.349634</td>\n",
       "      <td>0.444376</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             a         b         c         d\n",
       "zero  0.000000  0.000000  0.000000  0.000000\n",
       "one   0.260826 -0.526471 -0.767518  0.267649\n",
       "two  -0.620943 -0.613512 -0.349634  0.444376"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df - df.loc['zero']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si queremos operar por columna, usamos los métodos de Pandas en lugar de los operadores, para poder especificar `axis`.\n",
    "\n",
    "Una pequeña aclaración sobre `axis`\n",
    "* `axis=0` = `axis='index'`: eje vertical, o de los índices de las filas\n",
    "* `axis=1` = `axis='columns'`: eje horizontal, o de las columnas\n",
    "\n",
    "![axis.jpg](images/axis.jpg)\n",
    "\n",
    "En una operación de agregación (sum, med, std, etc) se usará igual que en NumPy. Pero ¡ojo! que en el siguiente caso `axis` lo que indica es en qué eje están los índices de la serie pasada como primer parámetro (en el caso de df['a'] están en el eje vertical)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "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>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "      <th>d</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>zero</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.206754</td>\n",
       "      <td>0.205454</td>\n",
       "      <td>-0.171868</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>one</th>\n",
       "      <td>0.0</td>\n",
       "      <td>-0.580543</td>\n",
       "      <td>-0.822890</td>\n",
       "      <td>-0.165045</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>two</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.214184</td>\n",
       "      <td>0.476763</td>\n",
       "      <td>0.893451</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        a         b         c         d\n",
       "zero  0.0  0.206754  0.205454 -0.171868\n",
       "one   0.0 -0.580543 -0.822890 -0.165045\n",
       "two   0.0  0.214184  0.476763  0.893451"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.sub(df['a'], axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otro ejemplo restando a un DataFrame parte del mismo. Los índices se conservan, pero aparece NaN donde no coinciden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "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>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "      <th>d</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>zero</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>one</th>\n",
       "      <td>0.260826</td>\n",
       "      <td>NaN</td>\n",
       "      <td>-0.767518</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>two</th>\n",
       "      <td>-0.620943</td>\n",
       "      <td>NaN</td>\n",
       "      <td>-0.349634</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             a   b         c   d\n",
       "zero  0.000000 NaN  0.000000 NaN\n",
       "one   0.260826 NaN -0.767518 NaN\n",
       "two  -0.620943 NaN -0.349634 NaN"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df - df.iloc[0, ::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operaciones con valores no disponibles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`NaN` (*Not a Number*) es una de las dos representaciones usadas en Pandas (y en NumPy) para valores no disponibles o faltantes (NA); siendo la otra `None` (el objeto nulo de Python). La ventaja de usar NaN es que se trata de un valor especial de punto flotante, y no tendremos errores a la hora de hacer operaciones como con None. Eso sí, ***cualquier operación normal con un NaN tendrá como resultado NaN*** (NumPy define versiones especiales de las operaciones más comunes para ignorar estos valores).\n",
    "\n",
    "En la siguiente tabla se detalla lo que ocurre cuando se detecta un valor NA en un tipo específico de Pandas (NOTA: los strings se almacenan como dtype object). Podemos observar que si tenemos un NA en objetos o en booleanos, el tipo de NA se conserva (None o NaN).\n",
    "\n",
    "<table>\n",
    "  <tr>\n",
    "    <th>NA en dtype</th>\n",
    "    <th>conversión</th>\n",
    "    <th>NA</th>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>float</td>\n",
    "    <td>-</td>\n",
    "    <td>np.nan</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>object</td>\n",
    "    <td>-</td>\n",
    "    <td>None ó np.nan</td>\n",
    "  </tr>\n",
    "    <tr>\n",
    "    <td>integer</td>\n",
    "    <td>a float64</td>\n",
    "    <td>np.nan</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>boolean</td>\n",
    "    <td>a object</td>\n",
    "    <td>None ó np.nan</td>\n",
    "  </tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    0.0\n",
       "1    NaN\n",
       "dtype: float64"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo con serie de integers -> conversión a float64, None a NaN\n",
    "pd.Series([0, None])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    True\n",
       "1    None\n",
       "dtype: object"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo con serie de objects -> conversión a object, None se queda igual\n",
    "pd.Series([True, None])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pandas cuenta con varios métodos para detectar, filtrar o reemplazar esos valores faltantes:\n",
    " * `isna()` | `isnull()` : devuelve una máscara indicando los valores NA como True\n",
    " * `notna()` | `notnull()` : devuelve una máscara indicando los valores NA como False\n",
    " * `dropna()` : devuelve una versión filtrada de los datos sin los valores NA\n",
    " * `fillna()` : devuelve una versión de los datos con los NA reemplazados\n",
    " \n",
    "En el caso de un DataFrame, `dropna()` no puede eliminar únicamente los elementos NA. Se comportará de manera distinta dependiendo de sus parámetros:\n",
    " * `dropna()` : elimina las filas con NA\n",
    " * `dropna(axis='columns')` : elimina las columnas con NA\n",
    " * `dropna(how='all')` : elimina las filas con todos sus elementos NA\n",
    " * `dropna(thresh=n)` : elimina las filas con menos de n valores distintos de NA\n",
    " \n",
    "El método `fillna()` también cuenta con varias opciones:\n",
    " * `fillna(0)` : reemplaza los NA con el valor 0\n",
    " * `fillna(method='ffill')` : reemplaza los NA con el valor anterior (de la fila anterior si es un DataFrame)\n",
    " * `fillna(method='bfill')` : reemplaza los NA con el valor posterior (de la fila posterior si es un DataFrame)\n",
    " * `fillna(method='bfill', axis=1)` : reemplaza los NA con el valor de la columna posterior (DataFrame)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "population      1\n",
       "community       1\n",
       "population_M    1\n",
       "dtype: int64"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo para contar los NA en las columnas de un dataset:\n",
    "provinces.isna().sum() # sum en axis 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Combinaciones de datasets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Concatenación"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La concatenación en Pandas es casi igual que NumPy, con la diferencia de que se conservan los índices incluso estando duplicados.\n",
    "\n",
    "Pandas cuenta con varias funciones para combinar datos:\n",
    " * `pd.concat()` : concatenación flexible de los objetos pasados en una lista como argumento de la función\n",
    "  * `axis` : 0 (default) para concatenar añadiendo filas; 1 para añadir columnas\n",
    "  * `verify_integrity=True` : devuelve error si encuentra índices duplicados\n",
    "  * `ignore_index=True` : crea un nuevo Index para el resultado\n",
    "  * `keys` : array de labels para crear multi-indexado y evitar conflictos de índices\n",
    "  * `join` : outer (unión) o inner (intersección)\n",
    " * `append()` : método de Series y DataFrame para concatenar un segundo objeto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Concatenación simple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1    a\n",
       "2    b\n",
       "3    c\n",
       "1    d\n",
       "2    e\n",
       "4    f\n",
       "dtype: object"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo\n",
    "serie1 = pd.Series(['a', 'b', 'c'], index=[1, 2, 3])\n",
    "serie2 = pd.Series(['d', 'e', 'f'], index=[1, 2, 4])\n",
    "pd.concat([serie1, serie2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1    a\n",
       "2    b\n",
       "3    c\n",
       "1    d\n",
       "2    e\n",
       "4    f\n",
       "dtype: object"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Lo mismo usando append\n",
    "serie1.append(serie2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "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>a</th>\n",
       "      <th>b</th>\n",
       "      <th>c</th>\n",
       "      <th>d</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>-1</td>\n",
       "      <td>-1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "      <td>-2</td>\n",
       "      <td>-4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>9</td>\n",
       "      <td>-3</td>\n",
       "      <td>-9</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   a  b  c  d\n",
       "0  1  1 -1 -1\n",
       "1  2  4 -2 -4\n",
       "2  3  9 -3 -9"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Con DataFrames\n",
    "df1 = pd.DataFrame([{'a': i, 'b': i**2} for i in range(1, 4)])\n",
    "df2 = -pd.DataFrame([{'c': i, 'd': i**2} for i in range(1, 4)])\n",
    "pd.concat([df1, df2], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "s1  1    a\n",
       "    2    b\n",
       "    3    c\n",
       "s2  1    d\n",
       "    2    e\n",
       "    4    f\n",
       "dtype: object"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Aplicando multi-indexado para evitar índices duplicados como antes\n",
    "pd.concat([serie1, serie2], keys=['s1', 's2'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Concatenación mediante joins"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cuando los índices de los objetos en la dimensión que se concatenan no coinciden, por defecto Pandas rellena los valores no disponibles con NaN; es lo mismo que se logra escribiendo un `join='outer'`, la unión. Si usamos `join='inner'`, lo que se consigue es la intersección (se descartan las filas o columnas que no coinciden en ambos objetos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "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",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>a</td>\n",
       "      <td>d</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>b</td>\n",
       "      <td>e</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>c</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>NaN</td>\n",
       "      <td>f</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     0    1\n",
       "1    a    d\n",
       "2    b    e\n",
       "3    c  NaN\n",
       "4  NaN    f"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.concat([serie1, serie2], axis=1, join='outer') # concatenación de columnas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "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",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>a</td>\n",
       "      <td>d</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>b</td>\n",
       "      <td>e</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   0  1\n",
       "1  a  d\n",
       "2  b  e"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.concat([serie1, serie2], axis=1, join='inner')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos aplicar también el método `reindex()` para especificar las filas específicas del resultado (con axis=1):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "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",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>a</td>\n",
       "      <td>d</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>b</td>\n",
       "      <td>e</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>c</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   0    1\n",
       "1  a    d\n",
       "2  b    e\n",
       "3  c  NaN"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.concat([serie1, serie2], axis=1).reindex(serie1.index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Merge y Join"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una de las características esenciales de Pandas son sus operaciones `merge` y `join` (con alto rendimiento en memoria); similares a las que tenemos en BBDD :\n",
    " * `pd.merge()` : 1-1, N-1, N-M joins\n",
    "  * `on` : especifica el nombre de la columna clave sobre la que se realiza el join\n",
    "  * `left_on` | `right_on` (='columna') : especifica el nombre de la columna clave en ambos objetos (cuando es distinto). Introduce ambas columnas en el resultado final, pudiendo usar `drop('name', axis=n)` para eliminar una.\n",
    "  * `left_index` | `right_index` (= True) : para hacer merge en un index en lugar de en una columna (on e index son compatibles!).\n",
    "  * `how` : inner | outer | left | right (filas resultado: intersección | unión | izquierda | derecha)\n",
    "  * `suffixes` (=['\\_suff_1', '\\_suff_2']) : si coinciden nombres de columna, se pueden especificar sufijos para su nombre en el resultado (por defecto \\_x e \\_y)\n",
    " * `join()` : método de Series y DataFrame para hacer merge con un segundo objeto, por defecto sobre los índices.\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1-1 join"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Muy similar a una concatenación por columnas. La función merge detecta una columna común que usa como clave para realizar la unión, y por defecto lo hace sólo usando las filas que coincidan (equivalente a how='inner'):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "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>num</th>\n",
       "      <th>pow2</th>\n",
       "      <th>pow3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>9</td>\n",
       "      <td>27</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   num  pow2  pow3\n",
       "0    1     1     1\n",
       "1    2     4     8\n",
       "2    3     9    27"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo 1-1\n",
    "df1 = pd.DataFrame([{'num': i, 'pow2': i**2} for i in range(1, 4)])\n",
    "df2 = pd.DataFrame([{'num': i, 'pow3': i**3} for i in range(1, 5)])\n",
    "pd.merge(df1, df2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### N-1 join"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cuando una de las columnas comunes contiene valores duplicados:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "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>estudiante</th>\n",
       "      <th>estudios</th>\n",
       "      <th>universidad</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Yago</td>\n",
       "      <td>Periodismo</td>\n",
       "      <td>UCM</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Luisa</td>\n",
       "      <td>Teleco</td>\n",
       "      <td>UPM</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Carlos</td>\n",
       "      <td>Teleco</td>\n",
       "      <td>UPM</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Irene</td>\n",
       "      <td>Informática</td>\n",
       "      <td>UPM</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  estudiante     estudios universidad\n",
       "0       Yago   Periodismo         UCM\n",
       "1      Luisa       Teleco         UPM\n",
       "2     Carlos       Teleco         UPM\n",
       "3      Irene  Informática         UPM"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo N-1\n",
    "df3 = pd.DataFrame({'estudiante': ['Yago', 'Luisa', 'Carlos', 'Irene'],\n",
    "                    'estudios': ['Periodismo', 'Teleco', 'Teleco', 'Informática']})\n",
    "df4 = pd.DataFrame({'estudios': ['Periodismo', 'Informática', 'Teleco'],\n",
    "                    'universidad': ['UCM', 'UPM', 'UPM']})\n",
    "pd.merge(df3, df4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### N-M join"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cuando las dos columnas comunes contienen valores duplicados:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "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>estudiante</th>\n",
       "      <th>estudios</th>\n",
       "      <th>habilidades</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Yago</td>\n",
       "      <td>Periodismo</td>\n",
       "      <td>Síntesis</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Yago</td>\n",
       "      <td>Periodismo</td>\n",
       "      <td>Redacción</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Luisa</td>\n",
       "      <td>Teleco</td>\n",
       "      <td>Programación</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Luisa</td>\n",
       "      <td>Teleco</td>\n",
       "      <td>Transmisión</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Carlos</td>\n",
       "      <td>Teleco</td>\n",
       "      <td>Programación</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Carlos</td>\n",
       "      <td>Teleco</td>\n",
       "      <td>Transmisión</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Irene</td>\n",
       "      <td>Informática</td>\n",
       "      <td>Programación</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>Irene</td>\n",
       "      <td>Informática</td>\n",
       "      <td>Arquitectura</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  estudiante     estudios   habilidades\n",
       "0       Yago   Periodismo      Síntesis\n",
       "1       Yago   Periodismo     Redacción\n",
       "2      Luisa       Teleco  Programación\n",
       "3      Luisa       Teleco   Transmisión\n",
       "4     Carlos       Teleco  Programación\n",
       "5     Carlos       Teleco   Transmisión\n",
       "6      Irene  Informática  Programación\n",
       "7      Irene  Informática  Arquitectura"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo N-M\n",
    "df5 = pd.DataFrame({'estudios': ['Periodismo', 'Informática', 'Teleco', \n",
    "                                 'Periodismo', 'Informática', 'Teleco'],\n",
    "                    'habilidades': ['Síntesis', 'Programación', 'Programación', \n",
    "                                    'Redacción', 'Arquitectura', 'Transmisión']})\n",
    "pd.merge(df3, df5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ejemplo de merge sobre índices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "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>pow2</th>\n",
       "      <th>pow3</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>num</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>9</td>\n",
       "      <td>27</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     pow2  pow3\n",
       "num            \n",
       "1       1     1\n",
       "2       4     8\n",
       "3       9    27"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df1_i = df1.set_index('num')\n",
    "df2_i = df2.set_index('num')\n",
    "pd.merge(df1_i, df2_i, left_index=True, right_index=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lo mismo usando join:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "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>pow2</th>\n",
       "      <th>pow3</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>num</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>9</td>\n",
       "      <td>27</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     pow2  pow3\n",
       "num            \n",
       "1       1     1\n",
       "2       4     8\n",
       "3       9    27"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df1_i.join(df2_i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Agregación y agrupamiento"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Agregación simple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para un objeto Series, el resultado de una agregación es un único valor; para un DataFrame el resultado es un objeto Series; la agregación se aplica a cada columna (default) o fila (axis='columns' o 1).\n",
    "\n",
    "Pandas hereda las agregaciones de NumPy. Estos son los métodos disponibles para Series y DataFrame:\n",
    "\n",
    " * Suma: `x.sum()`\n",
    " * Máximo: `x.max()`\n",
    " * Mínimo: `x.min()`\n",
    " * Producto: `x.prod()`\n",
    " * Media: `x.mean()`\n",
    " * Desviación estándar: `x.std()`\n",
    " * Desviación media: `x.mad()`\n",
    " * Varianza: `x.var()`\n",
    " * Mediana: `x.median()`\n",
    " * Primer elemento: `x.first()`\n",
    " * Último elemento: `x.last()`\n",
    " * Longitud: `x.count()`\n",
    "\n",
    "Además, aporta la función **`describe()`**, que devuelve los agregados más comunes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Agregación sobre subconjuntos: GroupBy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La operación `groupby()` permite hacer agregaciones más complejas sobre subconjuntos de los datos. Esta operación también se conoce como \"split-apply-combine\" (separar o agrupar los datos en subconjuntos, aplicar la operación de agregación a cada uno de ellos, y combinar los resultados en un array).\n",
    "\n",
    "El resultado de ejecutar groupby() es un objeto GroupBy (`DataFrameGroupBy` o `SeriesGroupBy`). Sobre dicho objeto aplicaremos la operación de agregación adecuada."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "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>key</th>\n",
       "      <th>data</th>\n",
       "      <th>data10</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>a</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>b</td>\n",
       "      <td>1</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>c</td>\n",
       "      <td>2</td>\n",
       "      <td>20</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>a</td>\n",
       "      <td>3</td>\n",
       "      <td>30</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>b</td>\n",
       "      <td>4</td>\n",
       "      <td>40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>c</td>\n",
       "      <td>5</td>\n",
       "      <td>50</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  key  data  data10\n",
       "0   a     0       0\n",
       "1   b     1      10\n",
       "2   c     2      20\n",
       "3   a     3      30\n",
       "4   b     4      40\n",
       "5   c     5      50"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo\n",
    "df = pd.DataFrame({'key': ['a', 'b', 'c', 'a', 'b', 'c'], 'data': range(6), 'data10': range(0,60,10)})\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<pandas.core.groupby.generic.DataFrameGroupBy object at 0x000001F38158F4C8>"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.groupby('key')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "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>data</th>\n",
       "      <th>data10</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>key</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>3</td>\n",
       "      <td>30</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>b</th>\n",
       "      <td>5</td>\n",
       "      <td>50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c</th>\n",
       "      <td>7</td>\n",
       "      <td>70</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     data  data10\n",
       "key              \n",
       "a       3      30\n",
       "b       5      50\n",
       "c       7      70"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.groupby('key').sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible crear una clave específica para hacer el groupby, que podemos ver como la columna clave anterior:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "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>data</th>\n",
       "      <th>data10</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5</td>\n",
       "      <td>50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>5</td>\n",
       "      <td>50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>5</td>\n",
       "      <td>50</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   data  data10\n",
       "0     5      50\n",
       "1     5      50\n",
       "2     5      50"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "key = [0, 1, 2, 2, 1, 0]\n",
    "df.groupby(key).sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se puede pensar en el objeto `GroupBy` como si de una colección de DataFrames se tratase. Podremos hacer varias cosas sobre este objeto:\n",
    " * Indexado sobre columna (y aplicación de la operación de agregación sobre ella)\n",
    " * Iteración sobre los grupos\n",
    " * Uso de describe() sobre los grupos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "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>data</th>\n",
       "      <th>data10</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>2.00000</td>\n",
       "      <td>2.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>1.50000</td>\n",
       "      <td>15.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>2.12132</td>\n",
       "      <td>21.213203</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>0.00000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>0.75000</td>\n",
       "      <td>7.500000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>1.50000</td>\n",
       "      <td>15.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>2.25000</td>\n",
       "      <td>22.500000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>3.00000</td>\n",
       "      <td>30.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          data     data10\n",
       "count  2.00000   2.000000\n",
       "mean   1.50000  15.000000\n",
       "std    2.12132  21.213203\n",
       "min    0.00000   0.000000\n",
       "25%    0.75000   7.500000\n",
       "50%    1.50000  15.000000\n",
       "75%    2.25000  22.500000\n",
       "max    3.00000  30.000000"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.groupby('key').get_group('a').describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El objeto `GroupBy` proporciona las siguientes operaciones:\n",
    " * `aggregate()` : permite hacer agregaciones de forma más flexible\n",
    " * `filter()` : filtrado por condiciones aplicadas sobre los grupos\n",
    " * `transform()` : permite hacer transformaciones en lugar de agregaciones\n",
    " * `apply()` : permite aplicar una función cualquiera a los resultados grupales, devolviendo un DataFrame o un escalar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "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>min</th>\n",
       "      <th>median</th>\n",
       "      <th>max</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>key</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>0</td>\n",
       "      <td>1.5</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>b</th>\n",
       "      <td>1</td>\n",
       "      <td>2.5</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c</th>\n",
       "      <td>2</td>\n",
       "      <td>3.5</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     min  median  max\n",
       "key                  \n",
       "a      0     1.5    3\n",
       "b      1     2.5    4\n",
       "c      2     3.5    5"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo con aggregate() aplicando varias agregaciones\n",
    "df.groupby('key')['data'].aggregate(['min', np.median, max]) # un string, una función de NumPy y otra de Pandas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "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>data</th>\n",
       "      <th>data10</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>key</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>0</td>\n",
       "      <td>30</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>b</th>\n",
       "      <td>1</td>\n",
       "      <td>40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c</th>\n",
       "      <td>2</td>\n",
       "      <td>50</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     data  data10\n",
       "key              \n",
       "a       0      30\n",
       "b       1      40\n",
       "c       2      50"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo con aggregate() diferenciando agregación por columna. Ideal para casos más complejos.\n",
    "df.groupby('key').aggregate({'data': 'min', 'data10': 'max'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "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>key</th>\n",
       "      <th>data</th>\n",
       "      <th>data10</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>b</td>\n",
       "      <td>1</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>c</td>\n",
       "      <td>2</td>\n",
       "      <td>20</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>b</td>\n",
       "      <td>4</td>\n",
       "      <td>40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>c</td>\n",
       "      <td>5</td>\n",
       "      <td>50</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  key  data  data10\n",
       "1   b     1      10\n",
       "2   c     2      20\n",
       "4   b     4      40\n",
       "5   c     5      50"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo con filter()\n",
    "def filtro(x):\n",
    "    return x['data'].mean() > 2\n",
    "\n",
    "df.groupby('key').filter(filtro)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "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>data</th>\n",
       "      <th>data10</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.00</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.01</td>\n",
       "      <td>0.1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.02</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.03</td>\n",
       "      <td>0.3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.04</td>\n",
       "      <td>0.4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0.05</td>\n",
       "      <td>0.5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   data  data10\n",
       "0  0.00     0.0\n",
       "1  0.01     0.1\n",
       "2  0.02     0.2\n",
       "3  0.03     0.3\n",
       "4  0.04     0.4\n",
       "5  0.05     0.5"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo con transform() \n",
    "df.groupby('key').transform(lambda x: x/100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "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>data</th>\n",
       "      <th>data10</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>key</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>9</td>\n",
       "      <td>900</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>b</th>\n",
       "      <td>25</td>\n",
       "      <td>2500</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c</th>\n",
       "      <td>49</td>\n",
       "      <td>4900</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     data  data10\n",
       "key              \n",
       "a       9     900\n",
       "b      25    2500\n",
       "c      49    4900"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo con apply() \n",
    "df.groupby('key').sum().apply(lambda x: x**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tablas dinámicas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una tabla dinámica se puede ver como una versión multidimensional de GroupBy, y es útil para visualizar mejor los datos. Podemos crearlas usando el método `pivot_table()` de los objetos DataFrame. Este método cuenta con las siguientes opciones:\n",
    " * `values` : columna sobre la que agregar\n",
    " * `index` : atributos o variables para filas\n",
    " * `columns` : atributos o variables para columnas\n",
    " * `affgunc` : función, lista de funciones o diccionario con agregaciones (por defecto: np.mean)\n",
    " * `fill_value` : escalar con el que sustituir los NA\n",
    " * `dropna` : booleano para descartar columnas con todo NaN (default: True)\n",
    " * `margins` : booleano para crear una nueva fila/columna (\"All\") con los totales (default:False)\n",
    " * `margins_name` : string para cambiar \"All\" por otra cosa en margins"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "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>survived</th>\n",
       "      <th>pclass</th>\n",
       "      <th>sex</th>\n",
       "      <th>age</th>\n",
       "      <th>sibsp</th>\n",
       "      <th>parch</th>\n",
       "      <th>fare</th>\n",
       "      <th>embarked</th>\n",
       "      <th>class</th>\n",
       "      <th>who</th>\n",
       "      <th>adult_male</th>\n",
       "      <th>deck</th>\n",
       "      <th>embark_town</th>\n",
       "      <th>alive</th>\n",
       "      <th>alone</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>male</td>\n",
       "      <td>22.0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>7.2500</td>\n",
       "      <td>S</td>\n",
       "      <td>Third</td>\n",
       "      <td>man</td>\n",
       "      <td>True</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Southampton</td>\n",
       "      <td>no</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>female</td>\n",
       "      <td>38.0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>71.2833</td>\n",
       "      <td>C</td>\n",
       "      <td>First</td>\n",
       "      <td>woman</td>\n",
       "      <td>False</td>\n",
       "      <td>C</td>\n",
       "      <td>Cherbourg</td>\n",
       "      <td>yes</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>female</td>\n",
       "      <td>26.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>7.9250</td>\n",
       "      <td>S</td>\n",
       "      <td>Third</td>\n",
       "      <td>woman</td>\n",
       "      <td>False</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Southampton</td>\n",
       "      <td>yes</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>female</td>\n",
       "      <td>35.0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>53.1000</td>\n",
       "      <td>S</td>\n",
       "      <td>First</td>\n",
       "      <td>woman</td>\n",
       "      <td>False</td>\n",
       "      <td>C</td>\n",
       "      <td>Southampton</td>\n",
       "      <td>yes</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>male</td>\n",
       "      <td>35.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>8.0500</td>\n",
       "      <td>S</td>\n",
       "      <td>Third</td>\n",
       "      <td>man</td>\n",
       "      <td>True</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Southampton</td>\n",
       "      <td>no</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   survived  pclass     sex   age  sibsp  parch     fare embarked  class  \\\n",
       "0         0       3    male  22.0      1      0   7.2500        S  Third   \n",
       "1         1       1  female  38.0      1      0  71.2833        C  First   \n",
       "2         1       3  female  26.0      0      0   7.9250        S  Third   \n",
       "3         1       1  female  35.0      1      0  53.1000        S  First   \n",
       "4         0       3    male  35.0      0      0   8.0500        S  Third   \n",
       "\n",
       "     who  adult_male deck  embark_town alive  alone  \n",
       "0    man        True  NaN  Southampton    no  False  \n",
       "1  woman       False    C    Cherbourg   yes  False  \n",
       "2  woman       False  NaN  Southampton   yes   True  \n",
       "3  woman       False    C  Southampton   yes  False  \n",
       "4    man        True  NaN  Southampton    no   True  "
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo con los datos de Titanic\n",
    "import seaborn as sns\n",
    "titanic = sns.load_dataset('titanic')\n",
    "titanic.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "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>class</th>\n",
       "      <th>First</th>\n",
       "      <th>Second</th>\n",
       "      <th>Third</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>sex</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>female</th>\n",
       "      <td>0.968085</td>\n",
       "      <td>0.921053</td>\n",
       "      <td>0.500000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>male</th>\n",
       "      <td>0.368852</td>\n",
       "      <td>0.157407</td>\n",
       "      <td>0.135447</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "class      First    Second     Third\n",
       "sex                                 \n",
       "female  0.968085  0.921053  0.500000\n",
       "male    0.368852  0.157407  0.135447"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Tabla dinámica para obtener la media de supervivientes por sexo y clase\n",
    "titanic.pivot_table('survived', index='sex', columns='class')\n",
    "\n",
    "# Lo mismo con groupby, bastante más complicado:\n",
    "# titanic.groupby(['sex', 'class'])['survived'].aggregate('mean').unstack()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos añadir más dimensiones. Creamos intervalos fijos para la edad usando `pd.cut`, y percentiles con `pd.qcut` para las tarifas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "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 tr th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr:last-of-type th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th>class</th>\n",
       "      <th colspan=\"2\" halign=\"left\">First</th>\n",
       "      <th colspan=\"2\" halign=\"left\">Second</th>\n",
       "      <th colspan=\"2\" halign=\"left\">Third</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th>fare</th>\n",
       "      <th>(-0.001, 14.454]</th>\n",
       "      <th>(14.454, 512.329]</th>\n",
       "      <th>(-0.001, 14.454]</th>\n",
       "      <th>(14.454, 512.329]</th>\n",
       "      <th>(-0.001, 14.454]</th>\n",
       "      <th>(14.454, 512.329]</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>sex</th>\n",
       "      <th>age</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"3\" valign=\"top\">female</th>\n",
       "      <th>(0, 18]</th>\n",
       "      <td>NaN</td>\n",
       "      <td>0.909091</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.714286</td>\n",
       "      <td>0.318182</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>(18, 40]</th>\n",
       "      <td>NaN</td>\n",
       "      <td>0.979167</td>\n",
       "      <td>0.900000</td>\n",
       "      <td>0.925926</td>\n",
       "      <td>0.454545</td>\n",
       "      <td>0.529412</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>(40, 100]</th>\n",
       "      <td>NaN</td>\n",
       "      <td>0.961538</td>\n",
       "      <td>0.800000</td>\n",
       "      <td>0.875000</td>\n",
       "      <td>0.333333</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"3\" valign=\"top\">male</th>\n",
       "      <th>(0, 18]</th>\n",
       "      <td>NaN</td>\n",
       "      <td>0.800000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.818182</td>\n",
       "      <td>0.260870</td>\n",
       "      <td>0.178571</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>(18, 40]</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.523810</td>\n",
       "      <td>0.078947</td>\n",
       "      <td>0.040000</td>\n",
       "      <td>0.136054</td>\n",
       "      <td>0.208333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>(40, 100]</th>\n",
       "      <td>NaN</td>\n",
       "      <td>0.280000</td>\n",
       "      <td>0.153846</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.068966</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "class                       First                             Second  \\\n",
       "fare             (-0.001, 14.454] (14.454, 512.329] (-0.001, 14.454]   \n",
       "sex    age                                                             \n",
       "female (0, 18]                NaN          0.909091         1.000000   \n",
       "       (18, 40]               NaN          0.979167         0.900000   \n",
       "       (40, 100]              NaN          0.961538         0.800000   \n",
       "male   (0, 18]                NaN          0.800000         0.000000   \n",
       "       (18, 40]               0.0          0.523810         0.078947   \n",
       "       (40, 100]              NaN          0.280000         0.153846   \n",
       "\n",
       "class                                         Third                    \n",
       "fare             (14.454, 512.329] (-0.001, 14.454] (14.454, 512.329]  \n",
       "sex    age                                                             \n",
       "female (0, 18]            1.000000         0.714286          0.318182  \n",
       "       (18, 40]           0.925926         0.454545          0.529412  \n",
       "       (40, 100]          0.875000         0.333333          0.000000  \n",
       "male   (0, 18]            0.818182         0.260870          0.178571  \n",
       "       (18, 40]           0.040000         0.136054          0.208333  \n",
       "       (40, 100]          0.000000         0.068966          0.000000  "
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "age = pd.cut(titanic['age'], [0, 18, 40, 100])\n",
    "fare = pd.qcut(titanic['fare'], 2)\n",
    "titanic.pivot_table('survived', ['sex', age], ['class', fare])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ejemplo usando `aggfunc`. Prescindimos del parámetro `values` por usar un diccionario:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "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 tr th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr:last-of-type th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th colspan=\"3\" halign=\"left\">fare</th>\n",
       "      <th colspan=\"3\" halign=\"left\">survived</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>class</th>\n",
       "      <th>First</th>\n",
       "      <th>Second</th>\n",
       "      <th>Third</th>\n",
       "      <th>First</th>\n",
       "      <th>Second</th>\n",
       "      <th>Third</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>sex</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>female</th>\n",
       "      <td>106.125798</td>\n",
       "      <td>21.970121</td>\n",
       "      <td>16.118810</td>\n",
       "      <td>91</td>\n",
       "      <td>70</td>\n",
       "      <td>72</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>male</th>\n",
       "      <td>67.226127</td>\n",
       "      <td>19.741782</td>\n",
       "      <td>12.661633</td>\n",
       "      <td>45</td>\n",
       "      <td>17</td>\n",
       "      <td>47</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              fare                       survived             \n",
       "class        First     Second      Third    First Second Third\n",
       "sex                                                           \n",
       "female  106.125798  21.970121  16.118810       91     70    72\n",
       "male     67.226127  19.741782  12.661633       45     17    47"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "titanic.pivot_table(index='sex', columns='class', aggfunc={'survived':sum, 'fare':'mean'})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También tenemos disponible la función `crosstab()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "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>class</th>\n",
       "      <th>First</th>\n",
       "      <th>Second</th>\n",
       "      <th>Third</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>sex</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>female</th>\n",
       "      <td>91</td>\n",
       "      <td>70</td>\n",
       "      <td>72</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>male</th>\n",
       "      <td>45</td>\n",
       "      <td>17</td>\n",
       "      <td>47</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "class   First  Second  Third\n",
       "sex                         \n",
       "female     91      70     72\n",
       "male       45      17     47"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.crosstab(index = titanic['sex'], columns = titanic['class'], values = titanic['survived'], aggfunc = 'sum')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operaciones vectorizadas sobre cadenas de texto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pandas proporciona una serie de operaciones vectorizadas (aplicables elemento a elemento) muy útiles a la hora de limpiar los datos del mundo real (valores NA, etc). Los objetos Series y DataFrame tienen un atributo `str`, que cuenta con una larga lista de métodos para realizar estas operaciones.\n",
    "\n",
    "Por un lado tenemos los métodos básicos que se corresponden con métodos nativos de Python:\n",
    "\n",
    "`len()`, `lower()`, `translate()`, `islower()`, `ljust()`, `upper()`, `startswith()`, `isupper()`, `rjust()`, `find()`, `endswith()`, `isnumeric()`, `center()`, `rfind()`, `isalnum()`, `isdecimal()`, `zfill()`, `index()`, `isalpha()`, `split()`, `strip()`, `rindex()`, `isdigit()`, `rsplit()`, `rstrip()`, `capitalize()`, `isspace()`, `partition()`, `lstrip()`, `swapcase()`, `istitle()`, `rpartition()`\n",
    "\n",
    "Por otro, los métodos que usan expresiones regulares:\n",
    "\n",
    " * `match()` : invoca `re.match()` sobre cada elemento, devolviendo un booleano\n",
    " * `extract()` : invoca `re.match()` sobre cada elemento, devolviendo los grupos matcheados como strings\n",
    " * `findall()` : invoca `re.findall()` sobre cada elemento\n",
    " * `replace()` : reemplaza las ocurrencias de un patrón con otro string\n",
    " * `contains()` : invoca `re.search()` sobre cada elemento, devolviendo un booleano\n",
    " * `count()` : cuenta las apariciones de un patrón\n",
    " * `split()` : equivalente a `str.split()` pero aceptando regexps \n",
    " * `rsplit()` : equivalente a `str.rsplit()` pero aceptando regexps\n",
    " \n",
    "Y por último métodos adicionales de utilidad:\n",
    " * `get()` : indexa cada elemento. Escribir df.str.get(0) es equivalente a df.str[0]\n",
    " * `slice()` : trocea cada elemento. Escribir df.str.slice(0, 2) es equivalente a df.str[0:2]\n",
    " * `slice_replace()` : reemplaza un trozo en cada elemento\n",
    " * `cat()` : concatenación de cadenas\n",
    " * `repeat()` : repetición de valores\n",
    " * `normalize()` : devuelve la representación unicode de un string\n",
    " * `pad()` : añade espacios en blanco al principio, al final o ambos\n",
    " * `wrap()` : trocea cadenas largas en varias líneas con una longitud menor a la indicada\n",
    " * `join()` : une cadenas en cada elemento con un separador especificado\n",
    " * `get_dummies()` : extrae variables dummy como columnas de un dataframe\n",
    " \n",
    "Más información: [Pandas: Working with text data](http://pandas.pydata.org/pandas-docs/stable/user_guide/text.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejemplo\n",
    "ss = pd.Series(['Arthur Dent', 'Marvin', 'Zaphod Beeblebrox', 'Ford Prefect', 'Tricia McMillan'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "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",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Arthur</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Marvin</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Zaphod</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Ford</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Tricia</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        0\n",
       "0  Arthur\n",
       "1  Marvin\n",
       "2  Zaphod\n",
       "3    Ford\n",
       "4  Tricia"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Extracción del nombre\n",
    "ss.str.extract('([A-Za-z]+)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    Art\n",
       "1    Mar\n",
       "2    Zap\n",
       "3    For\n",
       "4    Tri\n",
       "dtype: object"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Slicing\n",
    "ss.str[0:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0          Dent\n",
       "1        Marvin\n",
       "2    Beeblebrox\n",
       "3       Prefect\n",
       "4      McMillan\n",
       "dtype: object"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Extracción del apellido (o no!) usando chain\n",
    "ss.str.split().str.get(-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operaciones con series temporales"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pandas fue desarrollado en el contexto del modelado financiero, por lo que cuenta con un gran conjunto de herramientas para trabajar con fechas y datos temporales.\n",
    "\n",
    "Diferenciamos entre 3 tipos de estructuras.\n",
    "\n",
    " * **Marcas de tiempo** : Pandas proporciona un objeto `TimeStamp`, que aúna la facilidad de uso de los módulos *datetime* y *dateutil* de Python, con el eficiente almacenado y la interfaz vectorizada del tipo nativo (limitado) datetime64 de NumPy. Podremos construir un objeto `DatetimeIndex` a partir de un grupo de objetos TimeStamp, para usar como Index de Series o DataFrame. Podremos hacer indexado o selección como habitualmente.\n",
    " * **Incrementos de tiempo o duración** : Pandas proporciona el objeto `Timedelta`, que reemplaza a datetime.timedelta. La estructura Index asociada es `TimedeltaIndex`.\n",
    " * **Periodos de tiempo** : Pandas proporciona un objeto `Period`. La estructura Index asociada es `PeriodIndex`.\n",
    "\n",
    "Métodos disponibles:\n",
    " * `pd.to_datetime(s)` : parsea una fecha en formato texto (entiende distintas notaciones) y la convierte en TimeStamp, o parsea una lista de fechas y la convierte en DatetimeIndex.\n",
    " * `pd.to_timedelta(s, freq)` : crea un objeto TimedeltaIndex a partir de una secuencia y una **frecuencia** (p. ej. 'D'; diaria).\n",
    " * `pd.to_period(freq)` : transforma un objeto DatetimeIndex en un PeriodIndex\n",
    "\n",
    "**Frecuencias**:\n",
    "<table>\n",
    "  <tr>\n",
    "    <th>freq</th>\n",
    "    <th>means... </th>\n",
    "    <th>freq</th>\n",
    "    <th>means... </th>\n",
    "    <th>freq</th>\n",
    "    <th>means... </th>\n",
    "    <th>freq</th>\n",
    "    <th>means... </th>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>D</td>\n",
    "    <td>day</td>\n",
    "    <td>B</td>\n",
    "    <td>business day</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>W</td>\n",
    "    <td>weekly</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>M</td>\n",
    "    <td>month end</td>\n",
    "    <td>BM</td>\n",
    "    <td>business month end</td>\n",
    "    <td>MS</td>\n",
    "    <td>month start</td>\n",
    "    <td>BMS</td>\n",
    "    <td>business month start</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>Q</td>\n",
    "    <td>quarter end</td>\n",
    "    <td>BQ</td>\n",
    "    <td>business quarter end</td>\n",
    "    <td>QS</td>\n",
    "    <td>quarter start</td>\n",
    "    <td>BQS</td>\n",
    "    <td>business quarter start</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>A</td>\n",
    "    <td>year end</td>\n",
    "    <td>BA</td>\n",
    "    <td>business year end</td>\n",
    "    <td>AS</td>\n",
    "    <td>year start</td>\n",
    "    <td>BAS</td>\n",
    "    <td>business year start</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>H</td>\n",
    "    <td>hours</td>\n",
    "    <td>BH</td>\n",
    "    <td>business hours</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>T</td>\n",
    "    <td>minutes</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>S</td>\n",
    "    <td>seconds</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>L</td>\n",
    "    <td>ms</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>U</td>\n",
    "    <td>us</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>N</td>\n",
    "    <td>ns</td>\n",
    "  </tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2019-02-20 00:00:00')"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo creación de TimeStamp a partir de una única fecha\n",
    "date = pd.to_datetime(\"20th of February, 2019\")\n",
    "date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TimedeltaIndex([ '0 days',  '1 days',  '2 days',  '3 days',  '4 days',\n",
       "                 '5 days',  '6 days',  '7 days',  '8 days',  '9 days',\n",
       "                '10 days', '11 days', '12 days', '13 days', '14 days'],\n",
       "               dtype='timedelta64[ns]', freq=None)"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo creación de TimedeltaIndex, en días\n",
    "delta = pd.to_timedelta(np.arange(15), 'D')\n",
    "delta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2019-02-20', '2019-02-21', '2019-02-22', '2019-02-23',\n",
       "               '2019-02-24', '2019-02-25', '2019-02-26', '2019-02-27',\n",
       "               '2019-02-28', '2019-03-01', '2019-03-02', '2019-03-03',\n",
       "               '2019-03-04', '2019-03-05', '2019-03-06'],\n",
       "              dtype='datetime64[ns]', freq=None)"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Conversión en serie temporal (TimeStamp + TimedeltaIndex = DatetimeIndex)\n",
    "date + delta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2019-07-03', '2019-07-04', '2019-07-06', '2019-07-07',\n",
       "               '2019-07-08'],\n",
       "              dtype='datetime64[ns]', freq=None)"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo de creación de DatetimeIndex a partir de una lista de fechas\n",
    "from datetime import datetime\n",
    "dates = pd.to_datetime([datetime(2019, 7, 3), '4th of July, 2019',\n",
    "                       '2019-Jul-6', '07-07-2019', '20190708'])\n",
    "dates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TimedeltaIndex(['133 days', '134 days', '136 days', '137 days', '138 days'], dtype='timedelta64[ns]', freq=None)"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Podemos crear un TimedeltaIndex por ejemplo restando una fecha a una lista\n",
    "dates - date"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si tenemos un objeto `Series` (una columna de un `DataFrame`) con fechas y queremos obtener por ejemplo el mes (atributo `month` de un objeto fecha) de todos sus elementos, tendremos que usar el atributo de acceso `dt`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0     3\n",
       "1     6\n",
       "2     9\n",
       "3    12\n",
       "dtype: int64"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "date_series = pd.Series(pd.date_range(\"2010-01-08\", periods=4, freq=\"q\"))\n",
    "date_series.dt.month"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lista completa de atributos disponibles a través de dt: `dt.date`, `dt.time`, `dt.timetz`, `dt.year`, `dt.month`, `dt.day`, `dt.hour`, `dt.minute`, `dt.second`, `dt.microsecond`, `dt.nanosecond`, `dt.week`, `dt.weekofyear`, `dt.dayofweek`, `dt.weekday`, `dt.dayofyear`, `dt.quarter`, `dt.is_month_start`, `dt.is_month_end`, `dt.is_quarter_start`, `dt.is_quarter_end`, `dt.is_year_start`, `dt.is_year_end`, `dt.is_leap_year`, `dt.daysinmonth`, `dt.days_in_month`, `dt.tz`, `dt.freq`, `dt.to_period`, `dt.to_pydatetime`, `dt.tz_localize`, `dt.tz_convert`, `dt.normalize`, `dt.strftime`, `dt.round`, `dt.floor`, `dt.ceil`, `dt.month_name`, `dt.day_name`, `dt.qyear`, `dt.start_time`, `dt.end_time`, `dt.days`, `dt.seconds`, `dt.microseconds`, `dt.nanoseconds`, `dt.components`, `dt.to_pytimedelta`, `dt.total_seconds`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Secuencias regulares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para facilitar la creación de secuencias de fechas, Pandas ofrece las siguientes funciones:\n",
    " * `pd.date_range()` : para timestamps\n",
    " * `pd.period_range()` : para periodos\n",
    " * `pd.timedelta_range()` : para deltas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2019-07-03', '2019-07-04', '2019-07-05', '2019-07-06',\n",
       "               '2019-07-07', '2019-07-08', '2019-07-09', '2019-07-10'],\n",
       "              dtype='datetime64[ns]', freq='D')"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo con timestamps\n",
    "pd.date_range('2019-07-03', '2019-07-10') # = pd.date_range('2019-07-03', periods=8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2019-07-03 00:00:00', '2019-07-03 01:30:00',\n",
       "               '2019-07-03 03:00:00', '2019-07-03 04:30:00',\n",
       "               '2019-07-03 06:00:00', '2019-07-03 07:30:00',\n",
       "               '2019-07-03 09:00:00', '2019-07-03 10:30:00'],\n",
       "              dtype='datetime64[ns]', freq='90T')"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Con otra frecuencia\n",
    "pd.date_range('2019-07-03', periods=8, freq='1H30T')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TimedeltaIndex(['0 days', '1 days', '2 days', '3 days', '4 days', '5 days',\n",
       "                '6 days', '7 days'],\n",
       "               dtype='timedelta64[ns]', freq='D')"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo con deltas\n",
    "pd.timedelta_range(0, periods=8, freq='D')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Remuestreo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Con Pandas podemos remuestrear a una frecuencia más baja (submuestreo) o más alta (sobremuestreo):\n",
    " * `resample(freq)` : agrupa los datos con una determinada frecuencia (requiere aplicar una operación de agregación al resultado). \n",
    " * `asfreq(freq [, method='func'])` : selecciona los datos con una determinada frecuencia (un punto cada x tiempo)\n",
    " \n",
    "Al sobremuestrear generaremos por defecto valores NA. Con `asfreq()` podemos modificar esos valores gracias al parámetro method, que acepta como entrada 'bfill' o 'ffill' (igual que en el método fillna())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Desplazamiento temporal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos mover nuestros datos en el tiempo usando ciertos métodos:\n",
    " * `shift(n)` : desplaza los datos n veces la frecuencia original (hacia la derecha)\n",
    " * `tshift(n)` : desplaza el index n veces la frecuencia original (hacia la izquierda)\n",
    " \n",
    "Esto puede ser útil para comparar los datos en distintos periodos, o para crear nuevas features de entrada a partir de muestras de la serie en momentos pasados."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Estadísticas contínuas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las estadísticas contínuas (\"rolling statistics\") son el tercer tipo de operaciones implementadas para las series temporales en Pandas. La idea es generar ventanas de una duración determinada a lo largo de una serie temporal (podemos imaginarnos una ventana deslizante que va desde el principio de los datos hasta el final). Podremos obtener los estadísticos básicos de la sucesión de ventanas.\n",
    "\n",
    "Usaremos:\n",
    " * `rolling()` : método de los objetos Series y DataFrame, que devuelve una vista similar a la devuelta por la operación groupby. Esta vista, conocida como \"rolling window\", no es más que una ventana deslizante que nos da la posibilidad de ejecutar varias operaciones de agregación incluidas sobre dicha ventana.\n",
    " * `expanding()` : parecido a la anterior pero en inicio de la ventana no se mueve; la ventana se va expandiendo.\n",
    " \n",
    "Si por ejemplo tenemos una serie temporal de 10 años, y le aplicamos el método rolling(365, center=True), obtendremos una ventana deslizante centrada de 1 año. Eso significa que si aplicamos la operación mean() sobre la ventana, obtendremos una nueva serie temporal cuyo valor en cada punto es la media de todos los valores de la serie temporal original dentro la ventana de 1 año centrada en ese punto. Cuidado con coger el centro a la ligera porque podríamos estar cogiendo datos del futuro."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Más información** sobre series temporales en: [Pandas doc: Time series](http://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Alto rendimiento"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tanto NumPy como Pandas soportan operaciones vectorizadas rápidas, como por ejemplo la suma elemento a elemento con '+'. Pero las operaciones son menos eficientes cuando tenemos expresiones compuestas, ya que se evalúan por partes, malgastando memoria y CPU para cada paso intermedio. Si los arrays involucrados son muy grandes, esto puede ser un problema.\n",
    "\n",
    "El paquete `Numexpr`, y más en concreto la función `evaluate()` nos permite evaluar estas expresiones compuestas elemento a elemento, sin arrays intermedios. \n",
    "\n",
    "En la versión 0.13 de Pandas se introdujeron 2 funciones nuevas de alto nivel que permitían acceder a operaciones con la velocidad de C. Estas funciones son `eval()` y `query()`, basadas en Numexpr y similares a evaluate().\n",
    "\n",
    "La cuestión es ¿cuándo usarlas? pues basicamente cuando vayamos justos de memoria porque los DataFrames son muy grandes (podemos usar `df.values.nbytes` para comprobar su tamaño). Por rapidez estamos hablando de una mejora aproximada de ~2x para DataFrames grandes, pero puede llegar a ser incluso un empeoramiento con menos datos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### pd.eval()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función `pd.eval()` recibe como parámetro un string que contiene una expresión con operaciones. Soporta:\n",
    " * todas las operaciones aritméticas\n",
    " * las comparaciones (incluso encadenadas)\n",
    " * los operadores `&`, `|`, `and` y `or` con booleanos\n",
    " * indexado mediante obj.atrib y obj[index]\n",
    "\n",
    "Para otras operaciones, recurriremos al paquete Numexpr.\n",
    "\n",
    "Vemos un ejemplo para comprobar la diferencia de rendimiento que obtenemos con su uso:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejemplo\n",
    "seed = np.random.RandomState(42)\n",
    "df1, df2, df3, df4 = (pd.DataFrame(seed.rand(100000, 100)) for i in range(4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "78.4 ms ± 2.7 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "# Sin pd.eval()\n",
    "%timeit df1 + df2 + df3 + df4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "39.2 ms ± 2.44 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "# Con pd.eval()\n",
    "%timeit pd.eval('df1 + df2 + df3 + df4')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### df.eval()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funciona de forma similar a pd.eval() pero directamente sobre DataFrames. Los beneficios de usar este método son varios:\n",
    "\n",
    " 1. Las columnas pueden ser referenciadas simplemente escribiendo su nombre:\n",
    "\n",
    " `df.eval('(A + B) / (C - 1)')` *vs* `pd.eval(\"(df.A + df.B) / (df.C - 1)\")` \n",
    " \n",
    "\n",
    " 2. También podemos crear una nueva columna:\n",
    "\n",
    " `df.eval('D = (A + B) / (C - 1)' inplace=True)`\n",
    " \n",
    "\n",
    " 3. Podemos usar variables de Python usando el prefijo `@`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### df.query()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hay expresiones que no podremos evaluar con df.eval(), como por ejemplo la selección mediante masking, ya que la expresión depende de columnas del dataframe:\n",
    "\n",
    "`pd.eval('df[(df.A < 0.5) & (df.B < 0.5)]')`\n",
    "\n",
    "Para resolver este problema tenemos la función df.query():\n",
    "\n",
    "`df.query('A < 0.5 and B < 0.5')`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Más información** sobre mejoras del rendimiento en: [Pandas docs: Enhancing performance](https://pandas.pydata.org/pandas-docs/stable/user_guide/enhancingperf.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Best of Pandas API"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From [dunder-data](https://medium.com/dunder-data/minimally-sufficient-pandas-a8e67f2a2428):\n",
    "\n",
    "* **Attributes:** `columns`, `dtypes`, `index`, `shape`, `T`, `values`, `size`, `ndim`, `dtype`\n",
    "* **Aggregation Methods:** `all`, `any`, `count`, `describe`, `idxmax`, `idxmin`, `max`, `mean`, `median`, `min`, `mode`, `nunique`, `sum`, `std`, `var`\n",
    "* **Non-Aggregation Statistical Methods:** `abs`, `clip`, `corr`, `cov`, `cummax`, `cummin`, `cumprod`, `cumsum`, `diff`, `nlargest`, `nsmallest`, `pct_change`, `prod`, `quantile`, `rank`, `round`\n",
    "* **Subset Selection:** `head`, `iloc`, `loc`, `tail`\n",
    "* **Missing Value Handling:** `dropna`, `fillna`, `interpolate`, `isna`, `notna`\n",
    "* **Grouping:** `expanding`, `groupby`, `pivot_table`, `resample`, `rolling`\n",
    "* **Joining Data:** `append`, `merge`\n",
    "* **Other:** `asfreq`, `assign`, `astype`, `copy`, `drop`, `drop_duplicates`, `equals`, `isin`, `melt`, `plot`, `rename`, `replace`, `reset_index`, `sample`, `select_dtypes`, `shift`, `sort_index`, `sort_values`, `to_csv`, `to_json`, `to_sql`\n",
    "* **Functions:** `pd.concat`, `pd.crosstab`, `pd.cut`, `pd.qcut`, `pd.read_csv`, `pd.read_json`, `pd.read_sql`, `pd.to_datetime`, `pd.to_timedelta`"
   ]
  }
 ],
 "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.7.5"
  },
  "nbTranslate": {
   "displayLangs": [
    "en",
    "es"
   ],
   "hotkey": "alt-t",
   "langInMainMenu": false,
   "sourceLang": "es",
   "targetLang": "en",
   "useGoogleTranslate": true
  },
  "toc": {
   "base_numbering": "0",
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Mis notas: Pandas",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "346px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}