Py2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "**Universidad de Costa Rica** | Escuela de Ingeniería Eléctrica\n",
    "\n",
    "*IE0405 - Modelos Probabilísticos de Señales y Sistemas*\n",
    "\n",
    "### `PyX` - Serie de tutoriales de Python para el análisis de datos\n",
    "\n",
    "\n",
    "# `Py3` - *Librería de manipulación y análisis de datos Pandas*\n",
    "\n",
    "> **Pandas** es una útil y popular librería de manipulación de datos que ofrece estructuras de datos para el análisis de tablas numéricas y series de tiempo. Por sus capacidades, es comparable con Excel u otras hojas de cálculo, pero de forma *programática*. Esta es una introducción al objeto `DataFrame` y sus características básicas.\n",
    "\n",
    "*Fabián Abarca Calderón* \\\n",
    "*Jonathan Rojas Sibaja*\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Librería Pandas\n",
    "\n",
    "Para trabajar con una gran cantidad de datos, es deseable un conjunto de herramientas que nos permitan efectuar operaciones comunes de forma intuitiva y eficiente. Pandas, es la solución por defecto para hacerlo en Python, y es parte del ecosistema de SciPy. Viene instalado con Anaconda.\n",
    "\n",
    "**Nota 0**: La documentación oficial está en [https://pandas.pydata.org/docs/](https://pandas.pydata.org/docs/).\n",
    "\n",
    "Esta guía está basada en \"[Getting started tutorials](https://pandas.pydata.org/docs/getting_started/intro_tutorials/index.html)\".\n",
    "\n",
    "**Nota 1**: Para toda esta guía se hará la siguiente importación de librerías.\n",
    "\n",
    "**Nota 2**: Por convención, el *alias* de Pandas es `pd`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import datetime"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Estructuras de datos de Pandas\n",
    "\n",
    "Pandas permitirá la creación de las nuevas estructuras de datos `Series` y `DataFrame`, que son clases optimizadas para manipulación de datos. Aunque son similares en su forma a estructuras de Python como listas y diccionarios, en realidad incorporan una gran cantidad de nuevos atributos y métodos:\n",
    "\n",
    "| Clase       | Atributos | Métodos |\n",
    "|-------------|-----------|---------|\n",
    "| `Series`    | 20+       | 180+    |\n",
    "| `DataFrame` | 10+       | 210+    |\n",
    "\n",
    "- [Documentación](https://pandas.pydata.org/docs/reference/series.html) de `Series` \n",
    "- [Documentación](https://pandas.pydata.org/docs/reference/frame.html) de `DataFrame` \n",
    "---\n",
    "## 3.1. - `Series`\n",
    "\n",
    "En Python, las `Series` corresponden a un arreglo de **una** dimensión que admite diversos tipos de datos (números enteros, palabras, números flotantes, objetos de Python, etc.) y que además están etiquetados mediante un índice que el usuario puede definir o permitir que Python lo cree por defecto. \n",
    "\n",
    "Para crear listas o `Series` de valores se utiliza la siguiente sintaxis:\n",
    "\n",
    "```python\n",
    "pandas.Series(data=None, index=None, \n",
    "              dtype=None, name=None, copy=False, fastpath=False)\n",
    "```\n",
    "\n",
    "donde `data` es una secuencia o estructura de datos iterable de Python, como una lista, una tupla, un diccionario, un rango, etc. El siguiente ejemplo tiene indexado automático."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = pd.Series([1, 3, 5, np.nan, \"modelos\", 8.5])\n",
    "\n",
    "# Ver objeto Series\n",
    "print(s)\n",
    "\n",
    "# Utilizar atributo .count\n",
    "print('Número de elementos no nulos: {}.'.format(s.count()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Utilizado el comando de NumPy `random.randn` es posible generar datos aleatorios para la lista. También es posible agregar índices distintos a los numéricos, utilizando el argumento `index` y una lista de índices del mismo tamaño que los datos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = pd.Series(np.random.randn(5), index=['a', 'b', 'c', 'd', 'e'])\n",
    "print(s)\n",
    "\n",
    "p = pd.Series([1, '!', 5, '?', \"hola\", 13], index=[6, 5, 4, 3, 2, 1])\n",
    "print(p)\n",
    "\n",
    "q = pd.Series(range(5), index=['a', 'b', 'c', 'd', 'e'])\n",
    "print(q)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible hacer una inspección a los atributos y métodos de los objetos `Series` creados anteriormente con la función `dir()` de Python, y podrán apreciarse descriptores estadísticos como la correlación o la media."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(dir(s))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una vez creado el objeto `Series` se pueden ejecutar operaciones vectoriales con la misma o agregar otros atributos, como un nombre."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = pd.Series(q + q, name='suma')\n",
    "print(d)\n",
    "\n",
    "e = pd.Series(q**2, name='potencia')\n",
    "print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 3.2. - `DataFrame`\n",
    "\n",
    "En Pandas, un `DataFrame` corresponde a un arreglo etiquetado de **dos dimensiones**, semejante a concatenar varias `Series`. También admite varios tipos de datos. \n",
    "\n",
    "> Un `DataFrame` tiene una funcionalidad equivalente a una hoja de cálculo o una tabla SQL y permite manipular datos de forma versátil y eficiente. \n",
    "\n",
    "La sintaxis de creación de un `DataFrame` es:\n",
    "\n",
    "```python\n",
    "pandas.DataFrame(data=None, index=None, \n",
    "                 columns=None, dtype=None, copy=None)\n",
    "```\n",
    "\n",
    "donde `data` es típicamente un diccionario en el que cada llave/valor describe una columna. Sin embargo, se puede crear de varias otras maneras, como desde archivos JSON o CSV importados.\n",
    "\n",
    "La asignación de las etiquetas puede ser decidida por el usuario y Python hará coincidir los valores, en caso de diferencias en los tamaños de las listas agregadas, rellenará esos espacios siguiendo reglas de sentido común. \n",
    "\n",
    "A continuación un ejemplo de dos `Series` de diferentes tamaños. Observar las diferencias en el orden de los índices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creación de un diccionario con las series indexadas\n",
    "d = {\n",
    "     'esta': pd.Series([1., 2., 3.], index=['a', 'b', 'c']),\n",
    "     'otra': pd.Series([1., 2., 3., 4.], index=['c', 'a', 'd', 'b'])\n",
    "}\n",
    "\n",
    "# Creación del DataFrame a partir del diccionario\n",
    "df = pd.DataFrame(d)\n",
    "\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Con `dir()` también es posible consultar atributos y métodos disponibles de `DataFrame`.\n",
    "\n",
    "##### Ejemplo con índice tipo \"timestamp\"\n",
    "\n",
    "Los índices podrían ser una estampa de tiempo (*timestamp*). Este es un caso útil en el que, por ejemplo, se lleva un registro de varias variables (las columnas) en una sucesión de momentos distintos (el índice):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creación de un rango de fechas\n",
    "fechas = pd.date_range('20200101', periods=6)\n",
    "\n",
    "# Creación de un DataFrame con las fechas como índices\n",
    "df = pd.DataFrame(np.random.randn(6, 4), index=fechas, columns=list('ABCD'))\n",
    "\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Ejemplo con distintos tipos de datos\n",
    "\n",
    "Como en las `Series`, los `DataFrame` pueden utilizar diferentes tipos de datos en cada columna y asignarse como diccionarios."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame({'A': 1.,\n",
    "                   'B': pd.Timestamp('20200101'),\n",
    "                   'C': pd.Series(1, index=list(range(4))),\n",
    "                   'D': np.array([3] * 4, dtype='int32'),\n",
    "                   'E': pd.Categorical(['norte', 'sur', 'este', 'oeste']),\n",
    "                   'F': 'hola'\n",
    "                  })\n",
    "\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Modificaciones al `DataFrame`\n",
    "\n",
    "Una vez incializado el `DataFrame`, se pueden ejecutar acciones como extraer, eliminar e insertar columnas, con una sintaxis similar a la de los [diccionarios](https://www.w3schools.com/python/python_dictionaries.asp)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Extraer una columna\n",
    "df['E']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Eliminar columna 'F'\n",
    "del df['F']\n",
    "\n",
    "# Mostrar nuevo DataFrame sin columna 'F'\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Asignar nuevos datos a la columna 'A'\n",
    "df['A'] = pd.Series(np.random.randn(4), index=list(range(4)))\n",
    "\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Crear nueva columna 'A+' y agregar valores según criterio\n",
    "df['A+'] = df['A'] > 0\n",
    "\n",
    "# Mostrar nuevo DataFrame\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 3.3. - Inspeccionar los datos\n",
    "\n",
    "Es posible (y útil) \"echar un vistazo\" a los primeros y últimos datos. Por ejemplo, del `DataFrame` llamado `df` se pueden ver las primeras ***N*** filas de datos con el comando `head`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.head(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si solamente se desea visualizar las útimas tres líneas se utiliza el comando `tail`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.tail(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para visualizar los índices, se utiliza:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Ejemplo de convertir a NumPy\n",
    "\n",
    "Cuando sea deseable, se puede transformar el `DataFrame` a un `array` de NumPy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.to_numpy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lo anterior tanto si el `DataFrame` tiene un solo tipo o diversos tipos de datos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Ejemplo de manipulación para un solo tipo de datos\n",
    "\n",
    "Si todos los elementos son del mismo tipo, se pueden ejecutar algunas funciones de análisis y manipulación específicas, especialmente si son datos numéricos.\n",
    "\n",
    "A continuación se crea un `DataFrame` tipo matriz 6$\\times$4 de números aleatorios."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_num = pd.DataFrame(np.random.randn(6, 4), columns=list(\"ABCD\"), index=['a', 'b', 'c', 'd', 'e', 'f'])\n",
    "\n",
    "df_num"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible obtener un resumen de los principales descriptores estadísticos de cada columna, en este caso: el conteo de elementos, la media, la desviación estándar, el valor mínimo, el primer, segundo y tercer cuartil, y el valor máximo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_num.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Reordenar datos\n",
    "\n",
    "Es común desear reordenar los datos con alguna columna de referencia:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_num.sort_values(by='B')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 3.4. - Seleccionar datos\n",
    "\n",
    "> En Python, la selección (o búsqueda) de datos utilizando Pandas es más eficiente que las expresiones para seleccionar y obtener datos en NumPy. \n",
    "\n",
    "Por ejemplo, para ubicar una **fila** de datos, se puede utilizar el comando  `loc`, que tiene muchas opciones para buscar índices, según la [documentación](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.loc.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.loc[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También se pueden seleccionar un rango de filas (registros) al mismo tiempo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[0:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para obtener una posición en específico, se debe indicar la fila y la columna mediante el comando `at`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.at[2, 'E']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se puede ubicar ese mismo elemento por medio de la posición y no los índices, utilizando el comando `iloc`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.iloc[2, 4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se pueden ubicar los datos que cumplan con cierta condición booleana:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[df['A'] > 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[df['E'] == 'sur']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 3.5. - Operaciones sobre datos\n",
    "\n",
    "En Python, las operaciones se ejecutan sobre todos los datos arrojando el valor de salida por filas o columnas.\n",
    "\n",
    "Por ejemplo, para calcular la media estadística de los datos de cada columna, se utiliza el comando `mean` que recorre la dimensión `0` (filas) de la siguiente manera:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "df_num.mean(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si en cambio se desea conocer la media de los valores por filas, se utiliza la siguiente variación, donde `1` es la dimensión de las columnas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_num.mean(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Ejemplo de conteo de ocurrencias de valores únicos\n",
    "\n",
    "Para la siguiente serie de ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "letras = ['a', 'b', 'c', 'd', 'e']\n",
    "serie = pd.Series(np.random.choice(letras, size=15))\n",
    "serie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se pueden aplicar operaciones tales como el conteo (o \"apariciones de cada uno\") sobre `Series` o `DataFrame`, y devuelve un resultado clasificado de mayor a menor número de ocurrencias."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "serie.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.value_counts(df['A+'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Operaciones sobre caracteres\n",
    "\n",
    "También existen operaciones que se pueden aplicar sobre `Series` de palabras:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "G = pd.Series(['ÁRbOL', 'BLanCO', 'AvE', 'BuRRo'])\n",
    "g = G.str.lower()\n",
    "\n",
    "pd.DataFrame({'G': G, 'g': g})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 3.6. - Fusionar datos\n",
    "\n",
    "En Pandas, para concatenar datos se utiliza el comando `concat()` donde\n",
    "\n",
    "```python\n",
    "pandas.concat(objs, axis=0, join='outer', ignore_index=False, \n",
    "              keys=None, levels=None, names=None, verify_integrity=False, \n",
    "              sort=False, copy=True)[source]\n",
    "```\n",
    "\n",
    "donde `axis=` determine a lo largo de cuál dimensión se concatenan: `0` filas (vertical) y `1` columnas (horizontal) de la siguiente forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Crear DataFrame de ejemplo\n",
    "df_a = pd.DataFrame(np.random.randn(5,2))\n",
    "df_b = pd.DataFrame(np.random.randn(5,2))\n",
    "\n",
    "# Extraer fragmentos y concatenarlos\n",
    "fragmentos = [df_a[:], df_b[:]]\n",
    "pd.concat(fragmentos, axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Nota**: Observar que es necesario extraer los fragmentos primero porque no se pueden concatenar `DataFrame` directamente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 3.7. - Agrupar datos\n",
    "\n",
    "En Pandar, \"agrupar\" se refiere a:\n",
    "\n",
    "- Separar los datos en grupos basándose en un criterio.\n",
    "- Aplicar una función a cada grupo independientemente.\n",
    "- Combinar los resultados en una estructura de datos.\n",
    "\n",
    "A continuación hay un ejemplo de agrupación aplicando una suma a las columnas numéricas asociadas por cierto criterio:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_foo = pd.DataFrame({'A': ['foo', 'bar', 'foo', 'bar', 'foo'],\n",
    "                       'B': ['uno', 'dos', 'dos', 'tres', 'dos'],\n",
    "                       'C': np.random.randn(5),\n",
    "                       'D': np.random.randn(5)})\n",
    "df_foo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El siguiente resultado agrupa las filas según los elementos en `A` y suma los resultados de las columnas no categóricas (es decir, numéricas), que en este caso son `C` y `D`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_foo.groupby('A').sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El siguiente resultado agrupa primero por `A` y luego por `B`, para finalmente sumar las columnas `C` y `D` asociadas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_foo.groupby(['A', 'B']).sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 3.8. - Reacomodar datos\n",
    "\n",
    "##### Apilar\n",
    "\n",
    "En Pandas, una forma de reacomodar los datos es mediante el comando `stack`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pila = df.stack()\n",
    "\n",
    "pila"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Tabla pivote\n",
    "\n",
    "También se puede cambiar la forma de ordenar los datos como tablas pivote:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_piv = pd.DataFrame({'A': ['uno', 'uno', 'dos', 'tres']*3,\n",
    "                       'B': ['A', 'B', 'C']*4,\n",
    "                       'C': ['foo', 'foo', 'foo', 'bar', 'bar', 'bar']*2,\n",
    "                       'D': np.random.randn(12),\n",
    "                       'E': np.random.randn(12)})\n",
    "df_piv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En la siguiente tabla va a sumar los valores en `D` asociados con la agrupación con respecto a `A` y `B`, para cada categoría en `C`. Es una herramienta **poderosa**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = pd.pivot_table(df_piv, values='D', \n",
    "                   index=['A', 'B'], columns=['C'])\n",
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Cómo extraer un elemento de una tabla pivote?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v['bar']['dos']['B']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 3.9. - Series de tiempo\n",
    "\n",
    "En Pandas, las series de tiempo permiten generar secuencias con una frecuencia fija en un lapso de tiempo, como por ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tres ciclos horarios que inician el 1 de enero de 2020\n",
    "dti = pd.date_range('1-1-2020', periods=3, freq='H')\n",
    "dti"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cuya hora se puede convertir a una zona horaria diferente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dti = dti.tz_localize('America/Costa_Rica')\n",
    "dti"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También se pueden convertir una serie de tiempo a una frecuencia particular:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "idx = pd.date_range('2020-01-01', periods=5, freq='H')\n",
    "ts = pd.Series(range(len(idx)), index=idx)\n",
    "ts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ts.resample('2H').mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 3.10. - Gráficas\n",
    "\n",
    "En Python, se utiliza la asignación estándar para utilizar los comandos del API de `matplotlib` como métodos de la `Series` y `DataFrame`. Así, por ejemplo, se puede graficar una `Serie` de datos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.close('all')\n",
    "\n",
    "# Crear serie temporal\n",
    "ts = pd.Series(np.random.randn(1000),\n",
    "              index=pd.date_range('1/1/2020', periods=1000))\n",
    "\n",
    "# Suma acumulada\n",
    "ts = ts.cumsum()\n",
    "\n",
    "# Método .plot() de Matplotlib sobre la serie temporal\n",
    "ts.plot()\n",
    "plt.xlabel('Días')\n",
    "plt.ylabel('Valor')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También se pueden graficar arreglos del tipo `DataFrame` de manera que se grafican varias curvas en una misma gráfica como se muestra a continuación:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Crear números aleatorias con el mísmo índice de ts\n",
    "df = pd.DataFrame(np.random.randn(1000, 4), index=ts.index,\n",
    "                 columns=['A', 'B', 'C', 'D'])\n",
    "df = df.cumsum()\n",
    "\n",
    "# Graficar las curvas\n",
    "plt.figure()\n",
    "df.plot()\n",
    "plt.legend(loc='best')\n",
    "plt.xlabel('Días')\n",
    "plt.ylabel('Valor')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 3.11. - Importar y exportar datos\n",
    "\n",
    "Pandas es un excelente \"manejador\" de archivos externos de datos, tipo `.xls` o `.csv`. Por ejemplo, para crear un archivo `modelos.csv` a partir de los datos anteriores:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "df.to_csv('modelos')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cuyo contenido se puede \"llamar\" nuevamente utilizando el comando a continuación, que lo guarda como un `DataFrame`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.read_csv('modelos')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### Más información\n",
    "\n",
    "* [Página oficial de Pandas](https://pandas.pydata.org/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "**Universidad de Costa Rica** | Facultad de Ingeniería | Escuela de Ingeniería Eléctrica\n",
    "\n",
    "&copy; 2021\n",
    "\n",
    "---"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}