Pandas I.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <img src=\"uni-logo.png\" alt=\"Logo UNI\" width=100 hight=200 align=\"right\">\n",
    "\n",
    "\n",
    "<br><br><br>\n",
    "<h1><font color=\"#1D65DD\" size=5>Python desde cero</font></h1>\n",
    "\n",
    "\n",
    "\n",
    "<h1><font color=\"#1D65DD\" size=6>Pandas I</font></h1>\n",
    "\n",
    "<br>\n",
    "<div style=\"text-align: right\">\n",
    "<font color=\"#1D65DD\" size=3>Yuri Coicca, M.Sc.</font><br>\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"indice\"></a>\n",
    "<h2><font color=\"#7F000E\" size=5>Índice</font></h2>\n",
    "\n",
    "\n",
    "* [1. Introducción](#section1)\n",
    "* [2. Series](#section2)\n",
    "   * [Creación de series](#section21)\n",
    "   * [Acceso a los elementos de una serie](#section22)\n",
    "* [3. Operaciones y funciones sobre series](#section3)\n",
    "   * [Operadores binarios](#section31)\n",
    "   * [<font face=\"monospace\">apply() y map()</font>](#section32)\n",
    "   * [Operaciones sobre Strings](#section33)   \n",
    "   * [Descripción y resumen](#section34)\n",
    "   * [Manipulación de series](#section35)   \n",
    "   * [Consulta y selección](#section36)\n",
    "   * [Vectorización](#section37)   \n",
    "* [4. DataFrames](#section4)\n",
    "    * [Estructura](#section41)\n",
    "    * [Lectura / escritura de DataFrames](#section42)\n",
    "    * [Construcción de DataFrames](#section43)\n",
    "    * [Acceso a elementos](#section44)\n",
    "    * [Manipulación de la estructura](#section45)  \n",
    "    * [Descripción de los datos](#section46)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Permite ajustar la anchura de la parte útil de la libreta (reduce los márgenes)\n",
    "from IPython.core.display import display, HTML\n",
    "display(HTML(\"<style>.container{ width:98% }</style>\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "\n",
    "\n",
    "<a id=\"section1\"></a>\n",
    "# <font color=\"#7F000E\" size=5> 1. Introducción</font>\n",
    "<br>\n",
    "\n",
    "En estos cuadernos se proporciona una descripción de Pandas, y se presentarán, mediante ejemplos, las funcionalidades de uso más común. Esta introducción será extendida en el _siguiente módulo si continuamos con el siguiente curso_ en el que, además, se dará una visión formal de los conjuntos de los datos y su tratamiento. No obstante, Pandas es una librería _completa y compleja_, por lo que a lo largo del curso será indispensable recurrir a la abundante información existente en la red, a foros como [Stack Overflow](https://stackoverflow.com/questions/tagged/pandas), y a la [documentación oficial](http://pandas.pydata.org/pandas-docs/stable/). \n",
    "<br> \n",
    "\n",
    "\n",
    "[**Pandas**](http://pandas.pydata.org) es una librería de _Python_ que proporciona estructuras y herramientas para la manipulación,  preprocesamiento y análisis exploratorio de conjuntos de datos. Trabaja con objetos denominados **`DataFrame`**, que representan tablas indexadas de datos, e implementa funciones avanzadas y eficientes para acceso, selección, consultas, agrupamiento, procesamiento, etc.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El siguiente código lee un archivo de datos, lo almacena en un `DataFrame`, y lo muestra. Después accede a (y selecciona) los 100 primeros elementos y varias columnas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Cargando el paquete Pandas\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creando un dataFrame a partir de un Diccionario\n",
    "dt = {'ID': [11, 12, 13, 14, 15],\n",
    "            'first_name': ['David', 'Jamie', 'Steve', 'Stevart', 'John'],\n",
    "            'company': ['Aon', 'TCS', 'Google', 'RBS', '.'],\n",
    "            'salary': [74, 76, 96, 71, 78]}\n",
    "mydata01 = pd.DataFrame(dt, columns = ['ID', 'first_name', 'company', 'salary'])\n",
    "display(mydata01.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Leyendo un arhivo CSV desde un URL\n",
    "mydata02  = pd.read_csv(\"http://winterolympicsmedals.com/medals.csv\")\n",
    "display(mydata02.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Obteniendo el directorio actual de trabajo** \n",
    "\n",
    "* `os.getcwd()` devuelve la ruta absoluta del directorio de trabajo donde Python se está ejecutando actualmente como una cadena str.\n",
    "\n",
    "* `getcwd` significa **obtener directorio de trabajo actual**, y el comando de Unix pwd significa \"imprimir directorio de trabajo\". Por supuesto, puede imprimir el directorio de trabajo con `print()`.\n",
    "\n",
    "**Cambiando el directorio actual de trabajo** \n",
    "\n",
    "* Puede cambiar el directorio de trabajo actual con `os.chdir()`. Especifique la ruta de destino en el argumento.\n",
    "\n",
    "* Puede ser absoluto o relativo. Utilice **'../'** para subir. Puede cambiar el directorio actual como el comando de Unix **cd**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.getcwd()\n",
    "# listando archivos \n",
    "print(os.listdir(os.getcwd()))\n",
    "# leyendo archivo CSV del disco de la PC\n",
    "income = pd.read_csv('C:\\\\Users\\\\YURI\\\\POO con Python\\\\modulo II\\\\data\\\\madrid_2017.csv')\n",
    "display(income.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# \n",
    "import os\n",
    "print('getcwd:      ', os.getcwd())\n",
    "print('__file__:    ', __file__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tenga en cuenta que `__file__` no se puede utilizar en Jupyter Notebook (.ipynb). Independientemente del directorio donde se inicie Jupyter Notebook, el directorio actual es el directorio donde se encuentra .ipynb.\n",
    "\n",
    "Mas detalles en: https://note.nkmk.me/en/python-script-file-path/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lee un archivo .csv y utiliza el campo ID como índice.\n",
    "df_fifa = pd.read_csv('./data/fifa19.csv', index_col=0).set_index('ID')\n",
    "# Muestra la cabecera (5 primeras filas)\n",
    "display(df_fifa.head())\n",
    "print(\"Dimensiones del dataframe:\",df_fifa.shape)\n",
    "print(\"Número de filas (registros):\",df_fifa.shape[0])\n",
    "print(\"Número de columnas:\",df_fifa.shape[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lista con los nombres de las columnas de interés\n",
    "sel_columns = ['Name', 'Age', 'Nationality', 'Overall', 'Club', 'Value', 'Wage', 'Position', 'Joined', 'Height', 'Weight', 'Release Clause']\n",
    "\n",
    "# Selecciona filas y columnas\n",
    "df_fifa = df_fifa[:100][sel_columns] \n",
    "# Muestra los tipos de datos de las columnas\n",
    "print(df_fifa.dtypes)\n",
    "# Muestra la cabecera\n",
    "df_fifa.head(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=\"#7F000E\"> Ejemplo de uso</font>\n",
    "\n",
    "A continuación se ilustra, mediante un breve ejemplo, el tipo de procesamiento que se puede hacer con Pandas. El `DataFrame` contiene datos sobre jugadores de fútbol. La altura se expresa mediante el sistema imperial (británico), y está representada con un `String`.  En esta celda, se convierten las unidades de la columna `Height` al sistema métrico decimal (metros), y se representan mediante un valor numérico."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "feet_to_cm = 30.48\n",
    "inch_to_cm = 2.54\n",
    "\n",
    "# Toma un String con formato pies'pulgadas como entrada\n",
    "def imp_to_metric(imp_height):\n",
    "    feet, inch = imp_height.split(\"'\")                             # Separa pies y pulgadas \n",
    "    return (float(feet)*feet_to_cm + float(inch)*inch_to_cm)/100   # Convierte a float y calcula los metros\n",
    "\n",
    "# Convierte toda la columna\n",
    "df_fifa['Height'] = df_fifa['Height'].map(imp_to_metric)    \n",
    "\n",
    "# Lo muestra\n",
    "df_fifa.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En esta celda se transforman también peso, salario y valor, de manera más compacta, mediante funciones _lambda_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_fifa['Weight'] = df_fifa['Weight'].map(lambda w: float(w[:-3])*0.453592)\n",
    "df_fifa['Value'] = df_fifa['Value'].map(lambda v: float(v[1:-1]))\n",
    "df_fifa['Wage'] = df_fifa['Wage'].map(lambda w: int(w[1:-1])*1000)\n",
    "\n",
    "df_fifa.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Al igual que en las bases de datos relacionales, se pueden hacer accesos condicionales. Por ejemplo, se pueden mostrar los jugadores cuyo valor está por encima de 100 millones de euros."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_fifa[df_fifa['Value']>100]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pandas permite obtener estadísticos descriptivos simples. En la siguiente columna, se describe la información que contienen las columnas numéricas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_fifa.describe(include=\"number\", percentiles=[0.25, 0.5, 0.75])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por ejemplo, también pueden obtener el número de clubes distintos y las veces que aparecen, usando la funcion **values_counts()**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_fifa['Club'].value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora, para concluir esta sección veamos el uso de las capacidades de **groupby** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creando el dataframe agrupado\n",
    "agrupado=df_fifa.groupby('Club')\n",
    "display(agrupado.size())\n",
    "agrupado.get_group('FC Barcelona').head(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agrupado por multiples columnas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_fifa.groupby(['Club','Value']).size()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Obteniendo los valores **mean** (medio), **min** (mínimo), y **max** (máximo) de la edad de los jugadores por Club."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "agrupa_edad = display(df_fifa.groupby('Club').agg({'Age': ['mean', 'min', 'max']}).head(10))\n",
    "display(agrupa_edad)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función **unique ()** muestra los niveles o categorías únicos en el conjunto de datos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_fifa.index.nunique()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: right\">\n",
    "<a href=\"#indice\"><font size=5><i class=\"fa fa-arrow-circle-up\" aria-hidden=\"true\" style=\"color:#7F000E\"></i></font></a>\n",
    "</div>\n",
    "\n",
    "\n",
    "---\n",
    "\n",
    "<a id=\"section2\"></a>\n",
    "# <font color=\"#7F000E\" size=5> 2. Series </font>\n",
    "<br>\n",
    "\n",
    "Los objetos de tipo `Series` almacenan una colección de valores _indexada_. Esta clase implementa multitud de operaciones, y ___es la forma en que se accede a columnas o filas__ individuales en objetos de tipo `DataFrame`.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "serie_name = df_fifa['Name']    # Accede a la columna 'Name' y la almacena en una serie\n",
    "\n",
    "display(serie_name.head(5))\n",
    "print(\"Tipo:\", type(serie_name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    \n",
    "<i class=\"fa fa-info-circle\" aria-hidden=\"true\"></i>\n",
    "El índice del objeto `Series` es el correspondiente en el `DataFrame`. El nombre, es el nombre de la columna.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: right\">\n",
    "<a href=\"#indice\"><font size=5><i class=\"fa fa-arrow-circle-up\" aria-hidden=\"true\" style=\"color:#7F000E\"></i></font></a>\n",
    "</div>\n",
    "\n",
    "\n",
    "---\n",
    "\n",
    "<a id=\"section21\"></a> \n",
    "## <font color=\"#7F000E\">Creación de series </font>\n",
    "<br>\n",
    "\n",
    "En inmensa mayoría de las ocasiones, los objetivos de tipo `Series` se crean a partir del acceso a filas o columnas. No obstante, también es posible crear objetos de tipo `Series` directamente, y de distintos modos, a partir de estructuras estándar de _Python_ y _Numpy_.\n",
    "\n",
    "### <font color=\"#7F000E\"> Creación a partir de una colección de elementos</font>\n",
    "\n",
    "Se puede construir una serie a partir de una colección de datos. En caso de no especificar un índice, la serie se indexa internamente con enteros."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "equipos = ['Real Madrid', 'Manchester United', 'Milán']\n",
    "serie_equipos = pd.Series(equipos)         # Construye una serie a partir de una lista\n",
    "print(serie_equipos)                       # Por defecto, se indexa con enteros"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=\"#7F000E\"> Creación a partir de una colección y un índice </font>\n",
    "\n",
    "Es posible especificar la secuencia que contiene el índice. Éste, que por defecto es un entero, puede estar formado por datos de cualquier tipo al que se pueda aplicar una función _hash_ (función _hashable_)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "serie_equipos = pd.Series(['Real Madrid', 'Manchester United', 'Milán'],  # Datos\n",
    "                          index=['España', 'Inglaterra', 'Italia'])       # Índice\n",
    "print(serie_equipos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=\"#7F000E\"> Creación a partir de un diccionario </font>\n",
    "\n",
    "También se puede construir la serie a partir de un diccionario. En ese caso, las claves corresponden a los índices, y los valores a los elementos de la serie. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "equipos = {'España': 'Real Madrid',\n",
    "           'Inglaterra': 'Manchester United',\n",
    "           'Italia': 'Milán',\n",
    "           'Francia': 'PSG',\n",
    "           'Alemania': 'Bayern Munich' }          # Diccionario\n",
    "\n",
    "serie_equipos = pd.Series(equipos)                # Crea la serie a partir del diccionario\n",
    "print(serie_equipos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si además del diccionario se pasa una lista de índices, ésta se usa para determinar qué valores del diccionario se incluyen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "serie_equipos = pd.Series(equipos, index=['España', 'Inglaterra', 'Italia'])\n",
    "print(serie_equipos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible dar un nombre a la serie, y también es posible darselo al índice. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "serie_equipos.name='Equipo'\n",
    "serie_equipos.index.name = 'País'\n",
    "serie_equipos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: right\">\n",
    "<a href=\"#indice\"><font size=5><i class=\"fa fa-arrow-circle-up\" aria-hidden=\"true\" style=\"color:#004D7F\"></i></font></a>\n",
    "</div>\n",
    "\n",
    "\n",
    "---\n",
    "\n",
    "<a id=\"section22\"></a> \n",
    "## <font color=\"#7F000E\">Acceso a los elementos de una serie </font>\n",
    "<br>\n",
    "\n",
    "El acceso natural a los elementos de una serie se hace mediante su índice, con `loc[índice]`. También se puede acceder acceder a los elementos mediante la posición, como en el resto de colecciones, a través de `iloc[posición]`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(serie_equipos, '\\n')\n",
    "\n",
    "print(\"Acceso mediante loc:\")\n",
    "print(serie_equipos.loc['España'])\n",
    "\n",
    "print(\"\\nAcceso mediante iloc:\")\n",
    "print(serie_equipos.iloc[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También es posible acceder a los elementos mediante el operador `[]`, que llama internamente al método correspondiente (`loc` o `iloc`) en función del argumento. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"\\nAcceso mediante []:\")\n",
    "print(serie_equipos['España'])            # Llama a loc\n",
    "print(serie_equipos[1])                   # Llama a iloc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-danger\">\n",
    "    \n",
    "<i class=\"fa fa-exclamation-triangle\" aria-hidden=\"true\"></i> __Importante__: Cuando el índice de la serie es un entero, el operador `[]` llama a `loc[]`, es decir, usa el entero como como índice, y no como posición. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Este ejemplo muestra la situación que se da cuando el índice es un entero: \\n\")\n",
    "\n",
    "equipos = {13: 'Real Madrid',\n",
    "           3: 'Manchester United',\n",
    "           7: 'Milán',\n",
    "           0: 'PSG',\n",
    "           5: 'Bayern Munich'}\n",
    "\n",
    "s = pd.Series(equipos)\n",
    "print(s)\n",
    "\n",
    "print(\"\\nAcceso mediante loc:\")\n",
    "print(s.loc[3])            # Imprime el elemento de índice 3.\n",
    "\n",
    "print(\"\\nAcceso mediante iloc:\")\n",
    "print(s.iloc[3])           # Imprime el elemento en la posición 3.\n",
    "\n",
    "print(\"\\nAcceso mediante []:\")\n",
    "print(s[3])                # En este caso, llama a loc[]\n",
    "#print(s[1])               # Esta sentencia daría error, porque no hay ningún elemento con índice 1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tanto la función `loc` como `iloc` admiten el uso de __colecciones__ como argumentos. Es decir, permiten acceder a varios elementos de la serie a la vez."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "equipos = {'España': 'Real Madrid',\n",
    "           'Inglaterra': 'Manchester United',\n",
    "           'Italia': 'Milán',\n",
    "           'Francia': 'PSG',\n",
    "           'Alemania': 'Bayern Munich'}\n",
    "serie_equipos = pd.Series(equipos)\n",
    "print(serie_equipos, '\\n')\n",
    "\n",
    "print(serie_equipos.loc[['España', 'Italia', 'Francia']],'\\n')\n",
    "print(serie_equipos.iloc[[0,1,2]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "\n",
    "<i class=\"fa fa-exclamation-circle\" aria-hidden=\"true\"></i>\n",
    "__Importante__: Tanto `loc` como `iloc` toman ___un solo argumento___, que _ha de ser una colección_ (no varios datos).\n",
    "</div>\n",
    "\n",
    "Las funciones `at` e `iat` permiten acceder a elementos a través del índice o posición, respectivamente. A diferencia de `loc` e `iloc`,  no admiten colecciones como argumentos. Sin embargo, son más eficientes. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(serie_equipos.at['España'])\n",
    "print(serie_equipos.iat[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=\"#7F000E\"> _Slicing_ </font>\n",
    "\n",
    "El acceso a los elementos de una serie también se puede hacer mediante _slicing_, tanto en el índice como en las posiciones.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "equipos = {'España': 'Real Madrid',\n",
    "           'Inglaterra': 'Manchester United',\n",
    "           'Italia': 'Milán',\n",
    "           'Francia': 'PSG',\n",
    "           'Alemania': 'Bayern Munich'}\n",
    "serie_equipos = pd.Series(equipos)\n",
    "print(serie_equipos,'\\n')\n",
    "\n",
    "print(serie_equipos.iloc[0:3],'\\n')\n",
    "print(serie_equipos.loc['España':'Francia'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=\"#7F000E\"> Indexación mediante valores booleanos </font>\n",
    "\n",
    "Por último, es posible acceder a las series mediante una colección de datos de tipo booleano."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "equipos = {'España': 'Real Madrid',\n",
    "           'Inglaterra': 'Manchester United',\n",
    "           'Italia': 'Milán',\n",
    "           'Francia': 'PSG',\n",
    "           'Alemania': 'Bayern Munich'}\n",
    "\n",
    "serie_equipos = pd.Series(equipos)\n",
    "print(serie_equipos,'\\n')\n",
    "\n",
    "serie_equipos[[True,False,False,True,True]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El uso más común de esta funcionalidad es el filtrado de elementos según una condición. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "mundiales = {'España': 1 ,\n",
    "             'Inglaterra': 1,\n",
    "             'Italia': 4,\n",
    "             'Francia': 1,\n",
    "             'Alemania': 4}\n",
    "serie_mundiales = pd.Series(mundiales)\n",
    "print(serie_mundiales,'\\n')\n",
    "\n",
    "print(serie_mundiales[serie_mundiales>1])         # Accede a los elementos con ese índice de valores booleanos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En realidad, la condición genera otra serie, que es utilizada para el acceso."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(serie_mundiales>1,'\\n')                     # Genera una serie de valores booleanos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se puede hacer un acceso con condiciones más complejas, siempre y cuando éstas den lugar a un conjunto de valores booleanos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "champions = {'Real Madrid':13, 'Manchester':3, 'Milán':7, 'Bayern Munich':5, 'PSG': 0}\n",
    "\n",
    "equipos = {'España': 'Real Madrid',\n",
    "           'Inglaterra': 'Manchester',\n",
    "           'Italia': 'Milán',\n",
    "           'Francia': 'PSG',\n",
    "           'Alemania': 'Bayern Munich'}\n",
    "\n",
    "serie_equipos = pd.Series(equipos)\n",
    "\n",
    "# Esta línea de código mira para cada elemento de la serie, si el número de champions es mayor que 5.\n",
    "print(list(map(lambda equipo: champions[equipo]>=5, serie_equipos)),'\\n')\n",
    "\n",
    "# Se puede utilizarla expresión anterior para obtener los equipos.\n",
    "serie_equipos[list(map(lambda equipo: champions[equipo]>=5, serie_equipos))]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=\"#7F000E\">  Acceso para escritura  </font>\n",
    "\n",
    "\n",
    "\n",
    "Se hace de manera similar. Es posible escribir varias posiciones a la vez."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "equipos = {'España': 'Real Madrid',\n",
    "           'Inglaterra': 'Manchester United',\n",
    "           'Italia': 'Milán',\n",
    "           'Francia': 'PSG',\n",
    "           'Alemania': 'Bayern Munich'}\n",
    "serie_equipos = pd.Series(equipos)\n",
    "print(serie_equipos)\n",
    "print()\n",
    "\n",
    "serie_equipos.loc['Alemania'] = 'Borussia Dormund'  \n",
    "serie_equipos.iloc[1] = 'Chelsea'                    \n",
    "serie_equipos['España']='Atlético de Madrid'\n",
    "serie_equipos[[2,3]]=['Juventus', 'Mónaco']\n",
    "# serie_equipos[[2,3]]=['Juventus', 'Mónaco', 'Marsella'] # Error por la diferencia de tamaños\n",
    "print(serie_equipos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si se asigna un valor a un nuevo índice, se añade un nuevo elemento a la serie."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "serie_equipos['Portugal']='Benfica'            \n",
    "print(serie_equipos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=\"#7F000E\">  Acceso a índices y valores </font>\n",
    "\n",
    "Es posible acceder al índice y lista de valores contenidos en la serie por separado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(serie_equipos.index.values)\n",
    "print(serie_equipos.index.values[0])\n",
    "print()\n",
    "\n",
    "print(serie_equipos.values)\n",
    "print(serie_equipos.values[0])\n",
    "print()\n",
    "\n",
    "#print(type(serie_equipos.index)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: right\">\n",
    "<a href=\"#indice\"><font size=5><i class=\"fa fa-arrow-circle-up\" aria-hidden=\"true\" style=\"color:#7F000E\"></i></font></a>\n",
    "</div>\n",
    "\n",
    "---\n",
    "\n",
    "<a id=\"section3\"></a>\n",
    "# <font color=\"#7F000E\" size=5> 3. Operaciones y funciones sobre series </font>\n",
    "<br>\n",
    "\n",
    "La clase `Series` implementa una gran cantidad de operadores y funciones. Las de uso más general se organizan y describen a continuación. Para información completa, se puede consultar la [API de la clase Series](https://pandas.pydata.org/pandas-docs/stable/reference/series.html).\n",
    "\n",
    "<a id=\"section31\"></a> \n",
    "## <font color=\"#7F000E\">Operadores binarios </font>\n",
    "\n",
    "Al igual que con los arrays _Numpy_, es posible llevar a cabo operaciones a nivel de elemento entre series, o entre series y escalares. Éstas pueden hacerse mediante operadores o funciones. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "champions = {'Real Madrid':12, 'Manchester United':3, 'Milán':7, 'Bayern Munich':5, 'PSG': 0}\n",
    "serie_champions = pd.Series(champions)\n",
    "\n",
    "europa_league = {'Real Madrid':2, 'Manchester United':1, 'Milán':0, 'Bayern Munich':1, 'PSG': 0}\n",
    "serie_europa_league = pd.Series(europa_league)\n",
    "\n",
    "# Operación entre series\n",
    "print(serie_champions+serie_europa_league,'\\n')      # Operador\n",
    "print(serie_champions.add(serie_europa_league),'\\n') # Función\n",
    "\n",
    "# Operación entre serie y valor escalar\n",
    "print(serie_champions>3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las operaciones que involucran varias series se llevan a cabo entre __elementos con el mismo índice__. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "    \n",
    "<i class=\"fa fa-exclamation-circle\" aria-hidden=\"true\"></i>\n",
    "__Importante__: Cuando uno de los elementos no aparece en alguna de las series implicadas, el resultado es NaN.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "europa_league = {'Real Madrid':2, 'Manchester United':1, 'Milán':0, \n",
    "                 'Bayern Munich':1, 'PSG': 0, 'Atlético de Madrid':2}\n",
    "serie_europa_league = pd.Series(europa_league)\n",
    "\n",
    "print(serie_champions+serie_europa_league) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible definir funciones que se implementen a partir de estos operadores u otros definidos para actuar sobre los elementos de las series, y aplicarlas sobre las series. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def titulos_decada(titulos):\n",
    "    ''' Numero medio de títulos ganados por cada década de competición'''\n",
    "    return titulos/6.0\n",
    "\n",
    "champions = {'Real Madrid':13, 'Manchester United':3, 'Milán':7, 'Bayern Munich':5, 'PSG': 0}\n",
    "serie_champions = pd.Series(champions)\n",
    "\n",
    "titulos_decada(serie_champions) # Se aplica la función sobre cada elemento de la serie. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-danger\">\n",
    "\n",
    "<i class=\"fa fa-exclamation-triangle\" aria-hidden=\"true\"></i>\n",
    "Cuando la función u operador no trabaja a nivel de elemento, el comportamiento es inesperado.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def titulos_str(titulos):\n",
    "    return str(titulos)+\" títulos\" # No se convierte a String cada elemento, sino la serie entera\n",
    "\n",
    "titulos_str(serie_champions)       # Se aplica la función sobre cada elemento de la serie. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: right\">\n",
    "<a href=\"#indice\"><font size=5><i class=\"fa fa-arrow-circle-up\" aria-hidden=\"true\" style=\"color:#7F000E\"></i></font></a>\n",
    "</div>\n",
    "\n",
    "---\n",
    "\n",
    "<a id=\"section32\"></a> \n",
    "## <font color=\"#7F000E\" face=\"monospace\">apply() y map()</font>\n",
    "<br>\n",
    "\n",
    "Las funciones `apply()`  y `map()` permiten _aplicar_ una función a cada elemento de una serie. Como resultado de su aplicación, se genera otra serie. \n",
    "\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    \n",
    "<i class=\"fa fa-info-circle\" aria-hidden=\"true\"></i>\n",
    "**Nota**: Estas funciones se utilizan de manera muy frecuente, ya permiten utilizar ___cualquier___ función para transformar los valores de la serie. Por otra parte, y __en el caso de Series__ (veremos más adelante que estas funciones también se aplican a _DataFrames_) las diferencias entre ambas son sutiles, y prácticamente son intercambiables. La función `map` admite también diccionarios o _Series_. Por otra parte, `apply` se usa solo con funciones, generalmente más complejas. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "champions = {'Real Madrid':12, 'Manchester United':3, 'Milán':7, 'Bayern Munich':5, 'PSG': 0}\n",
    "europa_league = {'Real Madrid':2, 'Manchester United':1, 'Milán':0, 'Bayern Munich':1, 'PSG': 0}\n",
    "\n",
    "# Ahora solamente se dispone de una serie que se indexa por países. \n",
    "equipos = {'España': 'Real Madrid',\n",
    "           'Inglaterra': 'Manchester United',\n",
    "           'Italia': 'Milán',\n",
    "           'Francia': 'PSG',\n",
    "           'Alemania': 'Bayern Munich'}\n",
    "serie_equipos = pd.Series(equipos)\n",
    "\n",
    "def copas_equipo(equipo):                                        # Utilizamos get en lugar de [] en el acceso a los\n",
    "    return champions.get(equipo,0)+europa_league.get(equipo,0)   # diccionarios para poder devolver un valor por\n",
    "                                                                 # defecto (0) si el equipo no existe. \n",
    "serie_equipos.apply(copas_equipo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es muy frecuente utilizar funciones `lambda` junto con `apply` o `map`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "serie_equipos.map(lambda equipo: champions.get(equipo,0)+europa_league.get(equipo,0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "\n",
    "<i class=\"fa fa-info-circle\" aria-hidden=\"true\"></i>\n",
    "**Nota**: Las funciones `lambda` se usan por agilidad y claridad en el código. No obstante, las funciones estándar son ___más eficientes___.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: right\">\n",
    "<a href=\"#indice\"><font size=5><i class=\"fa fa-arrow-circle-up\" aria-hidden=\"true\" style=\"color:#7F000E\"></i></font></a>\n",
    "</div>\n",
    "\n",
    "---\n",
    "\n",
    "\n",
    "<a id=\"section33\"></a> \n",
    "## <font color=\"#7F000E\">Operaciones sobre Strings </font>\n",
    "<br>\n",
    "\n",
    "_Pandas_ implementa un conjunto de operaciones para el manejo de series de Strings, y que se aplican a nivel de elemento. Muchas de estas funciones corresponden con las equivalentes en las librerías de _Python_. El listado completo de funciones puede encontrarse en la sección correspondiente de la [API](https://pandas.pydata.org/pandas-docs/stable/reference/series.html#accessors)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "equipos = {'España': 'Real Madrid',\n",
    "           'Inglaterra': 'Manchester',\n",
    "           'Italia': 'Milán',\n",
    "           'Francia': 'PSG',\n",
    "           'Alemania': 'Bayern Munich'}\n",
    "serie_equipos = pd.Series(equipos)\n",
    "\n",
    "# Pasa a mayúsculas cada elemento de la serie. \n",
    "serie_equipos = serie_equipos.str.upper()\n",
    "print(serie_equipos,'\\n')\n",
    "\n",
    "# Ahora deja solo cada inicial en mayúscula.\n",
    "serie_equipos = serie_equipos.str.capitalize()\n",
    "print(serie_equipos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Estas funcionalidades se pueden reproducir también con `apply`, pero se recomiendan los métodos implementados en `Series` por cuestiones de eficiencia."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(serie_equipos.apply(str.upper)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: right\">\n",
    "<a href=\"#indice\"><font size=5><i class=\"fa fa-arrow-circle-up\" aria-hidden=\"true\" style=\"color:#004D7F\"></i></font></a>\n",
    "</div>\n",
    "\n",
    "---\n",
    "\n",
    "<a id=\"section34\"></a> \n",
    "## <font color=\"#7F000E\">Descripción y resumen </font>\n",
    "<br>\n",
    "\n",
    "Los objetos de tipo `Series` implementan también una gran cantidad de funciones que actúan sobre los elementos como un conjunto (no uno a uno). Algunas de ellas permiten obtener algunos datos de interés sobre la serie. El siguiente fragmento de código contiene ejemplos de llamadas a algunas de ellas. El listado completo puede consultarse en la sección correspondiente de la [API](https://pandas.pydata.org/pandas-docs/stable/reference/series.html#computations-descriptive-stats)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "champions = {'Real Madrid':13, 'Manchester United':3, 'Milán':7, 'Bayern Munich':5, 'PSG': 0}\n",
    "serie_champions = pd.Series(champions)\n",
    "\n",
    "print(\"Numero de elementos: \",serie_champions.count())                   \n",
    "print(\"Suma de los valores: \",serie_champions.sum())    \n",
    "print(\"Serie acumulada de valores:\\n\",serie_champions.cumsum())  \n",
    "\n",
    "print(\"\\nÍndice del máximo valor: \",serie_champions.idxmax())     \n",
    "print(\"Máximo valor: \",serie_champions.max())  \n",
    "print(\"Mínimo valor acumulado: \",serie_champions.cummin()) \n",
    "\n",
    "print(\"\\nMedia: \",serie_champions.mean())                      \n",
    "print(\"Desviación estándar: \", serie_champions.std())                      \n",
    "print(\"2 mayores valores: \",serie_champions.nlargest(2))  \n",
    "\n",
    "print(\"\\nCambio en porcentaje: \", serie_champions.pct_change())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función `describe` devuelve un resumen descriptivo de los datos. Admite algunos parámetros, como por ejemplo los percentiles. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "equipos = {'España': 'Real Madrid', 'Inglaterra': 'Manchester', 'Italia': 'Milán','Francia': 'PSG', 'Alemania': 'Bayern Munich'}\n",
    "serie_equipos = pd.Series(equipos)\n",
    "\n",
    "champions = {'Real Madrid':13, 'Manchester United':3, 'Milán':7, 'Bayern Munich':5, 'PSG': 0}\n",
    "serie_champions = pd.Series(champions)\n",
    "\n",
    "print(\"Serie con valores numéricos:\")\n",
    "print(serie_champions.describe(percentiles=[0.2,0.4,0.6,0.8]),'\\n')     # Resumen de los valores (datos numéricos) \n",
    "\n",
    "print(\"Serie con valores no numéricos:\")\n",
    "print(serie_equipos.describe(),'\\n')                                    # Resumen de los valores (datos no numéricos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mediante la función `unique()` es posible determinar qué valores aparecen en la serie. Esta funcionalidad es especialmente  útil cuando los valores son categóricos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "europa_league = {'Real Madrid':2, 'Manchester United':1, 'Milán':0, \n",
    "                 'Bayern Munich':1, 'PSG': 0, 'Atlético de Madrid':2}\n",
    "serie_europa_league = pd.Series(europa_league)\n",
    "\n",
    "print(serie_europa_league,'\\n')\n",
    "                                \n",
    "print(\"Valores distintos: \",serie_europa_league.unique())               \n",
    "print(\"Número de valores distintos:\", serie_europa_league.nunique())             \n",
    "print(\"Veces que aparece cada valor:\\n\", serie_europa_league.value_counts())          "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: right\">\n",
    "<a href=\"#indice\"><font size=5><i class=\"fa fa-arrow-circle-up\" aria-hidden=\"true\" style=\"color:#004D7F\"></i></font></a>\n",
    "</div>\n",
    "\n",
    "---\n",
    "\n",
    "\n",
    "<a id=\"section35\"></a> \n",
    "## <font color=\"#7F000E\">Manipulación de series </font>\n",
    "<br>\n",
    "\n",
    "### <font color=\"#7F000E\"> Eliminación de elementos </font>\n",
    "\n",
    "Es posible eliminar elementos de la serie mediante la función `drop()`. Ésta recibe como argumento una clave."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "champions = {'Real Madrid':13, 'Manchester United':3, 'Milán':7, 'Bayern Munich':5, 'PSG': 0}\n",
    "serie_champions = pd.Series(champions)\n",
    "\n",
    "serie_champions.drop('Real Madrid')\n",
    "print(serie_champions)                    # ¡Imprime la serie original!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-danger\">\n",
    "\n",
    "<i class=\"fa fa-exclamation-triangle\" aria-hidden=\"true\"></i>\n",
    "En el ejemplo anterior ___no___ se ha borrado la entrada correspondiente. La mayoría de operaciones, por defecto, __generan una copia__ de la serie.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "serie_champions_borrada = serie_champions.drop('Real Madrid')\n",
    "print(serie_champions_borrada)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El parámetro `inplace` indica que la operación se lleve a cabo sobre la propia serie. Por defecto, su valor es _False_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "serie_champions.drop('Real Madrid', inplace=True)\n",
    "print(serie_champions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=\"#7F000E\"> Concatenación de series </font>\n",
    "\n",
    "El método `append()` permite concatenar series. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "champions = {'Real Madrid':13, 'Manchester United':3, 'Milán':7, 'Bayern Munich':5, 'PSG': 0}\n",
    "serie_champions = pd.Series(champions)\n",
    "\n",
    "europa_league = {'Real Madrid':2, 'Manchester United':1, 'Milán':0, 'Bayern Munich':1, 'PSG': 0, 'Atlético de Madrid':3}\n",
    "serie_europa_league = pd.Series(europa_league)\n",
    "\n",
    "print(serie_champions.append(serie_europa_league))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "    \n",
    "<i class=\"fa fa-exclamation-circle\" aria-hidden=\"true\"></i>\n",
    "Se observa que en una serie puede haber dos elementos con el mismo índice. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "serie_champions_europa = serie_champions.append(serie_europa_league)\n",
    "print(serie_champions_europa.loc['Real Madrid'])\n",
    "\n",
    "#print(type(serie_champions_europa.loc['Real Madrid']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=\"#7F000E\">Sustitución de elementos </font>\n",
    "\n",
    "El método `replace()` permite reemplazar valores. Admite como parámetro un diccionario, permitiendo así sustituir varios valores a la vez. Incluso es posible utilizar _expresiones regulares_ [(documentación)](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.replace.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "champions = {'Real Madrid':13, 'Manchester United':3, 'Milán':7, 'Bayern Munich':5, 'PSG': 0, 'Atlético de Madrid':0}\n",
    "serie_champions = pd.Series(champions)\n",
    "print(serie_champions,'\\n')\n",
    "# Reemplaza un valor por otro\n",
    "print(serie_champions.replace(0,'Nunca'),'\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "equipos = {'España': 'Real Madrid', 'Inglaterra': 'Manchester United', 'Italia': 'Milán', 'Francia': 'PSG', 'Alemania': 'Bayern Munich'}\n",
    "serie_equipos = pd.Series(equipos)\n",
    "\n",
    "print(serie_equipos, '\\n')\n",
    "# Utiliza un diccionario para determinar los valores que se reemplazan y los nuevos valores. \n",
    "print(serie_equipos.replace({'Real Madrid':'Atlético de Madrid', 'Milán':'Juventus'}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: right\">\n",
    "<a href=\"#indice\"><font size=5><i class=\"fa fa-arrow-circle-up\" aria-hidden=\"true\" style=\"color:#7F000E\"></i></font></a>\n",
    "</div>\n",
    "\n",
    "---\n",
    "\n",
    "<a id=\"section36\"></a> \n",
    "## <font color=\"#7F000E\">Consulta y selección </font>\n",
    "<br>\n",
    "\n",
    "Además de las posibilidades que ofrece la indexación, existen algunas funciones que permiten llevar a cabo diversas operaciones de consulta y selección sobre `Series`.\n",
    "\n",
    "### <font color=\"#7F000E\" face=\"monospace\"> head() / tail() </font>\n",
    "\n",
    "\n",
    "La función `head()` muestra los primeros elementos de la serie; la función `tail()` los últimos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "champions = {'Real Madrid':12, 'Manchester United':3, 'Milán':7, 'Bayern Munich':5, 'PSG': 0}\n",
    "serie_champions = pd.Series(champions)\n",
    "\n",
    "print(serie_champions.head(3),'\\n')                 # Devuelve los 3 primeros elementos. \n",
    "print(serie_champions.tail(2))                      # Devuelve los 2 últimos elementos. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=\"#7F000E\" face=\"monospace\"> any() / all() </font>\n",
    "\n",
    "Las funciones denominadas `any()` y `all()`  permiten determinar si uno o todos  (respectivamente) los valores de la serie, son distintos de `False` (o 0). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "champions = {'Real Madrid':13, 'Manchester United':3, 'Milán':7, 'Bayern Munich':5, 'PSG': 0}\n",
    "serie_champions = pd.Series(champions)\n",
    "print(serie_champions)\n",
    "print()\n",
    "\n",
    "print(serie_champions.any())\n",
    "print(serie_champions.all(),'\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Estas funciones se utilizan a menudo junto a una condición. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(serie_champions>13,'\\n')                      # Esta comparación genera una serie. \n",
    "\n",
    "print((serie_champions>13).any())                   # Se le puede aplicar la función any()."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=\"#7F000E\" face=\"monospace\">isna()/isnull() y notna()/notnull() </font>\n",
    "\n",
    "También existen las funciones `isna()/isnull()` y `notna()/notnull()` que permiten determinar qué elementos de la serie son `NaN` (o `None`, dependiendo del tipo de datos) o no lo son."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "champions = {'Real Madrid':13, 'Manchester United':3, 'Milán':7, 'Bayern Munich':5, 'PSG': 0}\n",
    "serie_champions = pd.Series(champions)\n",
    "serie_champions['Real Madrid']=np.nan       # Muestra qué elementos son null o na.\n",
    "print(serie_champions)\n",
    "print()\n",
    "\n",
    "print(serie_champions.isnull())\n",
    "print()\n",
    "print(serie_champions.notnull())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=\"#7F000E\" face=\"monospace\"> where() y mask() </font>\n",
    "\n",
    "La función `where(condición)` devuelve una serie con los elementos que cumplen la condición, y en la que los elementos que __no__ cumplen la condición toman un valor predefinido. Por defecto, este valor es `NaN`, pero puede ser un escalar, o incluso el valor correspondiente en otra serie. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "serie_champions['Real Madrid']=13 \n",
    "serie_champions['Atlético de Madrid']=0 \n",
    "print(serie_champions)\n",
    "print()\n",
    "print(serie_champions.where((serie_champions >= 3)))\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Con un valor por defecto:\")\n",
    "print(serie_champions.where((serie_champions > 1),'Ninguna (todavía)'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"A los que tienen menos de 1 champions, les asigna el número de Europa League\")\n",
    "print(serie_champions.where((serie_champions >1), serie_europa_league))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "\n",
    "<i class=\"fa fa-exclamation-circle\" aria-hidden=\"true\"></i>\n",
    "Además de la posibilidad de reemplazar los elementos que no cumplen la condición, la diferencia de esta función con la indexación condicional es que, esta última, solamente devuelve los elementos que cumplen la condición.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "serie_champions[(serie_champions>3) & (serie_champions<12)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función `mask()` es parecida a la anterior, pero sustituye (enmascara) los elementos que cumplen la condición, y copia tal cual los elementos que __no__ la cumplen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Con un valor por defecto:\")\n",
    "print(serie_champions.mask((serie_champions > 3), 'Demasiadas'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=\"#7F000E\" face=\"monospace\"> filter() </font>\n",
    "\n",
    "La función `filter()` permite filtrar elementos de la serie en función del valor del índice. Admite varios parámetros."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "serie_champions.filter(items=['Milán'])       # Elementos cuyo índice es 'Milán'\n",
    "#serie_champions.filter(like='Madrid')         # Elementos cuyo índice contiene 'Madrid'\n",
    "#serie_champions.filter(regex=r'\\w.* \\w.*')     # Elementos que contienen la expresión regular (al menos dos palabras)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "\n",
    "<i class=\"fa fa-exclamation-circle\" aria-hidden=\"true\"></i> Existía una función parecida, denominada `select()` pero se ha eliminado de Pandas ( _Deprecated_ ).\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: right\">\n",
    "<a href=\"#indice\"><font size=5><i class=\"fa fa-arrow-circle-up\" aria-hidden=\"true\" style=\"color:#004D7F\"></i></font></a>\n",
    "</div>\n",
    "\n",
    "---\n",
    "\n",
    "<a id=\"section37\"></a> \n",
    "## <font color=\"#7F000E\">Vectorización </font>\n",
    "<br>\n",
    "\n",
    "Internamente, _Pandas_ utiliza _Numpy_ para almacenar los datos. Por tanto, algunas de las  peraciones que se pueden llevar sobre los objetos `Series` (y los `DataFrame` que se verán después) son vectorizadas. Esto supone un aumento importante en la eficiencia."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Crea una serie de números aleatorios\n",
    "serie = pd.Series(np.random.randint(0,1000,10000))\n",
    "print(serie.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En las celdas siguientes se calcula la suma de los elementos de la serie, sin, y con vectorización."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%timeit -n 10 -r 7\n",
    "suma = 0\n",
    "for elem in serie:\n",
    "    suma+=elem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%timeit -n 10 \n",
    "suma = serie.sum()\n",
    "#suma = np.sum(serie)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el siguiente ejemplo se compara el tiempo de ejecución de una suma con un escalar mediante un bucle, y mediante _Broadcast_. (En este caso, se inicializa la estructura en la misma linea de `timeit`, pero ese tiempo no se computa)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%timeit -n 10 serie = pd.Series(np.random.randint(0,1000,1000))\n",
    "for indice, valor in serie.iteritems():\n",
    "    serie.loc[indice]= valor+2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%timeit -n 10 serie = pd.Series(np.random.randint(0,1000,1000))\n",
    "serie+=2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: right\">\n",
    "<a href=\"#indice\"><font size=5><i class=\"fa fa-arrow-circle-up\" aria-hidden=\"true\" style=\"color:#004D7F\"></i></font></a>\n",
    "</div>\n",
    "\n",
    "---\n",
    "\n",
    "<a id=\"section4\"></a>\n",
    "# <font color=\"#7F000E\"> 4. DataFrames</font>\n",
    "<br>\n",
    "\n",
    "Un `DataFrame` es una estructura _bidimensional_ de datos que se indexa por filas y columnas. Al igual que en una hoja de cálculo o una tabla SQL, cada columna puede almacenar datos de un tipo diferente, y es tratada como un objeto de tipo `Series`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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>Name</th>\n",
       "      <th>Age</th>\n",
       "      <th>Photo</th>\n",
       "      <th>Nationality</th>\n",
       "      <th>Flag</th>\n",
       "      <th>Overall</th>\n",
       "      <th>Potential</th>\n",
       "      <th>Club</th>\n",
       "      <th>Club Logo</th>\n",
       "      <th>Value</th>\n",
       "      <th>...</th>\n",
       "      <th>Composure</th>\n",
       "      <th>Marking</th>\n",
       "      <th>StandingTackle</th>\n",
       "      <th>SlidingTackle</th>\n",
       "      <th>GKDiving</th>\n",
       "      <th>GKHandling</th>\n",
       "      <th>GKKicking</th>\n",
       "      <th>GKPositioning</th>\n",
       "      <th>GKReflexes</th>\n",
       "      <th>Release Clause</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ID</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></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>158023</th>\n",
       "      <td>L. Messi</td>\n",
       "      <td>31</td>\n",
       "      <td>https://cdn.sofifa.org/players/4/19/158023.png</td>\n",
       "      <td>Argentina</td>\n",
       "      <td>https://cdn.sofifa.org/flags/52.png</td>\n",
       "      <td>94</td>\n",
       "      <td>94</td>\n",
       "      <td>FC Barcelona</td>\n",
       "      <td>https://cdn.sofifa.org/teams/2/light/241.png</td>\n",
       "      <td>€110.5M</td>\n",
       "      <td>...</td>\n",
       "      <td>96.0</td>\n",
       "      <td>33.0</td>\n",
       "      <td>28.0</td>\n",
       "      <td>26.0</td>\n",
       "      <td>6.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>15.0</td>\n",
       "      <td>14.0</td>\n",
       "      <td>8.0</td>\n",
       "      <td>€226.5M</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20801</th>\n",
       "      <td>Cristiano Ronaldo</td>\n",
       "      <td>33</td>\n",
       "      <td>https://cdn.sofifa.org/players/4/19/20801.png</td>\n",
       "      <td>Portugal</td>\n",
       "      <td>https://cdn.sofifa.org/flags/38.png</td>\n",
       "      <td>94</td>\n",
       "      <td>94</td>\n",
       "      <td>Juventus</td>\n",
       "      <td>https://cdn.sofifa.org/teams/2/light/45.png</td>\n",
       "      <td>€77M</td>\n",
       "      <td>...</td>\n",
       "      <td>95.0</td>\n",
       "      <td>28.0</td>\n",
       "      <td>31.0</td>\n",
       "      <td>23.0</td>\n",
       "      <td>7.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>15.0</td>\n",
       "      <td>14.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>€127.1M</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>190871</th>\n",
       "      <td>Neymar Jr</td>\n",
       "      <td>26</td>\n",
       "      <td>https://cdn.sofifa.org/players/4/19/190871.png</td>\n",
       "      <td>Brazil</td>\n",
       "      <td>https://cdn.sofifa.org/flags/54.png</td>\n",
       "      <td>92</td>\n",
       "      <td>93</td>\n",
       "      <td>Paris Saint-Germain</td>\n",
       "      <td>https://cdn.sofifa.org/teams/2/light/73.png</td>\n",
       "      <td>€118.5M</td>\n",
       "      <td>...</td>\n",
       "      <td>94.0</td>\n",
       "      <td>27.0</td>\n",
       "      <td>24.0</td>\n",
       "      <td>33.0</td>\n",
       "      <td>9.0</td>\n",
       "      <td>9.0</td>\n",
       "      <td>15.0</td>\n",
       "      <td>15.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>€228.1M</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>193080</th>\n",
       "      <td>De Gea</td>\n",
       "      <td>27</td>\n",
       "      <td>https://cdn.sofifa.org/players/4/19/193080.png</td>\n",
       "      <td>Spain</td>\n",
       "      <td>https://cdn.sofifa.org/flags/45.png</td>\n",
       "      <td>91</td>\n",
       "      <td>93</td>\n",
       "      <td>Manchester United</td>\n",
       "      <td>https://cdn.sofifa.org/teams/2/light/11.png</td>\n",
       "      <td>€72M</td>\n",
       "      <td>...</td>\n",
       "      <td>68.0</td>\n",
       "      <td>15.0</td>\n",
       "      <td>21.0</td>\n",
       "      <td>13.0</td>\n",
       "      <td>90.0</td>\n",
       "      <td>85.0</td>\n",
       "      <td>87.0</td>\n",
       "      <td>88.0</td>\n",
       "      <td>94.0</td>\n",
       "      <td>€138.6M</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>192985</th>\n",
       "      <td>K. De Bruyne</td>\n",
       "      <td>27</td>\n",
       "      <td>https://cdn.sofifa.org/players/4/19/192985.png</td>\n",
       "      <td>Belgium</td>\n",
       "      <td>https://cdn.sofifa.org/flags/7.png</td>\n",
       "      <td>91</td>\n",
       "      <td>92</td>\n",
       "      <td>Manchester City</td>\n",
       "      <td>https://cdn.sofifa.org/teams/2/light/10.png</td>\n",
       "      <td>€102M</td>\n",
       "      <td>...</td>\n",
       "      <td>88.0</td>\n",
       "      <td>68.0</td>\n",
       "      <td>58.0</td>\n",
       "      <td>51.0</td>\n",
       "      <td>15.0</td>\n",
       "      <td>13.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>13.0</td>\n",
       "      <td>€196.4M</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 87 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                     Name  Age  \\\n",
       "ID                               \n",
       "158023           L. Messi   31   \n",
       "20801   Cristiano Ronaldo   33   \n",
       "190871          Neymar Jr   26   \n",
       "193080             De Gea   27   \n",
       "192985       K. De Bruyne   27   \n",
       "\n",
       "                                                 Photo Nationality  \\\n",
       "ID                                                                   \n",
       "158023  https://cdn.sofifa.org/players/4/19/158023.png   Argentina   \n",
       "20801    https://cdn.sofifa.org/players/4/19/20801.png    Portugal   \n",
       "190871  https://cdn.sofifa.org/players/4/19/190871.png      Brazil   \n",
       "193080  https://cdn.sofifa.org/players/4/19/193080.png       Spain   \n",
       "192985  https://cdn.sofifa.org/players/4/19/192985.png     Belgium   \n",
       "\n",
       "                                       Flag  Overall  Potential  \\\n",
       "ID                                                                \n",
       "158023  https://cdn.sofifa.org/flags/52.png       94         94   \n",
       "20801   https://cdn.sofifa.org/flags/38.png       94         94   \n",
       "190871  https://cdn.sofifa.org/flags/54.png       92         93   \n",
       "193080  https://cdn.sofifa.org/flags/45.png       91         93   \n",
       "192985   https://cdn.sofifa.org/flags/7.png       91         92   \n",
       "\n",
       "                       Club                                     Club Logo  \\\n",
       "ID                                                                          \n",
       "158023         FC Barcelona  https://cdn.sofifa.org/teams/2/light/241.png   \n",
       "20801              Juventus   https://cdn.sofifa.org/teams/2/light/45.png   \n",
       "190871  Paris Saint-Germain   https://cdn.sofifa.org/teams/2/light/73.png   \n",
       "193080    Manchester United   https://cdn.sofifa.org/teams/2/light/11.png   \n",
       "192985      Manchester City   https://cdn.sofifa.org/teams/2/light/10.png   \n",
       "\n",
       "          Value  ... Composure  Marking StandingTackle  SlidingTackle  \\\n",
       "ID               ...                                                    \n",
       "158023  €110.5M  ...      96.0     33.0           28.0           26.0   \n",
       "20801      €77M  ...      95.0     28.0           31.0           23.0   \n",
       "190871  €118.5M  ...      94.0     27.0           24.0           33.0   \n",
       "193080     €72M  ...      68.0     15.0           21.0           13.0   \n",
       "192985    €102M  ...      88.0     68.0           58.0           51.0   \n",
       "\n",
       "        GKDiving  GKHandling GKKicking GKPositioning GKReflexes Release Clause  \n",
       "ID                                                                              \n",
       "158023       6.0        11.0      15.0          14.0        8.0        €226.5M  \n",
       "20801        7.0        11.0      15.0          14.0       11.0        €127.1M  \n",
       "190871       9.0         9.0      15.0          15.0       11.0        €228.1M  \n",
       "193080      90.0        85.0      87.0          88.0       94.0        €138.6M  \n",
       "192985      15.0        13.0       5.0          10.0       13.0        €196.4M  \n",
       "\n",
       "[5 rows x 87 columns]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Lee el archivo, utiliza el campo ID como índice.\n",
    "df_fifa = pd.read_csv('./data/fifa19.csv', index_col=0).set_index('ID')\n",
    "# Muestra la cabecera\n",
    "df_fifa.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nombres = df_fifa['Name']\n",
    "print('\\n',type(nombres))\n",
    "print(nombres[:5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: right\">\n",
    "<a href=\"#indice\"><font size=5><i class=\"fa fa-arrow-circle-up\" aria-hidden=\"true\" style=\"color:#7F000E\"></i></font></a>\n",
    "</div>\n",
    "\n",
    "---\n",
    "\n",
    "<a id=\"section41\"></a> \n",
    "## <font color=\"#7F000E\">Estructura </font>\n",
    "<br>\n",
    "\n",
    "Un `DataFrame` está formado por tres componentes principales:\n",
    "\n",
    "1. Los _datos_, almacenados en el campo `DataFrame.values`, que es un array _NumPy_.\n",
    "2. El _índice_, almacenado en el campo `DataFrame.index`, y que permite indexar las filas.\n",
    "3. El _índice de columnas_, almacenado en el campo `DataFrame.columns`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Valores (2 primeras filas)')\n",
    "print(df_fifa.values[:2,:])\n",
    "print(type(df_fifa.values))\n",
    "\n",
    "print('\\nÍndice:')\n",
    "print(df_fifa.index)\n",
    "print(type(df_fifa.index))\n",
    "\n",
    "print('\\nColumnas:')\n",
    "print(df_fifa.columns)\n",
    "print(type(df_fifa.columns))\n",
    "\n",
    "#df_fifa.axes     # Índice y columnas (No se suele usar)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible hacer algunas comprobaciones sobre los índices y columnas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(df_fifa.index.is_unique)\n",
    "print(df_fifa.Age.is_unique)\n",
    "#df_fifa.index.is_monotonic_increasing\n",
    "#df_fifa.index.is_monotonic_decreasing\n",
    "df_fifa.index.has_duplicates"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible acceder a muchas de las propiedades de la estructura de un `DataFrame`, como sus dimensiones, los tipos de datos de las columnas, o incluso la ocupación en memoria. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "print('Tamaño del conjunto de datos: {:d} filas, {:d} columnas.'.format(df_fifa.shape[0], df_fifa.shape[1]))\n",
    "#print('Tamaño del conjunto de datos: {:d} filas, {:d} columnas.'.format(len(df_fifa.index), len(df_fifa.columns)))\n",
    "#print('Número de filas del Dataframe: ', len(df_fifa))\n",
    "print('Número de elementos almacenados: {:d}'.format(df_fifa.size))\n",
    "print(\"\\nTipo de datos de cada columna: \\n\", df_fifa.dtypes)\n",
    "print(\"\\nToda la información:\\n\")\n",
    "print(df_fifa.info())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Incluso es posible acceder a información más detallada sobre el uso de memoria (por columnas) mediante `DataFrame.memory_usage()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_fifa.memory_usage()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "\n",
    "<i class=\"fa fa-info-circle\" aria-hidden=\"true\"></i>\n",
    "&nbsp;  Aunque el uso de información a este nivel __excede el nivel de este tutorial__, sí que puede ser útil ocasionalmente si se hace necesario reducir el tamaño del `DataFrame` en memoria. Por ejemplo, el siguiente código convierte el tipo de datos de la columna `Age` a un entero de un byte, con la correspondiente disminución en el tamaño de la estructura. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_fifa['Age'] = df_fifa['Age'].astype(np.int8)\n",
    "print(df_fifa.memory_usage())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Con respecto a los índices, tanto el propio índice como las columnas se representan con tipos de datos específicos que optimizan los accesos. Sin embargo, la colección de valores se representa internamente mediante un array _Numpy_ que es accesible a través del campo `values`. También se pueden convertir en listas mediante el método `tolist()`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Columnas\")\n",
    "print(df_fifa.columns)\n",
    "print(\"\\nArray interno (values): \")\n",
    "print(df_fifa.columns.values)\n",
    "print(type(df_fifa.columns.values))\n",
    "print(\"\\nComo lista:\")\n",
    "\n",
    "print(df_fifa.columns.tolist())\n",
    "print(type(df_fifa.columns.tolist()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: right\">\n",
    "<a href=\"#indice\"><font size=5><i class=\"fa fa-arrow-circle-up\" aria-hidden=\"true\" style=\"color:#7F000E\"></i></font></a>\n",
    "</div>\n",
    "\n",
    "---\n",
    "\n",
    "<a id=\"section42\"></a> \n",
    "## <font color=\"#7F000E\">Lectura / escritura de DataFrames </font>\n",
    "<br>\n",
    "\n",
    "_Pandas_ proporciona funciones muy flexibles que permiten leer objetos `DataFrame` desde diversas fuentes de datos, como archivos csv, excel, JSON, HDF5, HTML, fuentes SQL, o incluso el portapapeles del sistema ([documentación](http://pandas.pydata.org/pandas-docs/version/0.20/io.html)). \n",
    "\n",
    "A continuación se describen los métodos que se utilizarán con más frecuencia en este curso.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=\"#7F000E\">  Lectura y escritura de archivos en formato csv (_comma separated values_) </font>\n",
    "\n",
    "Se lleva a cabo mediante la función `read_csv()`. El parámetro `index_col` permite especificar si alguna de las columnas ha de ser utilizada como índice del `DataFrame`. Esta función acepta otros muchos parámetros, que permiten por ejemplo:\n",
    "* descartar líneas (`skiprows`)\n",
    "* elegir el separador entre columnas (`sep`)\n",
    "* especificar el nombre de cada columna (`names`)\n",
    "* especificar el tipo de datos de cada columna (`dtype`)\n",
    "* especificar qué valores se considerarán perdidos (`na_values`)\n",
    "* especificar el caracter con el que se delimitan cadenas de texto (`quotechar`)\n",
    "* etc.\n",
    "\n",
    "Además, puede acceder a la fuente de datos a través de una URL ([documentación](http://pandas.pydata.org/pandas-docs/stable/generated/pandas.read_csv.html))."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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>ID</th>\n",
       "      <th>Clase</th>\n",
       "      <th>Edad</th>\n",
       "      <th>Sexo</th>\n",
       "      <th>Superviviente</th>\n",
       "      <th>Código (Sexo)</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nombre</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>Allen, Miss Elisabeth Walton</th>\n",
       "      <td>1</td>\n",
       "      <td>1st</td>\n",
       "      <td>29.00</td>\n",
       "      <td>female</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Allison, Miss Helen Loraine</th>\n",
       "      <td>2</td>\n",
       "      <td>1st</td>\n",
       "      <td>2.00</td>\n",
       "      <td>female</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Allison, Mr Hudson Joshua Creighton</th>\n",
       "      <td>3</td>\n",
       "      <td>1st</td>\n",
       "      <td>30.00</td>\n",
       "      <td>male</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Allison, Mrs Hudson JC (Bessie Waldo Daniels)</th>\n",
       "      <td>4</td>\n",
       "      <td>1st</td>\n",
       "      <td>25.00</td>\n",
       "      <td>female</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Allison, Master Hudson Trevor</th>\n",
       "      <td>5</td>\n",
       "      <td>1st</td>\n",
       "      <td>0.92</td>\n",
       "      <td>male</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                               ID Clase   Edad    Sexo  \\\n",
       "Nombre                                                                   \n",
       "Allen, Miss Elisabeth Walton                    1   1st  29.00  female   \n",
       "Allison, Miss Helen Loraine                     2   1st   2.00  female   \n",
       "Allison, Mr Hudson Joshua Creighton             3   1st  30.00    male   \n",
       "Allison, Mrs Hudson JC (Bessie Waldo Daniels)   4   1st  25.00  female   \n",
       "Allison, Master Hudson Trevor                   5   1st   0.92    male   \n",
       "\n",
       "                                               Superviviente  Código (Sexo)  \n",
       "Nombre                                                                       \n",
       "Allen, Miss Elisabeth Walton                               1              1  \n",
       "Allison, Miss Helen Loraine                                0              1  \n",
       "Allison, Mr Hudson Joshua Creighton                        0              0  \n",
       "Allison, Mrs Hudson JC (Bessie Waldo Daniels)              0              1  \n",
       "Allison, Master Hudson Trevor                              1              0  "
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#df_titanic = pd.read_csv('data/Titanic.csv', index_col=0, sep=',')\n",
    "#df = pd.read_csv('https://vincentarelbundock.github.io/Rdatasets/csv/datasets/Titanic.csv', index_col=0)\n",
    "df_titanic = pd.read_csv('data/Titanic.csv', sep=',', skiprows=1, index_col=1,\n",
    "                         names=['ID','Nombre','Clase','Edad','Sexo','Superviviente','Código (Sexo)'])\n",
    "df_titanic.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La escritura se lleva a cabo mediante la función `to_csv()`. Ésta acepta parámetros relativos al contenido:`header` o `index` para escribir los nombres de columnas o filas, `na_rep` para representación de los valores perdidos, etc. También acepta un parámetro denominado `encoding`, para establecer la codificación de los caracteres [(documentación)](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.to_csv.html).\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "\n",
    "<i class=\"fa fa-info-circle\" aria-hidden=\"true\"></i>\n",
    "Ambos métodos admiten un parámetro, denominado `compress` que permite leer/escribir directamente desde archivos comprimidos (más lento).\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_titanic.to_csv('data/Titanic.zip', sep=';', header=True, encoding='utf-8', compression='gzip')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### <font color=\"#7F000E\">  Lectura y escritura de archivos en formato excel </font>\n",
    "\n",
    "Se hace mediante la función `read_excel()`. Al igual que la anterior, permite especificar numerosos parámetros como la hoja concreta del archivo (`sheet_name`), tipos de datos, etc ([documentación](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.read_excel.html)). También es posible exportar un `DataFrame` a formato Excel mediante la función `to_excel()` [(documentación)]( https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.to_excel.html)."
   ]
  },
  {
   "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>Nombre</th>\n",
       "      <th>Clase</th>\n",
       "      <th>Edad</th>\n",
       "      <th>Sexo</th>\n",
       "      <th>Superviviente</th>\n",
       "      <th>Código (Sexo)</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ID</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>1</th>\n",
       "      <td>Allen, Miss Elisabeth Walton</td>\n",
       "      <td>1st</td>\n",
       "      <td>29.00</td>\n",
       "      <td>female</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Allison, Miss Helen Loraine</td>\n",
       "      <td>1st</td>\n",
       "      <td>2.00</td>\n",
       "      <td>female</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Allison, Mr Hudson Joshua Creighton</td>\n",
       "      <td>1st</td>\n",
       "      <td>30.00</td>\n",
       "      <td>male</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Allison, Mrs Hudson JC (Bessie Waldo Daniels)</td>\n",
       "      <td>1st</td>\n",
       "      <td>25.00</td>\n",
       "      <td>female</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Allison, Master Hudson Trevor</td>\n",
       "      <td>1st</td>\n",
       "      <td>0.92</td>\n",
       "      <td>male</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                           Nombre Clase   Edad    Sexo  \\\n",
       "ID                                                                       \n",
       "1                    Allen, Miss Elisabeth Walton   1st  29.00  female   \n",
       "2                     Allison, Miss Helen Loraine   1st   2.00  female   \n",
       "3             Allison, Mr Hudson Joshua Creighton   1st  30.00    male   \n",
       "4   Allison, Mrs Hudson JC (Bessie Waldo Daniels)   1st  25.00  female   \n",
       "5                   Allison, Master Hudson Trevor   1st   0.92    male   \n",
       "\n",
       "    Superviviente  Código (Sexo)  \n",
       "ID                                \n",
       "1               1              1  \n",
       "2               0              1  \n",
       "3               0              0  \n",
       "4               0              1  \n",
       "5               1              0  "
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_titanic = pd.read_excel('data/Titanic.xls', sheet_name='Hoja1', skiprows=0, index_col=0,names=['ID','Nombre','Clase','Edad','Sexo','Superviviente','Código (Sexo)'])\n",
    "df_titanic.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-danger\">\n",
    "\n",
    "<i class=\"fa fa-exclamation-triangle\" aria-hidden=\"true\"></i>\n",
    " Para trabajar con excel es necesario instalar el paquete `xlrd`.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: xlrd in c:\\users\\yuri\\anaconda38\\lib\\site-packages (1.2.0)\n"
     ]
    }
   ],
   "source": [
    "!pip install xlrd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Existen objetos, denominados `pd.ExcelFile` y `pd.ExcelWriter` que permiten leer y escribir, respectivamente, archivos Excel. Su funcionalidad es similar a la de los métodos descritos anteriormente. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hojas:  ['Hoja1']\n"
     ]
    },
    {
     "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>ID</th>\n",
       "      <th>PClass</th>\n",
       "      <th>Age</th>\n",
       "      <th>Sex</th>\n",
       "      <th>Survived</th>\n",
       "      <th>SexCode)</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Name</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>Allen, Miss Elisabeth Walton</th>\n",
       "      <td>1</td>\n",
       "      <td>1st</td>\n",
       "      <td>29.00</td>\n",
       "      <td>female</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Allison, Miss Helen Loraine</th>\n",
       "      <td>2</td>\n",
       "      <td>1st</td>\n",
       "      <td>2.00</td>\n",
       "      <td>female</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Allison, Mr Hudson Joshua Creighton</th>\n",
       "      <td>3</td>\n",
       "      <td>1st</td>\n",
       "      <td>30.00</td>\n",
       "      <td>male</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Allison, Mrs Hudson JC (Bessie Waldo Daniels)</th>\n",
       "      <td>4</td>\n",
       "      <td>1st</td>\n",
       "      <td>25.00</td>\n",
       "      <td>female</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Allison, Master Hudson Trevor</th>\n",
       "      <td>5</td>\n",
       "      <td>1st</td>\n",
       "      <td>0.92</td>\n",
       "      <td>male</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                               ID PClass    Age     Sex  \\\n",
       "Name                                                                      \n",
       "Allen, Miss Elisabeth Walton                    1    1st  29.00  female   \n",
       "Allison, Miss Helen Loraine                     2    1st   2.00  female   \n",
       "Allison, Mr Hudson Joshua Creighton             3    1st  30.00    male   \n",
       "Allison, Mrs Hudson JC (Bessie Waldo Daniels)   4    1st  25.00  female   \n",
       "Allison, Master Hudson Trevor                   5    1st   0.92    male   \n",
       "\n",
       "                                               Survived  SexCode)  \n",
       "Name                                                               \n",
       "Allen, Miss Elisabeth Walton                          1         1  \n",
       "Allison, Miss Helen Loraine                           0         1  \n",
       "Allison, Mr Hudson Joshua Creighton                   0         0  \n",
       "Allison, Mrs Hudson JC (Bessie Waldo Daniels)         0         1  \n",
       "Allison, Master Hudson Trevor                         1         0  "
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "excel_titanic = pd.ExcelFile('data/Titanic.xls')\n",
    "print(\"Hojas: \", excel_titanic.sheet_names)\n",
    "\n",
    "df_titanic = excel_titanic.parse('Hoja1', names=['ID','Name','PClass','Age','Sex','Survived','SexCode)'], index_col=1)\n",
    "df_titanic.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=\"#7F000E\">  Lectura y escritura de archivos en formato JSON </font>\n",
    "\n",
    "La función `read_json()` permite leer un `DataFrame` a partir de un conjunto de datos en formato JSON. También acepta como parámetro un `String`. El formato del objeto JSON ha de ajustarse al del `DataFrame`, y puede ser indicado a través del parámetro `orient` que, en este caso, además de `columns` e `index`, puede tomar los valores `split`, `records`, `index`, `columns` y `values` ([documentación](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.read_json.html)). "
   ]
  },
  {
   "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>integer</th>\n",
       "      <th>datetime</th>\n",
       "      <th>category</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5</td>\n",
       "      <td>2015-01-01 00:00:00</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>5</td>\n",
       "      <td>2015-01-01 00:00:01</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>9</td>\n",
       "      <td>2015-01-01 00:00:02</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>6</td>\n",
       "      <td>2015-01-01 00:00:03</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>6</td>\n",
       "      <td>2015-01-01 00:00:04</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   integer            datetime  category\n",
       "0        5 2015-01-01 00:00:00         0\n",
       "1        5 2015-01-01 00:00:01         0\n",
       "2        9 2015-01-01 00:00:02         0\n",
       "3        6 2015-01-01 00:00:03         0\n",
       "4        6 2015-01-01 00:00:04         0"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "url = 'http://raw.githubusercontent.com/chrisalbon/simulated_datasets/master/data.json'\n",
    "df_json = pd.read_json(url, orient='records')\n",
    "df_json.head(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función `to_json()` permite exportar el `DataFrame` a un String con formato JSON. También admite el parámetro `orient`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'ID': {'Allen, Miss Elisabeth Walton': 1,\n",
       "  'Allison, Miss Helen Loraine': 2,\n",
       "  'Allison, Mr Hudson Joshua Creighton': 3,\n",
       "  'Allison, Mrs Hudson JC (Bessie Waldo Daniels)': 4,\n",
       "  'Allison, Master Hudson Trevor': 5},\n",
       " 'PClass': {'Allen, Miss Elisabeth Walton': '1st',\n",
       "  'Allison, Miss Helen Loraine': '1st',\n",
       "  'Allison, Mr Hudson Joshua Creighton': '1st',\n",
       "  'Allison, Mrs Hudson JC (Bessie Waldo Daniels)': '1st',\n",
       "  'Allison, Master Hudson Trevor': '1st'},\n",
       " 'Age': {'Allen, Miss Elisabeth Walton': 29.0,\n",
       "  'Allison, Miss Helen Loraine': 2.0,\n",
       "  'Allison, Mr Hudson Joshua Creighton': 30.0,\n",
       "  'Allison, Mrs Hudson JC (Bessie Waldo Daniels)': 25.0,\n",
       "  'Allison, Master Hudson Trevor': 0.92},\n",
       " 'Sex': {'Allen, Miss Elisabeth Walton': 'female',\n",
       "  'Allison, Miss Helen Loraine': 'female',\n",
       "  'Allison, Mr Hudson Joshua Creighton': 'male',\n",
       "  'Allison, Mrs Hudson JC (Bessie Waldo Daniels)': 'female',\n",
       "  'Allison, Master Hudson Trevor': 'male'},\n",
       " 'Survived': {'Allen, Miss Elisabeth Walton': 1,\n",
       "  'Allison, Miss Helen Loraine': 0,\n",
       "  'Allison, Mr Hudson Joshua Creighton': 0,\n",
       "  'Allison, Mrs Hudson JC (Bessie Waldo Daniels)': 0,\n",
       "  'Allison, Master Hudson Trevor': 1},\n",
       " 'SexCode)': {'Allen, Miss Elisabeth Walton': 1,\n",
       "  'Allison, Miss Helen Loraine': 1,\n",
       "  'Allison, Mr Hudson Joshua Creighton': 0,\n",
       "  'Allison, Mrs Hudson JC (Bessie Waldo Daniels)': 1,\n",
       "  'Allison, Master Hudson Trevor': 0}}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import json\n",
    "\n",
    "json_titanic = json.loads(df_titanic.head().to_json(orient='columns'))\n",
    "#json_titanic = json.loads(df_titanic.head().to_json(orient='split'))\n",
    "#json_titanic = json.loads(df_titanic.head(2).to_json(orient='records'))\n",
    "json_titanic\n",
    "\n",
    "#json_titanic = json.loads(df_titanic.head().to_json(orient='table'))\n",
    "#json_titanic['data'][1]['index']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=\"#7F000E\">  Lectura y escritura sobre bases de datos SQL</font>\n",
    "\n",
    "Pandas proporciona métodos para leer y escribir `DataFrame` en bases de datos SQL. En todos ellos es necesario proporcionar una conexión a la base de datos. \n",
    "\n",
    "El método `read_sql_table` lee una tabla de una base de datos (necesita una conexión) y la almacena en un `DataFrame`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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>Apellido</th>\n",
       "      <th>Nombre</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Felix</td>\n",
       "      <td>Joao</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Nadal</td>\n",
       "      <td>Rafael</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Gasol</td>\n",
       "      <td>Pau</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Godín</td>\n",
       "      <td>Diego</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Llul</td>\n",
       "      <td>Sergio</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Ñíguez</td>\n",
       "      <td>Saúl</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Apellido  Nombre\n",
       "id                 \n",
       "1     Felix    Joao\n",
       "2     Nadal  Rafael\n",
       "3     Gasol     Pau\n",
       "4     Godín   Diego\n",
       "5      Llul  Sergio\n",
       "6    Ñíguez    Saúl"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sqlalchemy import create_engine\n",
    "\n",
    "# Crea una conexión a una base de datos sqlite\n",
    "engine = create_engine('sqlite:///data/deportes.db')   \n",
    "\n",
    "# Lee la tabla\n",
    "df_persona = pd.read_sql_table(\"persona\", engine, index_col=\"id\")\n",
    "df_persona"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función `read_sql_query` permite hacer consultas sobre la base de datos y almacenar el resultado en un _DataFrame_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "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>Apellido</th>\n",
       "      <th>Nombre</th>\n",
       "      <th>Equipo</th>\n",
       "      <th>Deporte</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Felix</td>\n",
       "      <td>Joao</td>\n",
       "      <td>At. Madrid</td>\n",
       "      <td>Fútbol</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Gasol</td>\n",
       "      <td>Pau</td>\n",
       "      <td>Porland</td>\n",
       "      <td>Baloncesto</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Godín</td>\n",
       "      <td>Diego</td>\n",
       "      <td>Int. Milán</td>\n",
       "      <td>Fútbol</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Llul</td>\n",
       "      <td>Sergio</td>\n",
       "      <td>R. Madrid</td>\n",
       "      <td>Baloncesto</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Apellido  Nombre      Equipo     Deporte\n",
       "id                                         \n",
       "1     Felix    Joao  At. Madrid      Fútbol\n",
       "3     Gasol     Pau     Porland  Baloncesto\n",
       "4     Godín   Diego  Int. Milán      Fútbol\n",
       "5      Llul  Sergio   R. Madrid  Baloncesto"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "query = r'SELECT p.ID, p.Apellido, p.Nombre, e.Equipo, e.Deporte FROM persona p, equipo e WHERE p.ID == e.ID'\n",
    "\n",
    "df_persona_equipo = pd.read_sql_query(query, engine, index_col=\"id\")\n",
    "df_persona_equipo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    \n",
    "<i class=\"fa fa-info-circle\" aria-hidden=\"true\"></i> La función `read_sql` llama a una u otra según los parámetros.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "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>Apellido</th>\n",
       "      <th>Nombre</th>\n",
       "      <th>Equipo</th>\n",
       "      <th>Deporte</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Felix</td>\n",
       "      <td>Joao</td>\n",
       "      <td>At. Madrid</td>\n",
       "      <td>Fútbol</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Gasol</td>\n",
       "      <td>Pau</td>\n",
       "      <td>Porland</td>\n",
       "      <td>Baloncesto</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Godín</td>\n",
       "      <td>Diego</td>\n",
       "      <td>Int. Milán</td>\n",
       "      <td>Fútbol</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Llul</td>\n",
       "      <td>Sergio</td>\n",
       "      <td>R. Madrid</td>\n",
       "      <td>Baloncesto</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Apellido  Nombre      Equipo     Deporte\n",
       "id                                         \n",
       "1     Felix    Joao  At. Madrid      Fútbol\n",
       "3     Gasol     Pau     Porland  Baloncesto\n",
       "4     Godín   Diego  Int. Milán      Fútbol\n",
       "5      Llul  Sergio   R. Madrid  Baloncesto"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#pd.read_sql(\"persona\", engine, index_col=\"id\")\n",
    "pd.read_sql(query, engine, index_col=\"id\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    \n",
    "<i class=\"fa fa-info-circle\" aria-hidden=\"true\"></i> Existen módulos que permiten trabajar directamente con algunos tipos de bases de datos.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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>Apellido</th>\n",
       "      <th>Nombre</th>\n",
       "      <th>Equipo</th>\n",
       "      <th>Deporte</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Felix</td>\n",
       "      <td>Joao</td>\n",
       "      <td>At. Madrid</td>\n",
       "      <td>Fútbol</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Gasol</td>\n",
       "      <td>Pau</td>\n",
       "      <td>Porland</td>\n",
       "      <td>Baloncesto</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Godín</td>\n",
       "      <td>Diego</td>\n",
       "      <td>Int. Milán</td>\n",
       "      <td>Fútbol</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Llul</td>\n",
       "      <td>Sergio</td>\n",
       "      <td>R. Madrid</td>\n",
       "      <td>Baloncesto</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Apellido  Nombre      Equipo     Deporte\n",
       "id                                         \n",
       "1     Felix    Joao  At. Madrid      Fútbol\n",
       "3     Gasol     Pau     Porland  Baloncesto\n",
       "4     Godín   Diego  Int. Milán      Fútbol\n",
       "5      Llul  Sergio   R. Madrid  Baloncesto"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import sqlite3 # Bases de datos sqlite\n",
    "conn = sqlite3.connect(\"data/deportes.db\")\n",
    "df_persona_equipo = pd.read_sql_query(query, conn, index_col=\"id\")\n",
    "conn.close()\n",
    "\n",
    "df_persona_equipo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función `to_sql` permite almacenar `DataFrame` en tablas SQL."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "engine = create_engine('sqlite:///data/titanic.db')    # Lee de una base de datos sqlite\n",
    "\n",
    "#df_titanic.to_sql('titanic', con=engine) # Da error si el archivo existe ya."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: right\">\n",
    "<a href=\"#indice\"><font size=5><i class=\"fa fa-arrow-circle-up\" aria-hidden=\"true\" style=\"color:#7F000E\"></i></font></a>\n",
    "</div>\n",
    "\n",
    "---\n",
    "\n",
    "<a id=\"section43\"></a> \n",
    "## <font color=\"#7F000E\">Construcción de DataFrames </font>\n",
    "<br>\n",
    "\n",
    "Existen _múltiples formas_ de crear un objeto `DataFrame` a partir de otros objetos como colecciones, diccionarios, series, etc. Éstas son útiles, por ejemplo,  a la hora de construir el `DataFrame` a partir de datos procedentes de fuentes heterogéneas. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=\"#7F000E\"> Construcción a partir de una lista o colección</font>\n",
    "\n",
    "Se hace mediante el método `DataFrame.from_records()`. Cada elemento de la lista representa una fila. Si no se proporcionan las columnas e índice, en ambos casos se utilizan enteros."
   ]
  },
  {
   "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>Nombre</th>\n",
       "      <th>Precio</th>\n",
       "      <th>Producto</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Álvaro</td>\n",
       "      <td>22.5</td>\n",
       "      <td>Queso</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Benito</td>\n",
       "      <td>14.5</td>\n",
       "      <td>Vino</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 2</th>\n",
       "      <td>Fernando</td>\n",
       "      <td>50.0</td>\n",
       "      <td>Jamón</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Martín</td>\n",
       "      <td>20.0</td>\n",
       "      <td>Aceite</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Hernán</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Azafrán</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Nombre  Precio Producto\n",
       "Tienda 1    Álvaro    22.5    Queso\n",
       "Tienda 1    Benito    14.5     Vino\n",
       "Tienda 2  Fernando    50.0    Jamón\n",
       "Tienda 3    Martín    20.0   Aceite\n",
       "Tienda 3    Hernán     NaN  Azafrán"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "ventas = [('Álvaro', 22.5, 'Queso'),\n",
    "         ('Benito', 14.5, 'Vino'),\n",
    "         ('Fernando', 50, 'Jamón'),\n",
    "         ('Martín', 20.0, 'Aceite'),\n",
    "         ('Hernán',np.NaN, 'Azafrán')]\n",
    "\n",
    "columnas = ['Nombre', 'Precio', 'Producto']\n",
    "indice =['Tienda 1', 'Tienda 1', 'Tienda 2', 'Tienda 3','Tienda 3']\n",
    "\n",
    "df_ventas = pd.DataFrame.from_records(ventas, columns=columnas, index=indice)\n",
    "df_ventas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este método se encapsula dentro del constructor general."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "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>Nombre</th>\n",
       "      <th>Precio</th>\n",
       "      <th>Producto</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Álvaro</td>\n",
       "      <td>22.5</td>\n",
       "      <td>Queso</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Benito</td>\n",
       "      <td>14.5</td>\n",
       "      <td>Vino</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 2</th>\n",
       "      <td>Fernando</td>\n",
       "      <td>50.0</td>\n",
       "      <td>Jamón</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Martín</td>\n",
       "      <td>20.0</td>\n",
       "      <td>Aceite</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Hernán</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Azafrán</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Nombre  Precio Producto\n",
       "Tienda 1    Álvaro    22.5    Queso\n",
       "Tienda 1    Benito    14.5     Vino\n",
       "Tienda 2  Fernando    50.0    Jamón\n",
       "Tienda 3    Martín    20.0   Aceite\n",
       "Tienda 3    Hernán     NaN  Azafrán"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ventas = [('Álvaro', 22.5, 'Queso'),\n",
    "         ('Benito', 14.5, 'Vino'),\n",
    "         ('Fernando', 50, 'Jamón'),\n",
    "         ('Martín', 20.0, 'Aceite'),\n",
    "         ('Hernán',np.NaN, 'Azafrán')]\n",
    "\n",
    "columnas = ['Nombre', 'Precio', 'Producto']\n",
    "indice =['Tienda 1', 'Tienda 1', 'Tienda 2', 'Tienda 3','Tienda 3']\n",
    "\n",
    "df_ventas = pd.DataFrame(ventas, index=indice, columns=columnas)\n",
    "df_ventas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=\"#7F000E\"> Construcción a partir de diccionarios </font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función `DataFrame.from_dict()`  construye un `DataFrame` a partir de un diccionario. Mediante el parámetro `orient`, permite especificar si las claves corresponden a las columnas o al índice, es decir, a las filas. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Nombre</th>\n",
       "      <td>Álvaro</td>\n",
       "      <td>Benito</td>\n",
       "      <td>Fernando</td>\n",
       "      <td>Martín</td>\n",
       "      <td>Hernán</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Precio</th>\n",
       "      <td>22.5</td>\n",
       "      <td>14.5</td>\n",
       "      <td>50</td>\n",
       "      <td>20</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Producto</th>\n",
       "      <td>Queso</td>\n",
       "      <td>Vino</td>\n",
       "      <td>Jamón</td>\n",
       "      <td>Aceite</td>\n",
       "      <td>Azafrán</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               0       1         2       3        4\n",
       "Nombre    Álvaro  Benito  Fernando  Martín   Hernán\n",
       "Precio      22.5    14.5        50      20      NaN\n",
       "Producto   Queso    Vino     Jamón  Aceite  Azafrán"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ventas = {'Nombre': ['Álvaro', 'Benito', 'Fernando','Martín','Hernán'],\n",
    "          'Precio': [22.5, 14.5, 50.0, 20.0, np.NaN],\n",
    "          'Producto':['Queso', 'Vino', 'Jamón', 'Aceite','Azafrán']}\n",
    "\n",
    "df_ventas = pd.DataFrame.from_dict(ventas, orient=\"index\")\n",
    "#df_ventas = pd.DataFrame.from_dict(ventas, orient=\"columns\")\n",
    "df_ventas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "\n",
    "<i class=\"fa fa-info-circle\" aria-hidden=\"true\"></i>\n",
    "De igual manera, el método `to_dict` permite exportar un _DataFrame_ a un diccionario.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El constructor acepta directamente un diccionario con el formato anterior (es equivalente a `from_dict(orient=\"columns\")`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "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>Nombre</th>\n",
       "      <th>Precio</th>\n",
       "      <th>Producto</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Álvaro</td>\n",
       "      <td>22.5</td>\n",
       "      <td>Queso</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Benito</td>\n",
       "      <td>14.5</td>\n",
       "      <td>Vino</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 2</th>\n",
       "      <td>Fernando</td>\n",
       "      <td>50.0</td>\n",
       "      <td>Jamón</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Martín</td>\n",
       "      <td>20.0</td>\n",
       "      <td>Aceite</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Hernán</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Azafrán</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Nombre  Precio Producto\n",
       "Tienda 1    Álvaro    22.5    Queso\n",
       "Tienda 1    Benito    14.5     Vino\n",
       "Tienda 2  Fernando    50.0    Jamón\n",
       "Tienda 3    Martín    20.0   Aceite\n",
       "Tienda 3    Hernán     NaN  Azafrán"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_compras = pd.DataFrame(ventas, index=indice, columns=columnas)\n",
    "df_compras"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aunque lo ___recomendable es utilizar las dos funciones descritas anteriormente___, la construcción de `DataFrame` es muy versátil, y acepta multitud de opciones que, en alguna ocasión, pueden ser útiles. En este ejemplo, cada uno de los diccionarios representa una fila del `DataFrame`. Las claves representan el nombre de la columna, y los valores el valor correspondiente de la columna para la fila. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "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>Nombre</th>\n",
       "      <th>Producto</th>\n",
       "      <th>Precio</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Álvaro</td>\n",
       "      <td>Queso</td>\n",
       "      <td>22.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Benito</td>\n",
       "      <td>Vino</td>\n",
       "      <td>14.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 2</th>\n",
       "      <td>Fernando</td>\n",
       "      <td>Jamón</td>\n",
       "      <td>50.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Martín</td>\n",
       "      <td>Aceite</td>\n",
       "      <td>20.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Hernán</td>\n",
       "      <td>Azafrán</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Nombre Producto  Precio\n",
       "Tienda 1    Álvaro    Queso    22.5\n",
       "Tienda 1    Benito     Vino    14.5\n",
       "Tienda 2  Fernando    Jamón    50.0\n",
       "Tienda 3    Martín   Aceite    20.0\n",
       "Tienda 3    Hernán  Azafrán     NaN"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compra_1 =  {'Nombre': 'Álvaro', 'Producto': 'Queso', 'Precio': 22.50}\n",
    "compra_2 =  {'Nombre': 'Benito', 'Producto': 'Vino', 'Precio': 14.50}\n",
    "compra_3 =  {'Nombre': 'Fernando','Producto': 'Jamón', 'Precio': 50.00}\n",
    "compra_4 =  {'Nombre': 'Martín', 'Producto': 'Aceite', 'Precio': 20.00}\n",
    "compra_5 =  {'Nombre': 'Hernán', 'Producto': 'Azafrán'} # Deja a NaN los campos para los que no se proporciona valor.\n",
    "\n",
    "df_compras = pd.DataFrame([compra_1, compra_2, compra_3, compra_4, compra_5], \n",
    "                          index=['Tienda 1', 'Tienda 1', 'Tienda 2', 'Tienda 3', 'Tienda 3'])\n",
    "df_compras"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: right\">\n",
    "<a href=\"#indice\"><font size=5><i class=\"fa fa-arrow-circle-up\" aria-hidden=\"true\" style=\"color:#7F000E\"></i></font></a>\n",
    "</div>\n",
    "\n",
    "---\n",
    "\n",
    "\n",
    "<a id=\"section44\"></a> \n",
    "## <font color=\"#7F000E\"> Acceso a elementos </font>\n",
    "<br>\n",
    "\n",
    "Para ilustrar el acceso a los elementos, se utilizará este  `DataFrame`, descrito anteriormente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "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>Nombre</th>\n",
       "      <th>Producto</th>\n",
       "      <th>Compra</th>\n",
       "      <th>Venta</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Álvaro</td>\n",
       "      <td>Queso</td>\n",
       "      <td>15.0</td>\n",
       "      <td>22.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Benito</td>\n",
       "      <td>Vino</td>\n",
       "      <td>10.0</td>\n",
       "      <td>14.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 2</th>\n",
       "      <td>Fernando</td>\n",
       "      <td>Jamón</td>\n",
       "      <td>35.0</td>\n",
       "      <td>50.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Martín</td>\n",
       "      <td>Aceite</td>\n",
       "      <td>12.0</td>\n",
       "      <td>20.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Hernán</td>\n",
       "      <td>Azafrán</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Nombre Producto  Compra  Venta\n",
       "Tienda 1    Álvaro    Queso    15.0   22.5\n",
       "Tienda 1    Benito     Vino    10.0   14.5\n",
       "Tienda 2  Fernando    Jamón    35.0   50.0\n",
       "Tienda 3    Martín   Aceite    12.0   20.0\n",
       "Tienda 3    Hernán  Azafrán     NaN    NaN"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ventas = [('Álvaro', 'Queso', 15.0, 22.5),\n",
    "         ('Benito',  'Vino', 10.0, 14.5),\n",
    "         ('Fernando', 'Jamón', 35, 50),\n",
    "         ('Martín',  'Aceite', 12, 20),\n",
    "         ('Hernán', 'Azafrán', np.NaN, np.NaN)]\n",
    "\n",
    "columnas = ['Nombre', 'Producto', 'Compra', 'Venta']\n",
    "indice =['Tienda 1', 'Tienda 1', 'Tienda 2', 'Tienda 3','Tienda 3']\n",
    "\n",
    "df = pd.DataFrame(ventas, index=indice, columns=columnas)\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  <font color=\"#7F000E\"> Acceso a las filas de un DataFrame </font>\n",
    "\n",
    "Del mismo modo que en los objetos `Series`, el acceso a las filas del `DataFrame` se hace mediante los métodos `loc[]` e `iloc[]` (también `at[]` e `iat[]`). Si el índice corresponde a una sola fila, estos devuelven un objeto de tipo `Series`; sin embargo, si el índice corresponde a varias filas, devuelven otro `Dataframe`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nombre      Fernando\n",
      "Producto       Jamón\n",
      "Compra            35\n",
      "Venta             50\n",
      "Name: Tienda 2, dtype: object\n",
      "<class 'pandas.core.series.Series'> \n",
      "\n",
      "          Nombre Producto  Compra  Venta\n",
      "Tienda 1  Álvaro    Queso    15.0   22.5\n",
      "Tienda 1  Benito     Vino    10.0   14.5\n",
      "<class 'pandas.core.frame.DataFrame'> \n",
      "\n",
      "Nombre      Álvaro\n",
      "Producto     Queso\n",
      "Compra          15\n",
      "Venta         22.5\n",
      "Name: Tienda 1, dtype: object\n",
      "<class 'pandas.core.series.Series'>\n"
     ]
    }
   ],
   "source": [
    "fila = df.loc['Tienda 2']               # Accede a la fila con índice 'Tienda 2'\n",
    "print(fila)\n",
    "print(type(fila),'\\n')                  # Imprime el tipo.\n",
    "\n",
    "filas = df.loc['Tienda 1']              # Accede a las filas con índice 'Tienda 1'\n",
    "print(filas)\n",
    "print(type(filas),'\\n')\n",
    "\n",
    "filas = df.iloc[0]                      # Accede a la fila en la posición 0.\n",
    "print(filas)\n",
    "print(type(filas))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La funcionalidad de ambos métodos también es similar a la descrita en el caso de las `Series`. Es decir, aceptan indexación a partir de colecciones del tipo del índice o booleanos (en el caso de `loc[]`), y de enteros (en el caso de `iloc[]`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "            Nombre Producto  Compra  Venta\n",
      "Tienda 2  Fernando    Jamón    35.0   50.0\n",
      "Tienda 1    Álvaro    Queso    15.0   22.5\n",
      "Tienda 1    Benito     Vino    10.0   14.5\n",
      "\n",
      "            Nombre Producto  Compra  Venta\n",
      "Tienda 2  Fernando    Jamón    35.0   50.0\n",
      "Tienda 3    Martín   Aceite    12.0   20.0\n",
      "Tienda 3    Hernán  Azafrán     NaN    NaN\n",
      "\n",
      "          Nombre Producto  Compra  Venta\n",
      "Tienda 1  Álvaro    Queso    15.0   22.5\n",
      "Tienda 3  Martín   Aceite    12.0   20.0\n"
     ]
    }
   ],
   "source": [
    "print(df.loc[['Tienda 2','Tienda 1']])      \n",
    "print()\n",
    "\n",
    "print(df.loc['Tienda 2':])\n",
    "print()\n",
    "\n",
    "print(df.iloc[[0,3]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    \n",
    "<i class=\"fa fa-info-circle\" aria-hidden=\"true\"></i> Los índices de cada tipo ofrecen funcionalidades específicas. Por ejemplo, en el caso de índices alfanuméricos, se puede hacer _slicing_ lexicográfico sin necesidad de especificar los valores concretos de los elementos.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "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>ID</th>\n",
       "      <th>PClass</th>\n",
       "      <th>Age</th>\n",
       "      <th>Sex</th>\n",
       "      <th>Survived</th>\n",
       "      <th>SexCode)</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Name</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>Ahlin, Mrs Johanna Persdotter</th>\n",
       "      <td>613</td>\n",
       "      <td>3rd</td>\n",
       "      <td>40.00</td>\n",
       "      <td>female</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Ahmed, Mr Ali</th>\n",
       "      <td>614</td>\n",
       "      <td>3rd</td>\n",
       "      <td>24.00</td>\n",
       "      <td>male</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Aijo-Nirva, Mr Isak</th>\n",
       "      <td>615</td>\n",
       "      <td>3rd</td>\n",
       "      <td>41.00</td>\n",
       "      <td>male</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Aks, Master Philip</th>\n",
       "      <td>617</td>\n",
       "      <td>3rd</td>\n",
       "      <td>0.83</td>\n",
       "      <td>male</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Aks, Mrs Sam (Leah Rosen)</th>\n",
       "      <td>616</td>\n",
       "      <td>3rd</td>\n",
       "      <td>18.00</td>\n",
       "      <td>female</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                ID PClass    Age     Sex  Survived  SexCode)\n",
       "Name                                                                        \n",
       "Ahlin, Mrs Johanna Persdotter  613    3rd  40.00  female         0         1\n",
       "Ahmed, Mr Ali                  614    3rd  24.00    male         0         0\n",
       "Aijo-Nirva, Mr Isak            615    3rd  41.00    male         0         0\n",
       "Aks, Master Philip             617    3rd   0.83    male         1         0\n",
       "Aks, Mrs Sam (Leah Rosen)      616    3rd  18.00  female         1         1"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_titanic = df_titanic.sort_index()\n",
    "df_titanic.loc['Ae':'Al']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El método `DataFrame.iterrows()` permite iterar sobre las filas de un _DataFrame_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tienda 1 --> Queso\n",
      "Tienda 1 --> Vino\n",
      "Tienda 2 --> Jamón\n",
      "Tienda 3 --> Aceite\n",
      "Tienda 3 --> Azafrán\n"
     ]
    }
   ],
   "source": [
    "for idx, row in df.iterrows():           \n",
    "    print(idx, end=' --> ')                        \n",
    "    print(row['Producto'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El método `DataFrame.iteritems()` itera sobre las columnas.  Devuelve tuplas en las que el primer elemento es el nombre y el segundo la serie correspondiente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Nombre', Tienda 1      Álvaro\n",
      "Tienda 1      Benito\n",
      "Tienda 2    Fernando\n",
      "Tienda 3      Martín\n",
      "Tienda 3      Hernán\n",
      "Name: Nombre, dtype: object)\n",
      "---->\n",
      "('Producto', Tienda 1      Queso\n",
      "Tienda 1       Vino\n",
      "Tienda 2      Jamón\n",
      "Tienda 3     Aceite\n",
      "Tienda 3    Azafrán\n",
      "Name: Producto, dtype: object)\n",
      "---->\n",
      "('Compra', Tienda 1    15.0\n",
      "Tienda 1    10.0\n",
      "Tienda 2    35.0\n",
      "Tienda 3    12.0\n",
      "Tienda 3     NaN\n",
      "Name: Compra, dtype: float64)\n",
      "---->\n",
      "('Venta', Tienda 1    22.5\n",
      "Tienda 1    14.5\n",
      "Tienda 2    50.0\n",
      "Tienda 3    20.0\n",
      "Tienda 3     NaN\n",
      "Name: Venta, dtype: float64)\n",
      "---->\n"
     ]
    }
   ],
   "source": [
    "for row in df.iteritems(): \n",
    "    print(row)\n",
    "    print('---->')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "###  <font color=\"#7F000E\"> Acceso a las columnas de un DataFrame </font>\n",
    "\n",
    "Se puede acceder a los elementos de una columna (o varias) mediante el operador `[]`. También se devuelve un objeto de tipo `Series` o `DataFrame` según se accedan, respectivamente, una o varias columnas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Tienda 1      Queso\n",
       "Tienda 1       Vino\n",
       "Tienda 2      Jamón\n",
       "Tienda 3     Aceite\n",
       "Tienda 3    Azafrán\n",
       "Name: Producto, dtype: object"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "productos = df['Producto']\n",
    "productos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por defecto, el acceso a una columna devuelve una serie. Si se utilizan dobles corchetes, devuelve un `DataFrame`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "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>Producto</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Queso</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Vino</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 2</th>\n",
       "      <td>Jamón</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Aceite</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Azafrán</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         Producto\n",
       "Tienda 1    Queso\n",
       "Tienda 1     Vino\n",
       "Tienda 2    Jamón\n",
       "Tienda 3   Aceite\n",
       "Tienda 3  Azafrán"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "productos = df[['Producto']]\n",
    "productos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "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>Producto</th>\n",
       "      <th>Compra</th>\n",
       "      <th>Venta</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Queso</td>\n",
       "      <td>15.0</td>\n",
       "      <td>22.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Vino</td>\n",
       "      <td>10.0</td>\n",
       "      <td>14.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 2</th>\n",
       "      <td>Jamón</td>\n",
       "      <td>35.0</td>\n",
       "      <td>50.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Aceite</td>\n",
       "      <td>12.0</td>\n",
       "      <td>20.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Azafrán</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         Producto  Compra  Venta\n",
       "Tienda 1    Queso    15.0   22.5\n",
       "Tienda 1     Vino    10.0   14.5\n",
       "Tienda 2    Jamón    35.0   50.0\n",
       "Tienda 3   Aceite    12.0   20.0\n",
       "Tienda 3  Azafrán     NaN    NaN"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "columnas = ['Producto','Compra','Venta']\n",
    "productos_coste = df[columnas]\n",
    "#productos_coste = df[['Producto','Compra','Venta']]   # Equivalente \n",
    "productos_coste"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-danger\">\n",
    "    \n",
    "<i class=\"fa fa-exclamation-triangle\" aria-hidden=\"true\"></i>\n",
    "Un error muy común a la hora de acceder a varias columnas consiste en utilizar como argumentos los nombres de las columnas separados por comas, en lugar de ___una colección___ con los nombres de las columnas.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# productos_coste = df['Producto','Compra','Venta']   # Devuelve error."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las columnas puden accederse individualmente como un campo del objeto `DataFrame`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tienda 1      Queso\n",
      "Tienda 1       Vino\n",
      "Tienda 2      Jamón\n",
      "Tienda 3     Aceite\n",
      "Tienda 3    Azafrán\n",
      "Name: Producto, dtype: object\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "pandas.core.series.Series"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "productos = df.Producto          # Es equivalente a  df['Producto']\n",
    "print(productos)\n",
    "type(df.Producto)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "\n",
    "<i class=\"fa fa-exclamation-circle\" aria-hidden=\"true\"></i>\n",
    "Por legibilidad del código, es preferible no hacerlo.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  <font color=\"#7F000E\"> Acceso a las columnas en función de su tipo </font>\n",
    "\n",
    "En muchos casos, es interesante seleccionar las columnas cuyos elementos son de un tipo determinado.  Por ejemplo, la siguiente celda accede a las columnas numéricas. "
   ]
  },
  {
   "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>Compra</th>\n",
       "      <th>Venta</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>15.0</td>\n",
       "      <td>22.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>10.0</td>\n",
       "      <td>14.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 2</th>\n",
       "      <td>35.0</td>\n",
       "      <td>50.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>12.0</td>\n",
       "      <td>20.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          Compra  Venta\n",
       "Tienda 1    15.0   22.5\n",
       "Tienda 1    10.0   14.5\n",
       "Tienda 2    35.0   50.0\n",
       "Tienda 3    12.0   20.0\n",
       "Tienda 3     NaN    NaN"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df._get_numeric_data()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función `DataFrame.select_dtypes()` ofrece mucha versatilidad, y permite determinar las columnas de qué tipos se incluyen (parámetro `include`) y qué tipos se excluyen (parámetro `exclude`). Se pueden utilizar tanto Strings como tipos de datos implementados en _Numpy_. "
   ]
  },
  {
   "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>ID</th>\n",
       "      <th>PClass</th>\n",
       "      <th>Age</th>\n",
       "      <th>Sex</th>\n",
       "      <th>Survived</th>\n",
       "      <th>SexCode)</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Name</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>Abbing, Mr Anthony</th>\n",
       "      <td>603</td>\n",
       "      <td>3rd</td>\n",
       "      <td>42.0</td>\n",
       "      <td>male</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Abbott, Master Eugene Joseph</th>\n",
       "      <td>604</td>\n",
       "      <td>3rd</td>\n",
       "      <td>13.0</td>\n",
       "      <td>male</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Abbott, Mr Rossmore Edward</th>\n",
       "      <td>605</td>\n",
       "      <td>3rd</td>\n",
       "      <td>16.0</td>\n",
       "      <td>male</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Abbott, Mrs Stanton (Rosa)</th>\n",
       "      <td>606</td>\n",
       "      <td>3rd</td>\n",
       "      <td>35.0</td>\n",
       "      <td>female</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Abelseth, Miss Anna Karen</th>\n",
       "      <td>607</td>\n",
       "      <td>3rd</td>\n",
       "      <td>16.0</td>\n",
       "      <td>female</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                               ID PClass   Age     Sex  Survived  SexCode)\n",
       "Name                                                                      \n",
       "Abbing, Mr Anthony            603    3rd  42.0    male         0         0\n",
       "Abbott, Master Eugene Joseph  604    3rd  13.0    male         0         0\n",
       "Abbott, Mr Rossmore Edward    605    3rd  16.0    male         0         0\n",
       "Abbott, Mrs Stanton (Rosa)    606    3rd  35.0  female         1         1\n",
       "Abelseth, Miss Anna Karen     607    3rd  16.0  female         1         1"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "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>ID</th>\n",
       "      <th>Survived</th>\n",
       "      <th>SexCode)</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Name</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Abbing, Mr Anthony</th>\n",
       "      <td>603</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Abbott, Master Eugene Joseph</th>\n",
       "      <td>604</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Abbott, Mr Rossmore Edward</th>\n",
       "      <td>605</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Abbott, Mrs Stanton (Rosa)</th>\n",
       "      <td>606</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Abelseth, Miss Anna Karen</th>\n",
       "      <td>607</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                               ID  Survived  SexCode)\n",
       "Name                                                 \n",
       "Abbing, Mr Anthony            603         0         0\n",
       "Abbott, Master Eugene Joseph  604         0         0\n",
       "Abbott, Mr Rossmore Edward    605         0         0\n",
       "Abbott, Mrs Stanton (Rosa)    606         1         1\n",
       "Abelseth, Miss Anna Karen     607         1         1"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "display(df_titanic.head(5))\n",
    "print()\n",
    "\n",
    "df_titanic.select_dtypes(include='number', exclude=np.float64).head(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "    \n",
    "<i class=\"fa fa-exclamation-circle\" aria-hidden=\"true\"></i>\n",
    "__Importante__: Hay un mundo en relación a los tipos de datos en _Numpy_, pero para el usuario de _Pandas_ o las librerías que se verán en el curso (para la inmensa mayoría de los profesionales) raramente se ha de recurrir a esta información [(documentación)](https://docs.scipy.org/doc/numpy/reference/arrays.scalars.html).\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### <font color=\"#7F000E\"> Acceso a elementos del DataFrame. </font>\n",
    "\n",
    "Con `loc` se puede acceder también a los elementos dados el valor (o valores) de su índice y columna. No se recomienda utilizar la segunda de las alternativas que se proponen a continuación, ya que puede dar lugar a comportamientos inesperados (particularmente en escrituras)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tienda 2    Jamón\n",
      "Tienda 1    Queso\n",
      "Tienda 1     Vino\n",
      "Name: Producto, dtype: object\n",
      "\n",
      "Tienda 2    Jamón\n",
      "Tienda 1    Queso\n",
      "Tienda 1     Vino\n",
      "Name: Producto, dtype: object\n",
      "\n",
      "         Producto  Compra  Venta\n",
      "Tienda 2    Jamón    35.0   50.0\n",
      "Tienda 1    Queso    15.0   22.5\n",
      "Tienda 1     Vino    10.0   14.5\n",
      "\n",
      "            Nombre Producto\n",
      "Tienda 1    Álvaro    Queso\n",
      "Tienda 1    Benito     Vino\n",
      "Tienda 2  Fernando    Jamón\n"
     ]
    }
   ],
   "source": [
    "print(df.loc[['Tienda 2','Tienda 1'],'Producto'])\n",
    "print()\n",
    "\n",
    "print(df.loc[['Tienda 2','Tienda 1']]['Producto'])\n",
    "print()\n",
    "\n",
    "print(df.loc[['Tienda 2','Tienda 1'],['Producto','Compra','Venta']])\n",
    "print()\n",
    "\n",
    "print(df.iloc[0:3,0:2]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "\n",
    "<i class=\"fa fa-info-circle\" aria-hidden=\"true\"></i> Como se comentó anteriormente, el método `at` es equivalente a `loc`, (e `iat` a `iloc`) con la salvedad de que `at` e `iat` __solamente aceptan escalares como índice__. Debido a esto, también son más eficientes. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tienda 1    Queso\n",
      "Tienda 1     Vino\n",
      "Name: Producto, dtype: object \n",
      "\n",
      "Jamón\n"
     ]
    }
   ],
   "source": [
    "fila = df.at['Tienda 1','Producto']            \n",
    "print(fila,'\\n')\n",
    "\n",
    "fila = df.iat[2,1]            \n",
    "print(fila)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### <font color=\"#7F000E\"> Escritura en elementos del DataFrame. </font>\n",
    "\n",
    "El acceso de para escritura es similar del acceso para lectura. Cuando se escriben varias posiciones, las dimensiones de los conjuntos de elementos a ambos lados de la asignación han de ser similares (salvo en el caso en que se asignen escalares)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "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>Nombre</th>\n",
       "      <th>Producto</th>\n",
       "      <th>Compra</th>\n",
       "      <th>Venta</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Álvaro</td>\n",
       "      <td>Queso</td>\n",
       "      <td>15.0</td>\n",
       "      <td>22.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Benito</td>\n",
       "      <td>Vino</td>\n",
       "      <td>10.0</td>\n",
       "      <td>14.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 2</th>\n",
       "      <td>Fernando</td>\n",
       "      <td>Jamón</td>\n",
       "      <td>35.0</td>\n",
       "      <td>50.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Martín</td>\n",
       "      <td>Aceite</td>\n",
       "      <td>12.0</td>\n",
       "      <td>20.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Hernán</td>\n",
       "      <td>Azafrán</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Nombre Producto  Compra  Venta\n",
       "Tienda 1    Álvaro    Queso    15.0   22.5\n",
       "Tienda 1    Benito     Vino    10.0   14.5\n",
       "Tienda 2  Fernando    Jamón    35.0   50.0\n",
       "Tienda 3    Martín   Aceite    12.0   20.0\n",
       "Tienda 3    Hernán  Azafrán     NaN    NaN"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este código asigna un escalar a varias posiciones."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "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>Nombre</th>\n",
       "      <th>Producto</th>\n",
       "      <th>Compra</th>\n",
       "      <th>Venta</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Álvaro</td>\n",
       "      <td>Queso</td>\n",
       "      <td>15.0</td>\n",
       "      <td>100.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Benito</td>\n",
       "      <td>Vino</td>\n",
       "      <td>10.0</td>\n",
       "      <td>100.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 2</th>\n",
       "      <td>Fernando</td>\n",
       "      <td>Jamón</td>\n",
       "      <td>35.0</td>\n",
       "      <td>50.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Martín</td>\n",
       "      <td>Aceite</td>\n",
       "      <td>12.0</td>\n",
       "      <td>100.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Hernán</td>\n",
       "      <td>Azafrán</td>\n",
       "      <td>NaN</td>\n",
       "      <td>100.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Nombre Producto  Compra  Venta\n",
       "Tienda 1    Álvaro    Queso    15.0  100.0\n",
       "Tienda 1    Benito     Vino    10.0  100.0\n",
       "Tienda 2  Fernando    Jamón    35.0   50.0\n",
       "Tienda 3    Martín   Aceite    12.0  100.0\n",
       "Tienda 3    Hernán  Azafrán     NaN  100.0"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.loc[['Tienda 1','Tienda 3'],'Venta']=100\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Restaura los valores una colección de valores (los tamaños de las estructuras de datos a izquierda y derecha de la asignación deben coincidir)."
   ]
  },
  {
   "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>Nombre</th>\n",
       "      <th>Producto</th>\n",
       "      <th>Compra</th>\n",
       "      <th>Venta</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Álvaro</td>\n",
       "      <td>Queso</td>\n",
       "      <td>15.0</td>\n",
       "      <td>22.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Benito</td>\n",
       "      <td>Vino</td>\n",
       "      <td>10.0</td>\n",
       "      <td>14.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 2</th>\n",
       "      <td>Fernando</td>\n",
       "      <td>Jamón</td>\n",
       "      <td>35.0</td>\n",
       "      <td>50.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Martín</td>\n",
       "      <td>Aceite</td>\n",
       "      <td>12.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Hernán</td>\n",
       "      <td>Azafrán</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Nombre Producto  Compra  Venta\n",
       "Tienda 1    Álvaro    Queso    15.0   22.0\n",
       "Tienda 1    Benito     Vino    10.0   14.5\n",
       "Tienda 2  Fernando    Jamón    35.0   50.0\n",
       "Tienda 3    Martín   Aceite    12.0    0.0\n",
       "Tienda 3    Hernán  Azafrán     NaN    0.0"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.loc[['Tienda 1','Tienda 3'],'Venta']=[22, 14.5, 0, 0]\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También se puede escribir el valor de columnas completas. Al igual que anteriormente, han de coindidir los tamaños."
   ]
  },
  {
   "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>Nombre</th>\n",
       "      <th>Producto</th>\n",
       "      <th>Compra</th>\n",
       "      <th>Venta</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Álvaro</td>\n",
       "      <td>Queso manchego</td>\n",
       "      <td>15.0</td>\n",
       "      <td>22.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Benito</td>\n",
       "      <td>Vino manchego</td>\n",
       "      <td>10.0</td>\n",
       "      <td>14.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 2</th>\n",
       "      <td>Fernando</td>\n",
       "      <td>Jamón Extremeño</td>\n",
       "      <td>35.0</td>\n",
       "      <td>50.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Martín</td>\n",
       "      <td>Aceite Andaluz</td>\n",
       "      <td>12.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Hernán</td>\n",
       "      <td>Azafrán manchego</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Nombre          Producto  Compra  Venta\n",
       "Tienda 1    Álvaro    Queso manchego    15.0   22.0\n",
       "Tienda 1    Benito     Vino manchego    10.0   14.5\n",
       "Tienda 2  Fernando   Jamón Extremeño    35.0   50.0\n",
       "Tienda 3    Martín    Aceite Andaluz    12.0    0.0\n",
       "Tienda 3    Hernán  Azafrán manchego     NaN    0.0"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df['Producto'] = ['Queso manchego', 'Vino manchego', \n",
    "                  'Jamón Extremeño', 'Aceite Andaluz', 'Azafrán manchego']\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: right\">\n",
    "<a href=\"#indice\"><font size=5><i class=\"fa fa-arrow-circle-up\" aria-hidden=\"true\" style=\"color:#004D7F\"></i></font></a>\n",
    "</div>\n",
    "\n",
    "---\n",
    "\n",
    "<a id=\"section45\"></a> \n",
    "## <font color=\"#7F000E\">Manipulación de la estructura</font>\n",
    "<br>\n",
    "\n",
    "### <font color=\"#7F000E\"> Cambio de índice </font>\n",
    "\n",
    "El índice se puede cambiar mediante la función `set_index`.  Esta función genera un nuevo _DataFrame_, salvo que explícitamente se indique lo contrario mediante el atributo `inplace`.\n",
    "\n",
    "En la siguiente celda se copia el _DataFrame_ original para conservarlo y poder visualizar mejor los resultados de las distintas operaciones. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "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>Producto</th>\n",
       "      <th>Compra</th>\n",
       "      <th>Venta</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nombre</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Álvaro</th>\n",
       "      <td>Queso manchego</td>\n",
       "      <td>15.0</td>\n",
       "      <td>22.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Benito</th>\n",
       "      <td>Vino manchego</td>\n",
       "      <td>10.0</td>\n",
       "      <td>14.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Fernando</th>\n",
       "      <td>Jamón Extremeño</td>\n",
       "      <td>35.0</td>\n",
       "      <td>50.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Martín</th>\n",
       "      <td>Aceite Andaluz</td>\n",
       "      <td>12.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Hernán</th>\n",
       "      <td>Azafrán manchego</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                  Producto  Compra  Venta\n",
       "Nombre                                   \n",
       "Álvaro      Queso manchego    15.0   22.0\n",
       "Benito       Vino manchego    10.0   14.5\n",
       "Fernando   Jamón Extremeño    35.0   50.0\n",
       "Martín      Aceite Andaluz    12.0    0.0\n",
       "Hernán    Azafrán manchego     NaN    0.0"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_copia = df.copy()\n",
    "df_copia.set_index('Nombre', inplace=True)\n",
    "df_copia.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función `reindex` recibe un índice y lo utiliza para indexar el `DataFrame`. Las filas cuyo índice no aparece en el nuevo índice son descartadas, mientras que se crean filas para aquellos valores del nuevo índice que no existían en el índice anterior. El indice original ha de contener valores únicos. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "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>Producto</th>\n",
       "      <th>Compra</th>\n",
       "      <th>Venta</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nombre</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Álvaro</th>\n",
       "      <td>Queso manchego</td>\n",
       "      <td>15.0</td>\n",
       "      <td>22.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Diego</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Hernán</th>\n",
       "      <td>Azafrán manchego</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Diego</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                Producto  Compra  Venta\n",
       "Nombre                                 \n",
       "Álvaro    Queso manchego    15.0   22.0\n",
       "Diego                NaN     NaN    NaN\n",
       "Hernán  Azafrán manchego     NaN    0.0\n",
       "Diego                NaN     NaN    NaN"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_copia.reindex(index=['Álvaro', 'Diego','Hernán','Diego'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=\"#7F000E\"> Creación de nuevas columnas </font>\n",
    "\n",
    "\n",
    "Cuando se asignan valores a una columna no existente, se crea ésta automáticamente. Si el valor es una colección, asigna uno por uno, según el orden del índice, los elementos. El tamaño de la colección ha de coincidir con el número de filas del `DataFrame`.\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\">\n",
    "    \n",
    "<i class=\"fa fa-exclamation-circle\" aria-hidden=\"true\"></i>\n",
    "En este ejemplo se usan datos _categóricos_. Es decir, se definen unas categorías predeterminadas. Esto se verá más detalle más adelante. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "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>Nombre</th>\n",
       "      <th>Producto</th>\n",
       "      <th>Compra</th>\n",
       "      <th>Venta</th>\n",
       "      <th>C.P</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Álvaro</td>\n",
       "      <td>Queso manchego</td>\n",
       "      <td>15.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>02001</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Benito</td>\n",
       "      <td>Vino manchego</td>\n",
       "      <td>10.0</td>\n",
       "      <td>14.5</td>\n",
       "      <td>02001</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 2</th>\n",
       "      <td>Fernando</td>\n",
       "      <td>Jamón Extremeño</td>\n",
       "      <td>35.0</td>\n",
       "      <td>50.0</td>\n",
       "      <td>02003</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Martín</td>\n",
       "      <td>Aceite Andaluz</td>\n",
       "      <td>12.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>02004</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Hernán</td>\n",
       "      <td>Azafrán manchego</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "      <td>02004</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Nombre          Producto  Compra  Venta    C.P\n",
       "Tienda 1    Álvaro    Queso manchego    15.0   22.0  02001\n",
       "Tienda 1    Benito     Vino manchego    10.0   14.5  02001\n",
       "Tienda 2  Fernando   Jamón Extremeño    35.0   50.0  02003\n",
       "Tienda 3    Martín    Aceite Andaluz    12.0    0.0  02004\n",
       "Tienda 3    Hernán  Azafrán manchego     NaN    0.0  02004"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df['C.P'] = pd.Categorical(['02001', '02001', '02003', '02004','02004'])\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También se puede añadir una columna y fijar los elementos en todas las filas a un valor determinado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "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>Nombre</th>\n",
       "      <th>Producto</th>\n",
       "      <th>Compra</th>\n",
       "      <th>Venta</th>\n",
       "      <th>C.P</th>\n",
       "      <th>Localidad</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Álvaro</td>\n",
       "      <td>Queso manchego</td>\n",
       "      <td>15.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>02001</td>\n",
       "      <td>Madrid</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Benito</td>\n",
       "      <td>Vino manchego</td>\n",
       "      <td>10.0</td>\n",
       "      <td>14.5</td>\n",
       "      <td>02001</td>\n",
       "      <td>Madrid</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 2</th>\n",
       "      <td>Fernando</td>\n",
       "      <td>Jamón Extremeño</td>\n",
       "      <td>35.0</td>\n",
       "      <td>50.0</td>\n",
       "      <td>02003</td>\n",
       "      <td>Madrid</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Martín</td>\n",
       "      <td>Aceite Andaluz</td>\n",
       "      <td>12.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>02004</td>\n",
       "      <td>Madrid</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Hernán</td>\n",
       "      <td>Azafrán manchego</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "      <td>02004</td>\n",
       "      <td>Madrid</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Nombre          Producto  Compra  Venta    C.P Localidad\n",
       "Tienda 1    Álvaro    Queso manchego    15.0   22.0  02001    Madrid\n",
       "Tienda 1    Benito     Vino manchego    10.0   14.5  02001    Madrid\n",
       "Tienda 2  Fernando   Jamón Extremeño    35.0   50.0  02003    Madrid\n",
       "Tienda 3    Martín    Aceite Andaluz    12.0    0.0  02004    Madrid\n",
       "Tienda 3    Hernán  Azafrán manchego     NaN    0.0  02004    Madrid"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df['Localidad'] = 'Madrid'\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se pueden añadir valores a algunas filas solamente mediante un diccionario en el que las claves corresponden al índice, dejando el resto con valor indeterminado o NaN."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "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>Nombre</th>\n",
       "      <th>Producto</th>\n",
       "      <th>Compra</th>\n",
       "      <th>Venta</th>\n",
       "      <th>C.P</th>\n",
       "      <th>Localidad</th>\n",
       "      <th>Entregado</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Álvaro</td>\n",
       "      <td>Queso manchego</td>\n",
       "      <td>15.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>02001</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Benito</td>\n",
       "      <td>Vino manchego</td>\n",
       "      <td>10.0</td>\n",
       "      <td>14.5</td>\n",
       "      <td>02001</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 2</th>\n",
       "      <td>Fernando</td>\n",
       "      <td>Jamón Extremeño</td>\n",
       "      <td>35.0</td>\n",
       "      <td>50.0</td>\n",
       "      <td>02003</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Martín</td>\n",
       "      <td>Aceite Andaluz</td>\n",
       "      <td>12.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>02004</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Hernán</td>\n",
       "      <td>Azafrán manchego</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "      <td>02004</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Nombre          Producto  Compra  Venta    C.P Localidad Entregado\n",
       "Tienda 1    Álvaro    Queso manchego    15.0   22.0  02001    Madrid      True\n",
       "Tienda 1    Benito     Vino manchego    10.0   14.5  02001    Madrid      True\n",
       "Tienda 2  Fernando   Jamón Extremeño    35.0   50.0  02003    Madrid      True\n",
       "Tienda 3    Martín    Aceite Andaluz    12.0    0.0  02004    Madrid       NaN\n",
       "Tienda 3    Hernán  Azafrán manchego     NaN    0.0  02004    Madrid       NaN"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df['Entregado'] = pd.Series({'Tienda 1': True, 'Tienda 2': True})\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Existe una función, denominada `assign` que permite copiar un `DataFrame` y crear nuevas columnas. El `DataFrame` original no se modifica. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "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>Nombre</th>\n",
       "      <th>Producto</th>\n",
       "      <th>Compra</th>\n",
       "      <th>Venta</th>\n",
       "      <th>C.P</th>\n",
       "      <th>Localidad</th>\n",
       "      <th>Entregado</th>\n",
       "      <th>Calle</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Álvaro</td>\n",
       "      <td>Queso manchego</td>\n",
       "      <td>15.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>02001</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>True</td>\n",
       "      <td>Ramón y Cajal</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Benito</td>\n",
       "      <td>Vino manchego</td>\n",
       "      <td>10.0</td>\n",
       "      <td>14.5</td>\n",
       "      <td>02001</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>True</td>\n",
       "      <td>Ramón y Cajal</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 2</th>\n",
       "      <td>Fernando</td>\n",
       "      <td>Jamón Extremeño</td>\n",
       "      <td>35.0</td>\n",
       "      <td>50.0</td>\n",
       "      <td>02003</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>True</td>\n",
       "      <td>Hellín</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Martín</td>\n",
       "      <td>Aceite Andaluz</td>\n",
       "      <td>12.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>02004</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Hernán</td>\n",
       "      <td>Azafrán manchego</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "      <td>02004</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Nombre          Producto  Compra  Venta    C.P Localidad  \\\n",
       "Tienda 1    Álvaro    Queso manchego    15.0   22.0  02001    Madrid   \n",
       "Tienda 1    Benito     Vino manchego    10.0   14.5  02001    Madrid   \n",
       "Tienda 2  Fernando   Jamón Extremeño    35.0   50.0  02003    Madrid   \n",
       "Tienda 3    Martín    Aceite Andaluz    12.0    0.0  02004    Madrid   \n",
       "Tienda 3    Hernán  Azafrán manchego     NaN    0.0  02004    Madrid   \n",
       "\n",
       "         Entregado          Calle  \n",
       "Tienda 1      True  Ramón y Cajal  \n",
       "Tienda 1      True  Ramón y Cajal  \n",
       "Tienda 2      True         Hellín  \n",
       "Tienda 3       NaN            NaN  \n",
       "Tienda 3       NaN            NaN  "
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.assign(Calle=pd.Series({'Tienda 1': 'Ramón y Cajal', 'Tienda 2': 'Hellín'}))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "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>Nombre</th>\n",
       "      <th>Producto</th>\n",
       "      <th>Compra</th>\n",
       "      <th>Venta</th>\n",
       "      <th>C.P</th>\n",
       "      <th>Localidad</th>\n",
       "      <th>Entregado</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Álvaro</td>\n",
       "      <td>Queso manchego</td>\n",
       "      <td>15.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>02001</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Benito</td>\n",
       "      <td>Vino manchego</td>\n",
       "      <td>10.0</td>\n",
       "      <td>14.5</td>\n",
       "      <td>02001</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 2</th>\n",
       "      <td>Fernando</td>\n",
       "      <td>Jamón Extremeño</td>\n",
       "      <td>35.0</td>\n",
       "      <td>50.0</td>\n",
       "      <td>02003</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Martín</td>\n",
       "      <td>Aceite Andaluz</td>\n",
       "      <td>12.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>02004</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Hernán</td>\n",
       "      <td>Azafrán manchego</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "      <td>02004</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Nombre          Producto  Compra  Venta    C.P Localidad Entregado\n",
       "Tienda 1    Álvaro    Queso manchego    15.0   22.0  02001    Madrid      True\n",
       "Tienda 1    Benito     Vino manchego    10.0   14.5  02001    Madrid      True\n",
       "Tienda 2  Fernando   Jamón Extremeño    35.0   50.0  02003    Madrid      True\n",
       "Tienda 3    Martín    Aceite Andaluz    12.0    0.0  02004    Madrid       NaN\n",
       "Tienda 3    Hernán  Azafrán manchego     NaN    0.0  02004    Madrid       NaN"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=\"#7F000E\"> Renombrado de índice y de columnas </font>\n",
    "\n",
    "\n",
    "El índice y las columnas pueden renombrarse mediante el método `rename()`. Puede tomar como argumento un diccionario con las correspondencias, o una función de transformación ([documentación](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.rename.html)). En caso de tomar una función de transformación, es necesario especificar si ésta actúa sobre índices o sobre columnas mediante el atributo `axis` (que por defecto toma el valor `index`).\n",
    "\n",
    "El siguiente ejemplo, renombra todos los índices anteponiéndoles el caracter `'#'` y transformándolo en un `String`. Esta operación devuelve un nuevo `DataFrame`, a menos que se indique que actúe sobre el mismo mediante el parámetro `inplace`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "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>Nombre</th>\n",
       "      <th>Producto</th>\n",
       "      <th>Compra</th>\n",
       "      <th>Venta</th>\n",
       "      <th>C.P</th>\n",
       "      <th>Localidad</th>\n",
       "      <th>Entregado</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>#Tienda 1</th>\n",
       "      <td>Álvaro</td>\n",
       "      <td>Queso manchego</td>\n",
       "      <td>15.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>02001</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>#Tienda 1</th>\n",
       "      <td>Benito</td>\n",
       "      <td>Vino manchego</td>\n",
       "      <td>10.0</td>\n",
       "      <td>14.5</td>\n",
       "      <td>02001</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>#Tienda 2</th>\n",
       "      <td>Fernando</td>\n",
       "      <td>Jamón Extremeño</td>\n",
       "      <td>35.0</td>\n",
       "      <td>50.0</td>\n",
       "      <td>02003</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>#Tienda 3</th>\n",
       "      <td>Martín</td>\n",
       "      <td>Aceite Andaluz</td>\n",
       "      <td>12.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>02004</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>#Tienda 3</th>\n",
       "      <td>Hernán</td>\n",
       "      <td>Azafrán manchego</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "      <td>02004</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             Nombre          Producto  Compra  Venta    C.P Localidad  \\\n",
       "#Tienda 1    Álvaro    Queso manchego    15.0   22.0  02001    Madrid   \n",
       "#Tienda 1    Benito     Vino manchego    10.0   14.5  02001    Madrid   \n",
       "#Tienda 2  Fernando   Jamón Extremeño    35.0   50.0  02003    Madrid   \n",
       "#Tienda 3    Martín    Aceite Andaluz    12.0    0.0  02004    Madrid   \n",
       "#Tienda 3    Hernán  Azafrán manchego     NaN    0.0  02004    Madrid   \n",
       "\n",
       "          Entregado  \n",
       "#Tienda 1      True  \n",
       "#Tienda 1      True  \n",
       "#Tienda 2      True  \n",
       "#Tienda 3       NaN  \n",
       "#Tienda 3       NaN  "
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_copia = df.copy()              # Copia el original (por claridad en los ejemplos)\n",
    "\n",
    "df_copia.rename(lambda x: '#'+str(x), axis='index', inplace=True)\n",
    "df_copia.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También se pueden renombrar índices o columnas asignando un diccionario a los atributos `index` o  `columns`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "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>Nombre</th>\n",
       "      <th>Producto</th>\n",
       "      <th>Compra</th>\n",
       "      <th>PVP</th>\n",
       "      <th>C.P</th>\n",
       "      <th>Localidad</th>\n",
       "      <th>Disponible</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Álvaro</td>\n",
       "      <td>Queso manchego</td>\n",
       "      <td>15.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>02001</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Benito</td>\n",
       "      <td>Vino manchego</td>\n",
       "      <td>10.0</td>\n",
       "      <td>14.5</td>\n",
       "      <td>02001</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 2</th>\n",
       "      <td>Fernando</td>\n",
       "      <td>Jamón Extremeño</td>\n",
       "      <td>35.0</td>\n",
       "      <td>50.0</td>\n",
       "      <td>02003</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Martín</td>\n",
       "      <td>Aceite Andaluz</td>\n",
       "      <td>12.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>02004</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Hernán</td>\n",
       "      <td>Azafrán manchego</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "      <td>02004</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Nombre          Producto  Compra   PVP    C.P Localidad Disponible\n",
       "Tienda 1    Álvaro    Queso manchego    15.0  22.0  02001    Madrid       True\n",
       "Tienda 1    Benito     Vino manchego    10.0  14.5  02001    Madrid       True\n",
       "Tienda 2  Fernando   Jamón Extremeño    35.0  50.0  02003    Madrid       True\n",
       "Tienda 3    Martín    Aceite Andaluz    12.0   0.0  02004    Madrid        NaN\n",
       "Tienda 3    Hernán  Azafrán manchego     NaN   0.0  02004    Madrid        NaN"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_copia = df.copy()       # Copia el original (por claridad en los ejemplos)\n",
    "df_copia.rename(columns = {'Venta': 'PVP', 'Entregado':'Disponible'}, inplace = True);\n",
    "df_copia.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por último, es posible renombrar las columnas directamente asignando una colección de valores al campo `DataFrame.columns`."
   ]
  },
  {
   "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></th>\n",
       "      <th>COMPRA</th>\n",
       "      <th>NOMBRE</th>\n",
       "      <th>PVP</th>\n",
       "      <th>PRODUCTO</th>\n",
       "      <th>C.P</th>\n",
       "      <th>LOCALIDAD</th>\n",
       "      <th>ENTREGADO</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Álvaro</td>\n",
       "      <td>Queso manchego</td>\n",
       "      <td>15.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>02001</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Benito</td>\n",
       "      <td>Vino manchego</td>\n",
       "      <td>10.0</td>\n",
       "      <td>14.5</td>\n",
       "      <td>02001</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 2</th>\n",
       "      <td>Fernando</td>\n",
       "      <td>Jamón Extremeño</td>\n",
       "      <td>35.0</td>\n",
       "      <td>50.0</td>\n",
       "      <td>02003</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Martín</td>\n",
       "      <td>Aceite Andaluz</td>\n",
       "      <td>12.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>02004</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Hernán</td>\n",
       "      <td>Azafrán manchego</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "      <td>02004</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            COMPRA            NOMBRE   PVP  PRODUCTO    C.P LOCALIDAD  \\\n",
       "Tienda 1    Álvaro    Queso manchego  15.0      22.0  02001    Madrid   \n",
       "Tienda 1    Benito     Vino manchego  10.0      14.5  02001    Madrid   \n",
       "Tienda 2  Fernando   Jamón Extremeño  35.0      50.0  02003    Madrid   \n",
       "Tienda 3    Martín    Aceite Andaluz  12.0       0.0  02004    Madrid   \n",
       "Tienda 3    Hernán  Azafrán manchego   NaN       0.0  02004    Madrid   \n",
       "\n",
       "         ENTREGADO  \n",
       "Tienda 1      True  \n",
       "Tienda 1      True  \n",
       "Tienda 2      True  \n",
       "Tienda 3       NaN  \n",
       "Tienda 3       NaN  "
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_copia.columns = ['COMPRA','NOMBRE', 'PVP','PRODUCTO','C.P', 'LOCALIDAD','ENTREGADO']\n",
    "df_copia"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=\"#7F000E\"> Reordenación de columnas </font>\n",
    "\n",
    "Al acceder a una colección de columnas se genera un nuevo `DataFrame` en el que las columnas se colocan en el orden de la colección. "
   ]
  },
  {
   "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>NOMBRE</th>\n",
       "      <th>LOCALIDAD</th>\n",
       "      <th>C.P</th>\n",
       "      <th>PRODUCTO</th>\n",
       "      <th>COMPRA</th>\n",
       "      <th>PVP</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Queso manchego</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>02001</td>\n",
       "      <td>22.0</td>\n",
       "      <td>Álvaro</td>\n",
       "      <td>15.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Vino manchego</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>02001</td>\n",
       "      <td>14.5</td>\n",
       "      <td>Benito</td>\n",
       "      <td>10.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 2</th>\n",
       "      <td>Jamón Extremeño</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>02003</td>\n",
       "      <td>50.0</td>\n",
       "      <td>Fernando</td>\n",
       "      <td>35.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Aceite Andaluz</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>02004</td>\n",
       "      <td>0.0</td>\n",
       "      <td>Martín</td>\n",
       "      <td>12.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Azafrán manchego</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>02004</td>\n",
       "      <td>0.0</td>\n",
       "      <td>Hernán</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    NOMBRE LOCALIDAD    C.P  PRODUCTO    COMPRA   PVP\n",
       "Tienda 1    Queso manchego    Madrid  02001      22.0    Álvaro  15.0\n",
       "Tienda 1     Vino manchego    Madrid  02001      14.5    Benito  10.0\n",
       "Tienda 2   Jamón Extremeño    Madrid  02003      50.0  Fernando  35.0\n",
       "Tienda 3    Aceite Andaluz    Madrid  02004       0.0    Martín  12.0\n",
       "Tienda 3  Azafrán manchego    Madrid  02004       0.0    Hernán   NaN"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_copia = df_copia[['NOMBRE','LOCALIDAD','C.P', 'PRODUCTO','COMPRA','PVP']]\n",
    "df_copia"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=\"#7F000E\"> Eliminación de filas y columnas </font>\n",
    "\n",
    "El método `drop()` permite eliminar filas y columnas. Sin embargo, ___devuelve un nuevo objeto___, y el original permanece en su estado. Para que la eliminación se haga sobre el objeto original, ha de indicarse fijando el parámetro `inplace=True`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "\n",
    "<i class=\"fa fa-exclamation-circle\" aria-hidden=\"true\"></i>\n",
    "__Recordad__ que la mayor parte de operaciones que manipulan la estructura del `DataFrame` no los elementos, producen una copia del mismo, pero aceptan el parámetro `inplace`.\n",
    "</div>"
   ]
  },
  {
   "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>Nombre</th>\n",
       "      <th>Producto</th>\n",
       "      <th>Compra</th>\n",
       "      <th>Venta</th>\n",
       "      <th>C.P</th>\n",
       "      <th>Localidad</th>\n",
       "      <th>Entregado</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Álvaro</td>\n",
       "      <td>Queso manchego</td>\n",
       "      <td>15.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>02001</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Benito</td>\n",
       "      <td>Vino manchego</td>\n",
       "      <td>10.0</td>\n",
       "      <td>14.5</td>\n",
       "      <td>02001</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Martín</td>\n",
       "      <td>Aceite Andaluz</td>\n",
       "      <td>12.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>02004</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Hernán</td>\n",
       "      <td>Azafrán manchego</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "      <td>02004</td>\n",
       "      <td>Madrid</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          Nombre          Producto  Compra  Venta    C.P Localidad Entregado\n",
       "Tienda 1  Álvaro    Queso manchego    15.0   22.0  02001    Madrid      True\n",
       "Tienda 1  Benito     Vino manchego    10.0   14.5  02001    Madrid      True\n",
       "Tienda 3  Martín    Aceite Andaluz    12.0    0.0  02004    Madrid       NaN\n",
       "Tienda 3  Hernán  Azafrán manchego     NaN    0.0  02004    Madrid       NaN"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_copia = df.copy()                             # Copia el original (por claridad en los ejemplos))\n",
    "df_copia.drop('Tienda 2', inplace = True)\n",
    "df_copia"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La eliminación de columnas puede hacerse con el mismo método, utilizando el parámetro `axis=1` (el valor por defecto de `axis` es 0, que indica que se eliminen filas)."
   ]
  },
  {
   "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>Nombre</th>\n",
       "      <th>Producto</th>\n",
       "      <th>Compra</th>\n",
       "      <th>Venta</th>\n",
       "      <th>C.P</th>\n",
       "      <th>Localidad</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Álvaro</td>\n",
       "      <td>Queso manchego</td>\n",
       "      <td>15.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>02001</td>\n",
       "      <td>Madrid</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Benito</td>\n",
       "      <td>Vino manchego</td>\n",
       "      <td>10.0</td>\n",
       "      <td>14.5</td>\n",
       "      <td>02001</td>\n",
       "      <td>Madrid</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 2</th>\n",
       "      <td>Fernando</td>\n",
       "      <td>Jamón Extremeño</td>\n",
       "      <td>35.0</td>\n",
       "      <td>50.0</td>\n",
       "      <td>02003</td>\n",
       "      <td>Madrid</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Martín</td>\n",
       "      <td>Aceite Andaluz</td>\n",
       "      <td>12.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>02004</td>\n",
       "      <td>Madrid</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Hernán</td>\n",
       "      <td>Azafrán manchego</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "      <td>02004</td>\n",
       "      <td>Madrid</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Nombre          Producto  Compra  Venta    C.P Localidad\n",
       "Tienda 1    Álvaro    Queso manchego    15.0   22.0  02001    Madrid\n",
       "Tienda 1    Benito     Vino manchego    10.0   14.5  02001    Madrid\n",
       "Tienda 2  Fernando   Jamón Extremeño    35.0   50.0  02003    Madrid\n",
       "Tienda 3    Martín    Aceite Andaluz    12.0    0.0  02004    Madrid\n",
       "Tienda 3    Hernán  Azafrán manchego     NaN    0.0  02004    Madrid"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_copia = df.copy()                             # Copia el original (por claridad en los ejemplos))\n",
    "df_copia.drop('Entregado', axis=1, inplace=True)\n",
    "df_copia"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se pueden borrar __columnas__ también mediante la función `del`."
   ]
  },
  {
   "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 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>Nombre</th>\n",
       "      <th>Producto</th>\n",
       "      <th>Compra</th>\n",
       "      <th>Venta</th>\n",
       "      <th>C.P</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Álvaro</td>\n",
       "      <td>Queso manchego</td>\n",
       "      <td>15.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>02001</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Benito</td>\n",
       "      <td>Vino manchego</td>\n",
       "      <td>10.0</td>\n",
       "      <td>14.5</td>\n",
       "      <td>02001</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 2</th>\n",
       "      <td>Fernando</td>\n",
       "      <td>Jamón Extremeño</td>\n",
       "      <td>35.0</td>\n",
       "      <td>50.0</td>\n",
       "      <td>02003</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Martín</td>\n",
       "      <td>Aceite Andaluz</td>\n",
       "      <td>12.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>02004</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Hernán</td>\n",
       "      <td>Azafrán manchego</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "      <td>02004</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Nombre          Producto  Compra  Venta    C.P\n",
       "Tienda 1    Álvaro    Queso manchego    15.0   22.0  02001\n",
       "Tienda 1    Benito     Vino manchego    10.0   14.5  02001\n",
       "Tienda 2  Fernando   Jamón Extremeño    35.0   50.0  02003\n",
       "Tienda 3    Martín    Aceite Andaluz    12.0    0.0  02004\n",
       "Tienda 3    Hernán  Azafrán manchego     NaN    0.0  02004"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del df_copia['Localidad']\n",
    "df_copia"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "\n",
    "<i class=\"fa fa-exclamation-circle\" aria-hidden=\"true\"></i>\n",
    "__Importante__: Esta función solamente permite borrar __columnas__, no filas. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función `pop` devuelve y elimina columnas en una misma operación."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tienda 1    Madrid\n",
      "Tienda 1    Madrid\n",
      "Tienda 2    Madrid\n",
      "Tienda 3    Madrid\n",
      "Tienda 3    Madrid\n",
      "Name: Localidad, dtype: object\n"
     ]
    },
    {
     "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>Nombre</th>\n",
       "      <th>Producto</th>\n",
       "      <th>Compra</th>\n",
       "      <th>Venta</th>\n",
       "      <th>C.P</th>\n",
       "      <th>Entregado</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Álvaro</td>\n",
       "      <td>Queso manchego</td>\n",
       "      <td>15.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>02001</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 1</th>\n",
       "      <td>Benito</td>\n",
       "      <td>Vino manchego</td>\n",
       "      <td>10.0</td>\n",
       "      <td>14.5</td>\n",
       "      <td>02001</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 2</th>\n",
       "      <td>Fernando</td>\n",
       "      <td>Jamón Extremeño</td>\n",
       "      <td>35.0</td>\n",
       "      <td>50.0</td>\n",
       "      <td>02003</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Martín</td>\n",
       "      <td>Aceite Andaluz</td>\n",
       "      <td>12.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>02004</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tienda 3</th>\n",
       "      <td>Hernán</td>\n",
       "      <td>Azafrán manchego</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "      <td>02004</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Nombre          Producto  Compra  Venta    C.P Entregado\n",
       "Tienda 1    Álvaro    Queso manchego    15.0   22.0  02001      True\n",
       "Tienda 1    Benito     Vino manchego    10.0   14.5  02001      True\n",
       "Tienda 2  Fernando   Jamón Extremeño    35.0   50.0  02003      True\n",
       "Tienda 3    Martín    Aceite Andaluz    12.0    0.0  02004       NaN\n",
       "Tienda 3    Hernán  Azafrán manchego     NaN    0.0  02004       NaN"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_copia = df.copy() \n",
    "localidades = df_copia.pop('Localidad')\n",
    "\n",
    "print(localidades)\n",
    "df_copia"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: right\">\n",
    "<a href=\"#indice\"><font size=5><i class=\"fa fa-arrow-circle-up\" aria-hidden=\"true\" style=\"color:#004D7F\"></i></font></a>\n",
    "</div>\n",
    "\n",
    "---\n",
    "\n",
    "<a id=\"section46\"></a> \n",
    "## <font color=\"#7F000E\" >Descripción de los datos </font>\n",
    "<br>\n",
    "\n",
    "La función `describe()` devuelve diversa información con respecto a las columnas. Esta información varía según el tipo de datos. Además, se puede especificar sobre qué columnas se aplica la función con los parámetros `include` \\ `exclude`.\n",
    "\n",
    "La siguiente llamada incluye todas las columnas. Puede apreciarse que para las numéricas muestra unos datos, y para las no numéricas otros."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "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>Nombre</th>\n",
       "      <th>Producto</th>\n",
       "      <th>Compra</th>\n",
       "      <th>Venta</th>\n",
       "      <th>C.P</th>\n",
       "      <th>Entregado</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>5</td>\n",
       "      <td>5</td>\n",
       "      <td>4.000000</td>\n",
       "      <td>5.000000</td>\n",
       "      <td>5</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>unique</th>\n",
       "      <td>5</td>\n",
       "      <td>5</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>top</th>\n",
       "      <td>Fernando</td>\n",
       "      <td>Vino manchego</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>02004</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>freq</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>18.000000</td>\n",
       "      <td>17.300000</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>11.518102</td>\n",
       "      <td>20.602184</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>10.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>11.500000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>13.500000</td>\n",
       "      <td>14.500000</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>20.000000</td>\n",
       "      <td>22.000000</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>35.000000</td>\n",
       "      <td>50.000000</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          Nombre       Producto     Compra      Venta    C.P Entregado\n",
       "count          5              5   4.000000   5.000000      5         3\n",
       "unique         5              5        NaN        NaN      3         1\n",
       "top     Fernando  Vino manchego        NaN        NaN  02004      True\n",
       "freq           1              1        NaN        NaN      2         3\n",
       "mean         NaN            NaN  18.000000  17.300000    NaN       NaN\n",
       "std          NaN            NaN  11.518102  20.602184    NaN       NaN\n",
       "min          NaN            NaN  10.000000   0.000000    NaN       NaN\n",
       "25%          NaN            NaN  11.500000   0.000000    NaN       NaN\n",
       "50%          NaN            NaN  13.500000  14.500000    NaN       NaN\n",
       "75%          NaN            NaN  20.000000  22.000000    NaN       NaN\n",
       "max          NaN            NaN  35.000000  50.000000    NaN       NaN"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_copia.describe(include=\"all\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el caso de las variables numéricas, se pueden determinar los percentiles que se han de mostrar. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "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>Compra</th>\n",
       "      <th>Venta</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>4.000000</td>\n",
       "      <td>5.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>18.000000</td>\n",
       "      <td>17.300000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>11.518102</td>\n",
       "      <td>20.602184</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>10.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>32%</th>\n",
       "      <td>11.920000</td>\n",
       "      <td>4.060000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>13.500000</td>\n",
       "      <td>14.500000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>61%</th>\n",
       "      <td>14.490000</td>\n",
       "      <td>17.800000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>35.000000</td>\n",
       "      <td>50.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          Compra      Venta\n",
       "count   4.000000   5.000000\n",
       "mean   18.000000  17.300000\n",
       "std    11.518102  20.602184\n",
       "min    10.000000   0.000000\n",
       "32%    11.920000   4.060000\n",
       "50%    13.500000  14.500000\n",
       "61%    14.490000  17.800000\n",
       "max    35.000000  50.000000"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_copia.describe(include=\"number\", percentiles=[0.32, 0.61])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: right\">\n",
    "<a href=\"#indice\"><font size=5><i class=\"fa fa-arrow-circle-up\" aria-hidden=\"true\" style=\"color:#004D7F\"></i></font></a>\n",
    "</div>\n",
    "\n",
    "---\n",
    "\n",
    "<div style=\"text-align: right\"> <font size=6><i class=\"fa fa-coffee\" aria-hidden=\"true\" style=\"color:#004D7F\"></i> </font></div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}