Modulo12_EcosistemaPython_Pandas.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1 align=\"center\">Pensamiento Algorítmico</h1>\n",
    "<h1 align=\"center\">Módulo 12: Ecosistema Python - Pandas</h1>\n",
    "<h1 align=\"center\">2024/01</h1>\n",
    "<h1 align=\"center\">MEDELLÍN - COLOMBIA </h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*** \n",
    "|[![Gmail](https://img.shields.io/badge/Gmail-D14836?style=plastic&logo=gmail&logoColor=white)](mailto:carlosalvarezh@gmail.com)|<carlosalvarezh@gmail.com>|[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/carlosalvarezh/Pensamiento_Algoritmico/blob/main/Modulo12_EcosistemaPython_Pandas.ipynb)\n",
    "|-:|:-|--:|\n",
    "|[![LinkedIn](https://img.shields.io/badge/linkedin-%230077B5.svg?style=plastic&logo=linkedin&logoColor=white)](https://www.linkedin.com/in/carlosalvarez5/)|[![@alvarezhenao](https://img.shields.io/twitter/url/https/twitter.com/alvarezhenao.svg?style=social&label=Follow%20%40alvarezhenao)](https://twitter.com/alvarezhenao)|[![@carlosalvarezh](https://img.shields.io/badge/github-%23121011.svg?style=plastic&logo=github&logoColor=white)](https://github.com/carlosalvarezh)|\n",
    "\n",
    "<table>\n",
    " <tr align=left><td><img align=left src=\"https://github.com/carlosalvarezh/Curso_CEC_EAFIT/blob/main/images/CCLogoColorPop1.gif?raw=true\" width=\"25\">\n",
    " <td>Text provided under a Creative Commons Attribution license, CC-BY. All code is made available under the FSF-approved MIT license.(c) Carlos Alberto Alvarez Henao</td>\n",
    "</table>\n",
    "\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *Pandas*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es un módulo (biblioteca) en *Python* de código abierto (open source) que proporciona estructuras de datos flexibles y permite trabajar con la información de forma eficiente (gran parte de Pandas está implementado usando `C/Cython` para obtener un buen rendimiento).\n",
    "\n",
    "Desde [este enlace](http://pandas.pydata.org \"Pandas\") podrás acceder a la página oficial de Pandas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Antes de *Pandas*, *Python* se utilizó principalmente para la manipulación y preparación de datos. Tenía muy poca contribución al análisis de datos. *Pandas* resolvió este problema. Usando *Pandas*, podemos lograr cinco pasos típicos en el procesamiento y análisis de datos, independientemente del origen de los datos: \n",
    "\n",
    "- cargar, \n",
    "\n",
    "\n",
    "- preparar, \n",
    "\n",
    "\n",
    "- manipular, \n",
    "\n",
    "\n",
    "- modelar, y \n",
    "\n",
    "\n",
    "- analizar."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Volver a la Tabla de Contenido](#TOC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Principales características de *Pandas*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Objeto tipo DataFrame rápido y eficiente con indexación predeterminada y personalizada.\n",
    "\n",
    "- Herramientas para cargar datos en objetos de datos en memoria desde diferentes formatos de archivo.\n",
    "\n",
    "- Alineación de datos y manejo integrado de datos faltantes.\n",
    "\n",
    "- Remodelación y pivoteo de conjuntos de datos.\n",
    "\n",
    "- Etiquetado de corte, indexación y subconjunto de grandes conjuntos de datos.\n",
    "\n",
    "- Las columnas de una estructura de datos se pueden eliminar o insertar.\n",
    "\n",
    "- Agrupamiento por datos para agregación y transformaciones.\n",
    "\n",
    "- Alto rendimiento de fusión y unión de datos.\n",
    "\n",
    "- Funcionalidad de series de tiempo\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Volver a la Tabla de Contenido](#TOC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Configuración de *Pandas*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La distribución estándar del no incluye el módulo de `pandas`. Es necesario realizar el procedimiento de instalacion y difiere del ambiente o el sistema operativo empleados.\n",
    "\n",
    "Si usa el ambiente *[Anaconda](https://anaconda.org/)*, la alternativa más simple es usar el comando:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "pip install pandas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "o empleando *conda*:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "conda install -c anaconda pandas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Volver a la Tabla de Contenido](#TOC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Estructuras de datos en *Pandas*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ofrece varias estructuras de datos que nos resultarán de mucha utilidad y que vamos a ir viendo poco a poco. Todas las posibles estructuras de datos que ofrece a día de hoy son:\n",
    "\n",
    "\n",
    "- **`Series`:** Son arrays unidimensionales con indexación (arrays con índice o etiquetados), similar a los diccionarios. Pueden generarse a partir de diccionarios o de listas.\n",
    " \n",
    " \n",
    "- **`DataFrame`:** Similares a las tablas de bases de datos relacionales como `SQL`.\n",
    " \n",
    " \n",
    "- **`Panel`, `Panel4D` y `PanelND`:** Permiten trabajar con más de dos dimensiones. Dado que es algo complejo y poco utilizado trabajar con arrays de más de dos dimensiones no trataremos los paneles en estos tutoriales de introducción a Pandas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Volver a la Tabla de Contenido](#TOC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dimensionado y Descripción"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La mejor manera para pensar sobre estas estructuras de datos es que la estructura de dato de dimension mayor contiene a la estructura de datos de menor dimensión.\n",
    "\n",
    "`DataFrame` contiene a las `Series`, `Panel` contiene al `DataFrame`\n",
    "\n",
    "\n",
    "| Data Structure | Dimension | Descripción |\n",
    "|----------------|:---------:|-------------|\n",
    "|`Series`          | 1         | Arreglo 1-Dimensional homogéneo de tamaño inmutable |\n",
    "|`DataFrames`      | 2         | Estructura tabular 2-Dimensional, tamaño mutable con columnas heterogéneas|\n",
    "|`Panel`           | 3         | Arreglo general 3-Dimensional, tamaño variable|\n",
    "\n",
    "La construcción y el manejo de dos o más matrices dimensionales es una tarea tediosa, se le impone una carga al usuario para considerar la orientación del conjunto de datos cuando se escriben las funciones. Pero al usar las estructuras de datos de *Pandas*, se reduce el esfuerzo mental del usuario.\n",
    "\n",
    "- Por ejemplo, con datos tabulares (`DataFrame`), es más útil semánticamente pensar en el índice (las filas) y las columnas, en lugar del eje 0 y el eje 1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Volver a la Tabla de Contenido](#TOC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mutabilidad"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las estructuras en *Pandas* son de valor mutable (se pueden cambiar), y excepto las `Series`, todas son de tamaño mutables. Los `DataFrames` son los más usados, los `Panel` no se usan tanto."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Volver a la Tabla de Contenido](#TOC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cargando el módulo *Pandas*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Volver a la Tabla de Contenido](#TOC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `Series`:\n",
    "\n",
    "Las series se definen de la siguiente manera:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "serie = pd.Series(data, index, dtype, copy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "donde: \n",
    "\n",
    "- `data` es el vector de datos \n",
    "\n",
    "\n",
    "- `index` (opcional) es el vector de índices que usará la serie. Si los índices son datos de fechas directamente se creará una instancia de una `TimeSeries` en lugar de una instancia de `Series`. Si se omite, por defecto es: `np.arrange(n)`\n",
    "\n",
    "- `dtype`, tipo de dato. Si se omite, el tipo de dato se infiere.\n",
    "\n",
    "\n",
    "- `copy`, copia datos, por defecto es `False`.\n",
    "\n",
    "\n",
    "Veamos un ejemplo de como crear este tipo de contenedor de datos. Primero vamos a crear una `Series` y `Pandas` nos creará índices automáticamente:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Volver a la Tabla de Contenido](#TOC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creando una `Series` sin datos (vacía, `empty`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "series = pd.Series()\n",
    "print(series)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Volver a la Tabla de Contenido](#TOC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creando una *Serie* con datos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si los datos provienen de un `ndarray`, el índice pasado debe ser de la misma longitud. Si no se pasa ningún índice, el índice predeterminado será `range(n)` donde `n` es la longitud del arreglo, es decir, $[0,1,2, \\ldots rango(len(array))-1]$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = np.array(['a','b','c','d'])\n",
    "s = pd.Series(data)\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Obsérvese que no se pasó ningún índice, por lo que, de forma predeterminada, se asignaron los índices que van de `0` a `len(datos) - 1`, es decir, de `0` a `3`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "indices = ['a','b','c','d']\n",
    "data = [\"Carlos\",\"Alberto\",\"alvarez\",\"henao\"]\n",
    "#indices = [v for v in range(len(data))]\n",
    "\n",
    "s = pd.Series(data,index=indices)\n",
    "\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Aquí pasamos los valores del índice. Ahora podemos ver los valores indexados de forma personalizada en la salida."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Volver a la Tabla de Contenido](#TOC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creando una `Series` desde un diccionario"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = {'a' : 0., 'b' : 1.,'c' : 2.}\n",
    "s = pd.Series(data)\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- La `clave` del diccionario es usada para construir el índice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = {'a' : 0., 'b' : 1., 'c' : 2.}\n",
    "s = pd.Series(data,index=['b','c','d','a'])\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- El orden del índice se conserva y el elemento faltante se llena con `NaN` (*Not a Number*)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Volver a la Tabla de Contenido](#TOC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creando una *Series* desde un escalar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "indices = [v for v in range(10)]\n",
    "data = 0\n",
    "\n",
    "s = pd.Series(data, indices)\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Volver a la Tabla de Contenido](#TOC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accesando a los datos desde la `Series` con la posición"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los datos en una `Series` se pueden acceder de forma similar a un `ndarray`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "data = [v for v in range(12)]\n",
    "indices = ['a','b','e','d','i', 'c', 'l', 'o', 'p', 'ñ', 't', 'u']\n",
    "\n",
    "s = pd.Series(data,indices)\n",
    "print(s['c']) # recupera el primer elemento"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora, recuperemos los tres primeros elementos en la `Series`. Si se inserta `a:` delante, se extraerán todos los elementos de ese índice en adelante. Si se usan dos parámetros (con `:` entre ellos), se extraerán los elementos entre los dos índices (sin incluir el índice de detención)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(s[:'d']) # recupera los tres primeros elementos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recupere los tres últimos elementos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(s[-3:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Volver a la Tabla de Contenido](#TOC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Recuperando los datos usando indexación"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recupere un único elemento usando el valor del índice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(s['a'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recupere múltiples elementos usando una lista de valores de los índices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(s[['a','e','i']])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si una etiqueta no está contenida, se emitirá un mensaje de excepción (error)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(s['f'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  * Vamos a crear una serie con índices generados aleatoriamente (de forma automática)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "# serie con índices automáticos\n",
    "serie = pd.Series(np.random.random(10))\n",
    "print('Serie con índices automáticos'.format())\n",
    "print('{}'.format(serie))\n",
    "print(type(serie))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  * Ahora vamos a crear una serie donde nosotros le vamos a decir los índices que queremos usar (definidos por el usuario)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "serie = pd.Series(np.random.randn(4),\n",
    "                  index = np.random.randn(4))\n",
    "print('Serie con índices definidos')\n",
    "print('{}'.format(serie))\n",
    "print(type(serie))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  * Por último, vamos a crear una serie temporal usando índices que son fechas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# serie(serie temporal) con índices que son fechas\n",
    "n = 60\n",
    "serie = pd.Series(np.random.randn(n),\n",
    "                  index = pd.date_range('2001/01/01', periods = n))\n",
    "print('Serie temporal con índices de fechas')\n",
    "print('{}'.format(serie))\n",
    "print(type(serie))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En los ejemplos anteriores hemos creado las series a partir de un `numpy array` pero las podemos crear a partir de muchas otras cosas: listas, diccionarios, numpy arrays,... Veamos ejemplos:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Serie a partir de una lista..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "serie_lista = pd.Series([i*i for i in range(10)])\n",
    "print('Serie a partir de una lista')\n",
    "print('{}'.format(serie_lista))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Serie a partir de un diccionario..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dicc = {'{}^2 = '.format(i) : i*i for i in range(10)}\n",
    "serie_dicc = pd.Series(dicc)\n",
    "print('Serie a partir de un diccionario ')\n",
    "print('{}'.format(serie_dicc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Serie a partir de valores de otra serie..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "serie_serie = pd.Series(serie_dicc.values)\n",
    "print('Serie a partir de los valores de otra (pandas) serie')\n",
    "print('{}'.format(serie_serie))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Serie a partir de un valor constante..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "serie_cte = pd.Series(\"NaN\", index = np.arange(10))\n",
    "print('Serie a partir de un valor constante')\n",
    "print('{}'.format(serie_cte))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una serie (`Series` o `TimeSeries`) se puede manejar igual que si tuviéramos un `numpy array` de una dimensión o igual que si tuviéramos un diccionario. Vemos ejemplos de esto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "serie = pd.Series(np.random.randn(10),\n",
    "                  index = ['a','b','c','d','e','f','g','h','i','j'])\n",
    "print('Serie que vamos a usar en este ejemplo:')\n",
    "print('{}'.format(serie))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ejemplos de comportamiento como `numpy array`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('serie.max() {}'.format(serie.max()))\n",
    "print('serie.sum() {}'.format(serie.sum()))\n",
    "print('serie.abs()')\n",
    "print('{}'.format(serie.abs()))\n",
    "print('serie[serie > 0]')\n",
    "print('{}'.format(serie[serie > 1]))\n",
    "#...\n",
    "print('\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ejemplos de comportamiento como diccionario"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Se comporta como un diccionario:\")\n",
    "print(\"================================\")\n",
    "print(\"serie['a'] \\n {}\".format(serie['a']))\n",
    "print(\"'a' en la serie \\n {}\".format('a' in serie))\n",
    "print(\"'z' en la serie \\n {}\".format('z' in serie))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las operaciones están 'vectorizadas' y se hacen elemento a elemento con los elementos alineados en función del índice. \n",
    "\n",
    "\n",
    "- Si se hace, por ejemplo, una suma de dos series, si en una de las dos series no existe un elemento, i.e. el índice no existe en la serie, el resultado para ese índice será `NAN`. \n",
    "\n",
    "\n",
    "- En resumen, estamos haciendo una unión de los índices y funciona diferente a los `numpy arrays`. \n",
    "\n",
    "\n",
    "Se puede ver el esquema en el siguiente ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s1 = serie[1:]\n",
    "s2 = serie[:-1]\n",
    "suma = s1 + s2\n",
    "print(' s1 s2 s1 + s2')\n",
    "print('------------------ ------------------ ------------------')\n",
    "for clave in sorted(set(list(s1.keys()) + list(s2.keys()))):\n",
    "    print('{0:1} {1:20} + {0:1} {2:20} = {0:1} {3:20}'.format(clave,\n",
    "                                                          s1.get(clave),\n",
    "                                                          s2.get(clave),\n",
    "                                                          suma.get(clave)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En la anterior línea de código se usa el método `get` para no obtener un `KeyError`, como sí obtendría si se usa, p.e., `s1['a']`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Volver a la Tabla de Contenido](#TOC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `DataFrame`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un `DataFrame` es una estructura 2-Dimensional, es decir, los datos se alinean en forma tabular por filas y columnas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Volver a la Tabla de Contenido](#TOC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Características del`DataFrame`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Las columnas pueden ser de diferente tipo.\n",
    "\n",
    "- Tamaño cambiable.\n",
    "\n",
    "- Ejes etiquetados (filas y columnas).\n",
    "\n",
    "- Se pueden desarrollar operaciones aritméticas en filas y columnas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Volver a la Tabla de Contenido](#TOC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `pandas.DataFrame`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "una estructura de `DataFrame` puede crearse usando el siguiente constructor:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "pandas.DataFrame(data, index, columns, dtype, copy) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los parámetros de este constructor son los siguientes:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **`data`:** Pueden ser de diferentes formas como `ndarray`, `Series`, `map`, `lists`, `dict`, constantes o también otro `DataFrame`.\n",
    "\n",
    "- **`index`:** para las etiquetas de fila, el índice que se utilizará para la trama resultante es dado de forma opcional por defecto por `np.arange(n)`, si no se especifica ningún índice.\n",
    "\n",
    "- **`columns`:** para las etiquetas de columnas, la sintaxis por defecto es `np.arange(n)`. Esto es así si no se especifíca ningún índice.\n",
    "\n",
    "- **`dtype`:** tipo de dato para cada columna\n",
    "\n",
    "- **`copy`:*** Es usado para copiar los datos. Por defecto es `False`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Volver a la Tabla de Contenido](#TOC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creando un `DataFrame`..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un `DataFrame` en Pandas se puede crear usando diferentes entradas, como: `listas`, `diccionarios`, `Series`, `ndarrays`, otros `DataFrame`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***vacío...***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame()\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = pd.Series()\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***desde listas...***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = [[1,2, 3],[4, 5, 6],[7,8,9]]\n",
    "df = pd.DataFrame(data)\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = [['Alex',10],['Bob',12],['Clarke',13]]\n",
    "columnas=['Name','Age']\n",
    "df = pd.DataFrame(data,columns = columnas)\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame(data,columns=['Name','Age'],dtype=float)\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***desde diccionarios de `ndarrays`/`lists`...***\n",
    "\n",
    "Todos los `ndarrays` deben ser de la misma longitud. Si se pasa el índice, entonces la longitud del índice debe ser igual a la longitud de las matrices.\n",
    "\n",
    "Si no se pasa ningún índice, de manera predeterminada, el índice será `range(n)`, donde `n` es la longitud del arreglo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = {'Name':['Tom', 'Jack', 'Steve', 'Ricky'],'Age':[28,34,29,42]}\n",
    "df = pd.DataFrame(data)\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Observe los valores $0,1,2,3$. Son el índice predeterminado asignado a cada uno usando la función `range(n)`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***indexado usando `arrays`...***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "indice = [i for i in range(4)]\n",
    "df = pd.DataFrame(data,indice)\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***desde listas de diccionarios...***\n",
    "\n",
    "Se puede pasar una lista de diccionarios como datos de entrada para crear un `DataFrame`. Las `claves` serán usadas por defecto como los nombres de las columnas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]\n",
    "df = pd.DataFrame(data)\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- un `NaN` aparece en donde no hay datos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El siguiente ejemplo muestra como se crea un `DataFrame` pasando una lista de diccionarios y los índices de las filas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame(data, index=['first', 'second'])\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El siguiente ejemplo muestra como se crea un `DataFrame` pasando una lista de diccionarios, y los índices de las filas y columnas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Con dos índices de columnas, los valores son iguales que las claves del diccionario\n",
    "df1 = pd.DataFrame(data, index=['first', 'second'], columns=['a', 'b'])\n",
    "\n",
    "# Con dos índices de columna y con un índice con otro nombre\n",
    "df2 = pd.DataFrame(data, index=['first', 'second'], columns=['a', 'b1', 'c1'])\n",
    "print(df1)\n",
    "print(df2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Observe que el `DataFrame` `df2`  se crea con un índice de columna que no es la clave del diccionario; por lo tanto, se generan los `NaN` en su lugar. Mientras que, `df1` se crea con índices de columnas iguales a las claves del diccionario, por lo que no se agrega `NaN`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***desde un diccionario de `Series`...***\n",
    "\n",
    "Se puede pasar una Serie de diccionarios para formar un `DataFrame`. El índice resultante es la unión de todos los índices de serie pasados."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),\n",
    "      'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}\n",
    "\n",
    "df = pd.DataFrame(d)\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- para la serie `one`, no hay una etiqueta `'d'` pasada, pero en el resultado, para la etiqueta `d`, se agrega `NaN`.\n",
    "\n",
    "Ahora vamos a entender la selección, adición y eliminación de columnas a través de ejemplos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Volver a la Tabla de Contenido](#TOC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Selección de columna"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame(d)\n",
    "print(df['one'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Volver a la Tabla de Contenido](#TOC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adición de columna"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame(d)\n",
    "\n",
    "# Adding a new column to an existing DataFrame object with column label by passing new series\n",
    "\n",
    "print (\"Adicionando una nueva columna pasando como Serie:, \\n\")\n",
    "df['three']=pd.Series([10,20,30],index=['a','b','c'])\n",
    "print(df,'\\n')\n",
    "\n",
    "print (\"Adicionando una nueva columna usando las columnas existentes en el DataFrame:\\n\")\n",
    "df['four']=df['one']+df['three']\n",
    "\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista = [1,2,3]\n",
    "lista.append(4)\n",
    "lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Volver a la Tabla de Contenido](#TOC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Borrado de columna"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']), \n",
    "     'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd']), \n",
    "     'three' : pd.Series([10,20,30], index=['a','b','c'])}\n",
    "\n",
    "df = pd.DataFrame(d)\n",
    "print (\"Our dataframe is:\\n\")\n",
    "print(df, '\\n')\n",
    "\n",
    "# using del function\n",
    "print (\"Deleting the first column using DEL function:\\n\")\n",
    "del df['one']\n",
    "print(df,'\\n')\n",
    "\n",
    "# using pop function\n",
    "print (\"Deleting another column using POP function:\\n\")\n",
    "df.pop('two')\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Volver a la Tabla de Contenido](#TOC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Selección, Adición y Borrado de fila"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Selección por etiqueta\n",
    "\n",
    "Las filas se pueden seleccionar pasando la etiqueta de fila por la función `loc`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']), \n",
    "     'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}\n",
    "\n",
    "df = pd.DataFrame(d)\n",
    "print(df)\n",
    "print(df.loc['b'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- El resultado es una serie con etiquetas como nombres de columna del `DataFrame`. Y, el Nombre de la serie es la etiqueta con la que se recupera."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Volver a la Tabla de Contenido](#TOC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Selección por ubicación entera\n",
    "\n",
    "Las filas se pueden seleccionar pasando la ubicación entera a una función `iloc`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame(d)\n",
    "print(df.iloc[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Volver a la Tabla de Contenido](#TOC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Porcion de fila\n",
    "\n",
    "Múltiples filas se pueden seleccionar usando el operador `:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame(d)\n",
    "print(df[2:4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Volver a la Tabla de Contenido](#TOC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Adición de filas\n",
    "\n",
    "Adicionar nuevas filas al `DataFrame` usando la función `append`. Esta función adiciona las filas al final."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame([[1, 2], [3, 4]])\n",
    "df2 = pd.DataFrame([[5, 6], [7, 8]])\n",
    "\n",
    "print(df)\n",
    "\n",
    "df = df.append(df2)\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Volver a la Tabla de Contenido](#TOC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Borrado de filas\n",
    "\n",
    "Use la etiqueta de índice para eliminar o cortar filas de un `DataFrame`. Si la etiqueta está duplicada, se eliminarán varias filas.\n",
    "\n",
    "Si observa, en el ejemplo anterior, las etiquetas están duplicadas. Cortemos una etiqueta y veamos cuántas filas se descartarán."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame([[1, 2], [3, 4]], columns = ['a','b'])\n",
    "df2 = pd.DataFrame([[5, 6], [7, 8]], columns = ['a','b'])\n",
    "\n",
    "df = df.append(df2)\n",
    "print(df)\n",
    "# Drop rows with label 0\n",
    "df = df.drop(1)\n",
    "\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- En el ejemplo anterior se quitaron dos filas porque éstas dos contenían la misma etiqueta `0`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Volver a la Tabla de Contenido](#TOC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lectura / Escritura en Pandas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una de las grandes capacidades de *`Pandas`* es la potencia que aporta a lo hora de leer y/o escribir archivos de datos.\n",
    "\n",
    "- Pandas es capaz de leer datos de archivos `csv`, `excel`, `HDF5`, `sql`, `json`, `html`,...\n",
    "\n",
    "Si se emplean datos de terceros, que pueden provenir de muy diversas fuentes, una de las partes más tediosas del trabajo será tener los datos listos para empezar a trabajar: Limpiar huecos, poner fechas en formato usable, saltarse cabeceros,...\n",
    "\n",
    "Sin duda, una de las funciones que más se usarán será `read_csv()` que permite una gran flexibilidad a la hora de leer un archivo de texto plano."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(pd.to_csv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En [este enlace](https://pandas.pydata.org/pandas-docs/stable/user_guide/io.html \"pandas docs\") se pueden encontrar todos los posibles formatos con los que Pandas trabaja:\n",
    "\n",
    "Cada uno de estos métodos de lectura de determinados formatos (`read_NombreFormato`) tiene infinidad de parámetros que se pueden ver en la documentación y que no vamos a explicar por lo extensísima que seria esta explicación. \n",
    "\n",
    "Para la mayoría de los casos que nos vamos a encontrar los parámetros serían los siguientes:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "pd.read_table(dir_archivo, engine='python', sep=':', header=True|False, names=[lista con nombre columnas])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Básicamente hay que pasarle el archivo a leer, cual es su separador, si la primera linea del archivo contiene el nombre de las columnas y en el caso de que no las tenga pasarle en `names` el nombre de las columnas. \n",
    "\n",
    "\n",
    "Veamos un ejemplo de un dataset del  cómo leeriamos el archivo con los datos de los usuarios, siendo el contenido de las 10 primeras lineas el siguiente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load users info\n",
    "userHeader = ['ID', 'Sexo', 'Edad', 'Ocupacion', 'PBOX']\n",
    "\n",
    "users = pd.read_csv('Data/users.txt', engine='python', sep='::', header=None, names=userHeader)\n",
    "\n",
    "# print 5 first users\n",
    "print ('# 10 primeros usuarios: \\n%s' % users[:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(users)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para escribir un `DataFrame` en un archivo de texto se pueden utilizar los [método de escritura](http://pandas.pydata.org/pandas-docs/stable/io.html) para escribirlos en el formato que se quiera. \n",
    "\n",
    "\n",
    "- Por ejemplo si utilizamos el método `to_csv()` nos escribirá el `DataFrame` en este formato estandar que separa los campos por comas; pero por ejemplo, podemos decirle al método que en vez de que utilice como separador una coma, que utilice por ejemplo un guión. \n",
    "\n",
    "\n",
    "Si queremos escribir en un archivo el `DataFrame` `users` con estas características lo podemos hacer de la siguiente manera:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "users.to_csv('Datasets/MyUsers9999.txt', sep='&')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Volver a la Tabla de Contenido](#TOC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Merge"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una funcionalidad muy potente que ofrece Pandas es la de poder juntar, `merge` (en bases de datos sería hacer un `JOIN`) datos siempre y cuando este sea posible. \n",
    "\n",
    "\n",
    "En el ejemplo que estamos haciendo con el dataset podemos ver esta funcionalidad de forma muy intuitiva, ya que los datos de este data set se han obtenido a partir de una bases de datos relacional. \n",
    "\n",
    "\n",
    "Veamos a continuación como hacer un `JOIN` o un `merge` de los archivos `users.txt` y `ratings.txt` a partir del `user_id`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load users info\n",
    "userHeader = ['user_id', 'gender', 'age', 'ocupation', 'zip']\n",
    "users = pd.read_csv('Datasets/users.txt', engine='python', sep='::', header=None, names=userHeader)\n",
    "# Load ratings\n",
    "ratingHeader = ['user_id', 'movie_id', 'rating', 'timestamp']\n",
    "ratings = pd.read_csv('Datasets/ratings.txt', engine='python', sep='::', header=None, names=ratingHeader)\n",
    "\n",
    "# Merge tables users + ratings by user_id field\n",
    "merger_ratings_users = pd.merge(users, ratings)\n",
    "print('%s' % merger_ratings_users[:10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De la misma forma que hemos hecho el `JOIN` de los usuarios y los votos, podemos hacer lo mismo añadiendo también los datos relativos a las películas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "userHeader = ['user_id', 'gender', 'age', 'ocupation', 'zip']\n",
    "users = pd.read_csv('Datasets/users.txt', engine='python', sep='::', header=None, names=userHeader)\n",
    "\n",
    "movieHeader = ['movie_id', 'title', 'genders']\n",
    "movies = pd.read_csv('Datasets/movies.txt', engine='python', sep='::', header=None, names=movieHeader)\n",
    "\n",
    "ratingHeader = ['user_id', 'movie_id', 'rating', 'timestamp']\n",
    "ratings = pd.read_csv('Datasets/ratings.txt', engine='python', sep='::', header=None, names=ratingHeader)\n",
    "\n",
    "# Merge data\n",
    "#mergeRatings = pd.merge(pd.merge(users, ratings), movies)\n",
    "mergeRatings = pd.merge(merger_ratings_users, movies)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si quisiésemos ver por ejemplo un elemento de este nuevo `JOIN` creado (por ejemplo la posición 1000), lo podríamos hacer de la siguiente forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "info1000 = mergeRatings.loc[10]\n",
    "print('Info of 1000 position of the table: \\n%s' % info1000[:1000])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Volver a la Tabla de Contenido](#TOC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Trabajando con Datos, Indexación, Selección"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Cómo podemos seleccionar, añadir, eliminar, mover,..., columnas, filas,...?\n",
    "\n",
    "\n",
    "- Para seleccionar una columna solo hay que usar el nombre de la columna y pasarlo como si fuera un diccionario (o un atributo).\n",
    "\n",
    "\n",
    "- Para añadir una columna simplemente hay que usar un nombre de columna no existente y pasarle los valores para esa columna.\n",
    "\n",
    "\n",
    "- Para eliminar una columna podemos usar `del` o el método `pop` del `DataFrame`.\n",
    "\n",
    "\n",
    "- Para mover una columna podemos usar una combinación de las metodologías anteriores.\n",
    "\n",
    "\n",
    "Como ejemplo, vamos crear un `DataFrame`con datos aleatorios y a seleccionar los valores de una columna:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame(np.random.randn(5,3),\n",
    "                  index = ['primero','segundo','tercero','cuarto','quinto'],\n",
    "                  columns = ['velocidad', 'temperatura','presion'])\n",
    "print(df)\n",
    "print(df['velocidad'])\n",
    "print(df.velocidad)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para acceder a la columna `velocidad` lo podemos hacer de dos formas. \n",
    "\n",
    "\n",
    "- O bien usando el nombre de la columna como si fuera una clave de un diccionario \n",
    "\n",
    "\n",
    "- O bien usando el nombre de la columna como si fuera un atributo. \n",
    "\n",
    "\n",
    "En el caso de que los nombres de las columnas sean números, la segunda opción no podríais usarla...\n",
    "\n",
    "\n",
    "Vamos a añadir una columna nueva al `DataFrame`. Es algo tan sencillo como usar un nombre de columna no existente y pasarle los datos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['velocidad_maxima'] = np.random.randn(df.shape[0])\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pero qué pasa si quiero añadir la columna en un lugar específico. Para ello podemos usar el método `insert` (y de paso vemos como podemos borrar una columna):\n",
    "\n",
    "**Forma 1:**\n",
    "\n",
    "- Borramos la columna 'velocidad_maxima' que está al final del df usando `del`\n",
    "\n",
    "\n",
    "- Colocamos la columna eliminada en la posición que especifiquemos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(df)\n",
    "columna = df['velocidad_maxima']\n",
    "del df['velocidad_maxima']\n",
    "df.insert(1, 'velocidad_maxima', columna)\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Forma 2:** Usando el método `pop`: borramos usando el método `pop` y añadimos la columna borrada en la última posición de nuevo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(df)\n",
    "columna = df.pop('velocidad_maxima')\n",
    "print(df)\n",
    "#print(columna)\n",
    "df.insert(3, 'velocidad_maxima', columna)\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para seleccionar datos concretos de un `DataFrame` podemos usar el índice, una rebanada (*slicing*), valores booleanos, la columna,...\n",
    "\n",
    "\n",
    "- Seleccionamos la columna de velocidades:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(df.velocidad)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Seleccionamos todas las columnas cuyo índice es igual a tercero:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(df.xs('tercero'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Seleccionamos todas las columnas cuyo índice está entre tercero y quinto (en este caso los índices son inclusivos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(df.loc['tercero':'quinto'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Seleccionamos todos los valores de velocidad donde la temperatura > 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(df['velocidad'][df['temperatura']>0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Seleccionamos todos los valores de una columna por índice usando una rebanada (`slice`) de enteros.\n",
    "\n",
    "\n",
    "- En este caso el límite superior de la rebanada no se incluye (Python tradicional)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(df.iloc[1:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Seleccionamos filas y columnas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(df.iloc[1:3, ['velocidad', 'presion']])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(df.ix)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Volver a la Tabla de Contenido](#TOC)"
   ]
  }
 ],
 "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.11.3"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": true,
   "user_envs_cfg": true
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Tabla de Contenidos",
   "title_sidebar": "Contenidos",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "165px"
   },
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}