4 - Librerias de funciones externas.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Librerias de funciones externas\n",
    "Las librerias externas contienen funciones que realizan tareas especificas por ejemplo de analisis estadistico o visualizacion de datos. Estas librerias complementan las funciones propias de Python (built-in functions) y para poder utilizarlas debemos primero instalarlas y despues importarlas en nuestro Notebook. En este curso vamos a ver algunas de las librerias mas populares de Python como NumPy y Pandas. Las librerias que veremos vienen con Anaconda asi que no vamos a necesitar instalarlas. Estas son algunas de las librerias externas (ademas de los entornos de programacion Jupyter Notebooks y Spyder) que instala Anaconda por defecto.\n",
    "\n",
    "<img src='util/Anaconda_librerias.png'>\n",
    "\n",
    "## 1. NumPy\n",
    "NumPy es una librería de funciones matematicas que es muy popular para realizar operaciones matematicas con vectores y matrices. NumPy tiene muchas funciones pero en este curso solo vamos unas pocas pero si quereis mas informacion de NumPy y todas las funciones que contiene puedes ir a este enlace: https://numpy.org/doc/stable/user/index.html\n",
    "\n",
    "<img src='util/Numpy_funciones.png'>\n",
    "\n",
    "Al ser una libreria externa, es decir las funciones no son propias (built-in) de Python, lo primero que debemos hacer para poder usar las funciones de NumPy es importar NumPy y darle un nombre, por ejemplo *np*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np # importamos la libreria NumPy como np (podemos darle otro nombre si queremos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A partir de ahora para usar las funciones de NumPy debemos poner np. seguido del nombre de la funcion.\n",
    "\n",
    "⚡ Si en una celda ponemos np. y pulsamos la tecla Tabulador veremos la lista de funciones disponibles de Numpy que como verás son muchísimas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-2-df0eca0bfa5c>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-2-df0eca0bfa5c>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    np.\u001b[0m\n\u001b[1;37m       ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "np."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 Array\n",
    "Un concepto muy importante en NumPy es *array*, es como se llama a las estructuras de valores que utiliza NumPy. Un *array* es similar a una lista de valores pero en un formato que NumPy reconoce y que es compatible con las funciones de Numpy.\n",
    "\n",
    "Con la funcion ***array*** de NumPy podemos crear un array (vector o matriz) a partir de una lista de valores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "miLista = [2,5,10,20,6] # creamos una lista de valores\n",
    "miArray = np.array(miLista) # creamos un array a partir de la lista de valores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2,  5, 10, 20,  6])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "miArray."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "miLista."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "miArray es ahora una lista de valores que al tener el formato formato *array* la hacemos compatible con NumPy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 Funciones basicas de NumPy\n",
    "NumPy contiene una serie de funciones basicas que son muy similares a algunas de las funciones propias (built-in) de Python, por ejemplo:\n",
    "\n",
    "Para crear secuencias de valores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "miArray = np.arange(1,10,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el case de miArray, hemos creado una lista de valores del tipo *array* (es decir un vector o matriz) que es el formato propio de NumPy "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "miArray"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para calcular el maximo valor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.max(miArray)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max(miArray)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "❗ Como puedes ver las dos funciones se llaman igual *max*, pero podemos distinguir la que es propia de NumPy porque debemos poner *np.* delante del nombre de la funcion. \n",
    "\n",
    "Para calcular el numero de valores o elementos tenemos la funcion *size* que es similar a la funcion propia de Python llamada *len*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.size(miArray)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(miArray)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3 Creacion de arrays de valores aleatorios\n",
    "Con la funcion ***random*** podemos crear arrays (vectores o matrices) de valores aleatorios con una determinada distribucion estadistica. Dentro de la funcion *random* podemos usar otras sub-funciones si ponemos random seguido de un punto, entre ellas tenemos las sub-funciones ***uniform*** y ***normal***.\n",
    "\n",
    "Por ejemplo vamos a crear un vector de 20 valores aleatorios comprendidos entre 0 y 5 segun una distribucion uniforme:\n",
    "<img src='util/distribucion_uniforme.png'>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.uniform(low=0, high=10, size=[20,1]) # low = limite inferior, high = limite superior, \n",
    "# size = [numero de filas, numero de columnas] del array (vector o matriz)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O un vector 20 de valores aleatorios segun una distribucion normal con un valor medio igual a 5 y una desviacion estandar igual a 2.\n",
    "<img src='util/distribucion_normal.png'>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.normal(loc = 5, scale = 2, size=[20,1]) # loc = valor medio, scale = desviacion estandard\n",
    "# size = [numero de filas, numero de columnas] del array (vector o matriz)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "⚡ **Ejercicio:** Intenta tú ahora crear una matriz de valores aleatorios segun una distribucion normal. La matriz debe tener 10 filas y 5 columnas y los valores deben tener un valor medio de 10 y una desviacion estandar de 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora crea una variable que se llame *matriz* y que contenga una matriz como la que acabamos de crear."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Tienen los mismos valores las dos matrices que hemos creado?\n",
    "\n",
    "Y por ultimo calcula el numero de valores que tiene *matriz*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Pandas\n",
    "Pandas es una librería de Python especializada en el manejo y análisis de estructuras de datos, en particular tablas de datos. Con Pandas puedes:\n",
    "\n",
    "- Define nuevas estructuras de datos basadas en los arrays de la librería NumPy pero con nuevas funcionalidades.\n",
    "- Permite leer y escribir fácilmente ficheros en formato CSV y Excel.\n",
    "- Permite acceder a los datos mediante índices o nombres para filas y columnas.\n",
    "- Ofrece métodos para reordenar, dividir y combinar conjuntos de datos.\n",
    "- Permite trabajar con series temporales.\n",
    "\n",
    "Pandas tiene muchas funciones pero en este curso solo vamos unas pocas pero si quereis mas informacion de Pandas y todas las funciones que contiene puedes ir a este enlace: https://pandas.pydata.org/docs/getting_started/intro_tutorials/index.html\n",
    "\n",
    "<img src='util/Pandas_funciones.png'>\n",
    "\n",
    "En este Notebook vamos a ver ademas como podemos combinar las librerias NumPy y Pandas.\n",
    "\n",
    "Al ser Pandas una libreria externa, es decir las funciones no son propias (built-in) de Python, lo primero que debemos hacer para poder usar las funciones de NumPy es importar Pandas y darle un nombre, por ejemplo *pd*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A partir de ahora para usar las funciones de Pandas debemos poner pd. seguido del nombre de la funcion.\n",
    "\n",
    "⚡ Si en una celda ponemos pd. y pulsamos la tecla Tabulador veremos la lista de funciones disponibles de Pandas que como verás son muchísimas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 Dataframes\n",
    "Un concepto muy importante en Pandas es *dataframe*, es como se llama a las estructuras de valores que utiliza Pandas. Un *dataframe* son el nucleo de Pandas y podemos pensar en un *dataframe* como una tabla de datos que comparten el mismo índice o en otras palabras el equivalente de un tabla de Excel. Vamos a crear un *dataframe* con Pandas para entender mejor que es y para que nos puede servir.\n",
    "\n",
    "Primero vamos a crear una matriz de valores aleatorios con NumPy (tal y como hemos visto en la primera parte de este Notebook dedicada a NumPy). Por ejemplo, con la funcion de NumPy *random.uniform* creamos una matriz de 12 filas y 6 columnas de valores aleatorios comprendidos entre 0 y 100 y le vamos a dar el nombre *rain*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rain = np.random.uniform(low = 0, high = 100, size = [12,6])\n",
    "print(rain)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora usando Pandas vamos a crear el Dataframe usando los datos de *rain*, para ello vamos a utilizar la funcion *DataFrame* de Pandas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rain_df = pd.DataFrame(rain)\n",
    "print(rain_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Qué ha cambiado?\n",
    "\n",
    "Vamos a hacerlo de nuevo pero ahora vamos a especificar el nombre de las filas (*index*) y las columnas (*columns*)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rain_df = pd.DataFrame(rain, index = ['Ene', 'Feb', 'Mar', 'Abr', 'May', 'Jun', 'Jul', 'Ago', 'Sep', 'Oct', 'Nov', 'Dec'],\n",
    "                             columns = ['2022', '2023', '2024', '2025', '2026', '2027'])\n",
    "rain_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De este modo podemos dar mas informacion de los datos contenidos en una matriz o vector. \n",
    "\n",
    "### 2.2 Extraer valores seleccionados\n",
    "De una manera similar a como hacemos en Numpy con los *arrays*, podemos extraer los datos que mas nos interese de un *dataframe* pero Pandas nos permite acceder a los datos mediante índices o nombres para filas y columnas en vez de numeros de filas o columnas. Para ello utilizamos la funcion *loc*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rain_df.loc[['Ago','Dec'],['2023','2026']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rain_df.loc['Ago':'Dec','2023':'2026']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rain_ago_df = rain_df.loc['Ago',:]\n",
    "rain_ago_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3 Añadir o actualizar los valores de un *dataframe*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos añadir una nueva columna con nuevos datos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rain_df['2028'] = np.random.uniform(low = 0, high = 100, size = [12,1])\n",
    "rain_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Que pasa si repetimos la misma operacion?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rain_df['2028'] = np.random.uniform(low = 0, high = 100, size = [12,1])\n",
    "rain_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "❗**Importante**: Presta atencion al numero entre corchetes a lado de la celda, te da el orden de ejecucion de las celdas.\n",
    "\n",
    "⚡**Ejercicio:** En la celda de abajo hemos escrito el codigo para añadir otra columna llamada 2029 pero al ejecutar la celda da un error, ¿sabes por que? ¿lo puedes arreglar?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rain_df['2029'] = np.random.uniform(low = 0, high = 100, size = [1,12])\n",
    "rain_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos a crear una nueva columna que sea la media de los valores de cada año. Primero ¿como calculamos la media?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rain_df.mean(1) # si entre parentesis ponemos 0 la media la hace por columnas, si es un 1 entonces la media es por filas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora añadimo una columna llamada *media* con la media de los valores por filas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rain_df['media'] = rain_df.mean(1)\n",
    "rain_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4 Series temporales con Pandas\n",
    "Pandas introduce un nuevo tipo de valor (ademas de los que ya habiamos visto: numerico, cadena de caracteres y booleano) que es la fecha. Como vamos a ver esto es especialmente util para tratamiento y analisis de series temporales (o historicas) por ejemplo, datos diarios de lluvia. \n",
    "\n",
    "Como ejemplo vamos a crear usa serie temporal de datos diarios de lluvia: \n",
    "\n",
    "1. Con la funcion *random.uniform* de NumPy creamos un *array* de 365 valores aleatorios comprendidos entre 0 y 20 y lo guardamos en un variable que se llame *lluvia_array*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lluvia_array = np.random.uniform(low=0, high=20, size = [365,1])\n",
    "lluvia_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Ahora con la funcion ***date_range*** de Pandas creamos un serie temporal con las fechas del año 2021 y lo guardamos en la variable fechas_2021 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fechas_2021 = pd.date_range(start = '2021-01-01', end = '2021-12-31') \n",
    "fechas_2021"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Por ultimo creamos un dataframe llamado *lluvia_dataframe* en el que los indices sean los valores de *fechas_2021*, y que contenga una columna llamada *lluvia (mm / dia)* con los datos de *lluvia_array*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lluvia_dataframe = pd.DataFrame(lluvia_array, index = fechas_2021, columns = ['lluvia'])\n",
    "lluvia_dataframe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lluvia_dataframe['2021-02-01':'2021-02-28']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lluvia_dataframe[lluvia_dataframe.index.month == 2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lluvia_dataframe[lluvia_dataframe['lluvia'] > 18]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lluvia_dataframe['2021-02-01':'2021-02-28'][lluvia_dataframe['lluvia'] > 18]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lluvia_dataframe[lluvia_dataframe.index.month == 2][lluvia_dataframe['lluvia'] > 18]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lluvia_dataframe.resample(\"W\").mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si quereis saber mas sobre como crear y modificar dataframes: https://pandas.pydata.org/docs/user_guide/index.html\n",
    "\n",
    "### 2.5 Pandas y Excel\n",
    "#### Guadar dataframes en archivos que pueda leer Excel\n",
    "Una de las mejores caracteristicas de Pandas es que puedes guardar los dataframes en formato Excel. Vamos a guardar el dataframe *rain_df* en la carpeta *datos* como un archivo Excel (.xlsx), para ello utilizamos la funcion ***to_excel***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rain_df.to_excel('datos/rain_df.xlsx')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tambien podemos guardarlo como un archivo de texto del tipo .csv (comma-separated values) con la funcion ***to_csv***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rain_df.to_csv('datos/lluvia_dataframe.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Leer archivos Excel con Pandas\n",
    "Y tambien leer archivos Excel. Con la funcion ***read_excel*** las tablas Excel son convertidas a *dataframe* y asi podemos utilizar las funciones de Pandas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.read_excel('datos/rain_df.xlsx')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "E igualmente podemos leer archivos de texto del tipo .csv (comma-separated values) con la funcion ***read_csv*** y guardarlo como una variable"
   ]
  },
  {
   "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>nombre</th>\n",
       "      <th>edad</th>\n",
       "      <th>sexo</th>\n",
       "      <th>peso</th>\n",
       "      <th>altura</th>\n",
       "      <th>colesterol</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>José Luis Martínez Izquierdo</td>\n",
       "      <td>18</td>\n",
       "      <td>H</td>\n",
       "      <td>85.0</td>\n",
       "      <td>1.79</td>\n",
       "      <td>182.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Rosa Díaz Díaz</td>\n",
       "      <td>32</td>\n",
       "      <td>M</td>\n",
       "      <td>65.0</td>\n",
       "      <td>1.73</td>\n",
       "      <td>232.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Javier García Sánchez</td>\n",
       "      <td>24</td>\n",
       "      <td>H</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1.81</td>\n",
       "      <td>191.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Carmen López Pinzón</td>\n",
       "      <td>35</td>\n",
       "      <td>M</td>\n",
       "      <td>65.0</td>\n",
       "      <td>1.70</td>\n",
       "      <td>200.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Marisa López Collado</td>\n",
       "      <td>46</td>\n",
       "      <td>M</td>\n",
       "      <td>51.0</td>\n",
       "      <td>1.58</td>\n",
       "      <td>148.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Antonio Ruiz Cruz</td>\n",
       "      <td>68</td>\n",
       "      <td>H</td>\n",
       "      <td>66.0</td>\n",
       "      <td>1.74</td>\n",
       "      <td>249.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Antonio Fernández Ocaña</td>\n",
       "      <td>51</td>\n",
       "      <td>H</td>\n",
       "      <td>62.0</td>\n",
       "      <td>1.72</td>\n",
       "      <td>276.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>Pilar Martín González</td>\n",
       "      <td>22</td>\n",
       "      <td>M</td>\n",
       "      <td>60.0</td>\n",
       "      <td>1.66</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>Pedro Gálvez Tenorio</td>\n",
       "      <td>35</td>\n",
       "      <td>H</td>\n",
       "      <td>90.0</td>\n",
       "      <td>1.94</td>\n",
       "      <td>241.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>Santiago Reillo Manzano</td>\n",
       "      <td>46</td>\n",
       "      <td>H</td>\n",
       "      <td>75.0</td>\n",
       "      <td>1.85</td>\n",
       "      <td>280.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>Macarena Álvarez Luna</td>\n",
       "      <td>53</td>\n",
       "      <td>M</td>\n",
       "      <td>55.0</td>\n",
       "      <td>1.62</td>\n",
       "      <td>262.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>José María de la Guía Sanz</td>\n",
       "      <td>58</td>\n",
       "      <td>H</td>\n",
       "      <td>78.0</td>\n",
       "      <td>1.87</td>\n",
       "      <td>198.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>Miguel Angel Cuadrado Gutiérrez</td>\n",
       "      <td>27</td>\n",
       "      <td>H</td>\n",
       "      <td>109.0</td>\n",
       "      <td>1.98</td>\n",
       "      <td>210.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>Carolina Rubio Moreno</td>\n",
       "      <td>20</td>\n",
       "      <td>M</td>\n",
       "      <td>61.0</td>\n",
       "      <td>1.77</td>\n",
       "      <td>194.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                             nombre  edad sexo   peso  altura  colesterol\n",
       "0      José Luis Martínez Izquierdo    18    H   85.0    1.79       182.0\n",
       "1                    Rosa Díaz Díaz    32    M   65.0    1.73       232.0\n",
       "2             Javier García Sánchez    24    H    NaN    1.81       191.0\n",
       "3               Carmen López Pinzón    35    M   65.0    1.70       200.0\n",
       "4              Marisa López Collado    46    M   51.0    1.58       148.0\n",
       "5                 Antonio Ruiz Cruz    68    H   66.0    1.74       249.0\n",
       "6           Antonio Fernández Ocaña    51    H   62.0    1.72       276.0\n",
       "7             Pilar Martín González    22    M   60.0    1.66         NaN\n",
       "8              Pedro Gálvez Tenorio    35    H   90.0    1.94       241.0\n",
       "9           Santiago Reillo Manzano    46    H   75.0    1.85       280.0\n",
       "10            Macarena Álvarez Luna    53    M   55.0    1.62       262.0\n",
       "11       José María de la Guía Sanz    58    H   78.0    1.87       198.0\n",
       "12  Miguel Angel Cuadrado Gutiérrez    27    H  109.0    1.98       210.0\n",
       "13            Carolina Rubio Moreno    20    M   61.0    1.77       194.0"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "colesterol_df = pd.read_csv('datos/colesterol.csv') # leemos los datos del archivo colesterol.csv y\n",
    "# los guardamos como un dataframe en una variable que se llama colesterol_df\n",
    "colesterol_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.6 Utilizar operaciones de comparacion para extraer datos de un Dataframe que cumplan ciertas condiciones\n",
    "Con los operadores de comparacion (>, <, =) podemos extraer los datos que mas nos interesen de un dataframe.\n",
    "\n",
    "De los datos que tenemos disponibles en *colesterol_df* vamos primero a mirar la columna de la edad."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0     18\n",
       "1     32\n",
       "2     24\n",
       "3     35\n",
       "4     46\n",
       "5     68\n",
       "6     51\n",
       "7     22\n",
       "8     35\n",
       "9     46\n",
       "10    53\n",
       "11    58\n",
       "12    27\n",
       "13    20\n",
       "Name: edad, dtype: int64"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "colesterol_df['edad']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora vemos cual son mayores de 40"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0     False\n",
       "1     False\n",
       "2     False\n",
       "3     False\n",
       "4      True\n",
       "5      True\n",
       "6      True\n",
       "7     False\n",
       "8     False\n",
       "9      True\n",
       "10     True\n",
       "11     True\n",
       "12    False\n",
       "13    False\n",
       "Name: edad, dtype: bool"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "colesterol_df['edad'] >= 40"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Asi solo podemos ver los indices que cumplen o no la condicion pero nos gustaria extraer todos los datos de las personas mayores de 40.\n",
    "```python\n",
    "nombre_dataframe[(nombre_dataframe['nombre_columna'] condicion)]\n",
    "```"
   ]
  },
  {
   "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>edad</th>\n",
       "      <th>sexo</th>\n",
       "      <th>peso</th>\n",
       "      <th>altura</th>\n",
       "      <th>colesterol</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Marisa López Collado</td>\n",
       "      <td>46</td>\n",
       "      <td>M</td>\n",
       "      <td>51.0</td>\n",
       "      <td>1.58</td>\n",
       "      <td>148.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Antonio Ruiz Cruz</td>\n",
       "      <td>68</td>\n",
       "      <td>H</td>\n",
       "      <td>66.0</td>\n",
       "      <td>1.74</td>\n",
       "      <td>249.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Antonio Fernández Ocaña</td>\n",
       "      <td>51</td>\n",
       "      <td>H</td>\n",
       "      <td>62.0</td>\n",
       "      <td>1.72</td>\n",
       "      <td>276.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>Santiago Reillo Manzano</td>\n",
       "      <td>46</td>\n",
       "      <td>H</td>\n",
       "      <td>75.0</td>\n",
       "      <td>1.85</td>\n",
       "      <td>280.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>Macarena Álvarez Luna</td>\n",
       "      <td>53</td>\n",
       "      <td>M</td>\n",
       "      <td>55.0</td>\n",
       "      <td>1.62</td>\n",
       "      <td>262.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>José María de la Guía Sanz</td>\n",
       "      <td>58</td>\n",
       "      <td>H</td>\n",
       "      <td>78.0</td>\n",
       "      <td>1.87</td>\n",
       "      <td>198.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                        nombre  edad sexo  peso  altura  colesterol\n",
       "4         Marisa López Collado    46    M  51.0    1.58       148.0\n",
       "5            Antonio Ruiz Cruz    68    H  66.0    1.74       249.0\n",
       "6      Antonio Fernández Ocaña    51    H  62.0    1.72       276.0\n",
       "9      Santiago Reillo Manzano    46    H  75.0    1.85       280.0\n",
       "10       Macarena Álvarez Luna    53    M  55.0    1.62       262.0\n",
       "11  José María de la Guía Sanz    58    H  78.0    1.87       198.0"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "colesterol_df[(colesterol_df['edad'] >= 40)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora queremos ver que personas mayores de 40 tienen alto el colesterol, en este caso colesterol > 200. Cuando tenemos varias condiciones:\n",
    "\n",
    "```python\n",
    "nombre_dataframe[(nombre_dataframe['nombre_columna_1'] condicion_1) & (nombre_dataframe['nombre_columna_2'] condicion_2)]\n",
    "```"
   ]
  },
  {
   "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>edad</th>\n",
       "      <th>sexo</th>\n",
       "      <th>peso</th>\n",
       "      <th>altura</th>\n",
       "      <th>colesterol</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Antonio Ruiz Cruz</td>\n",
       "      <td>68</td>\n",
       "      <td>H</td>\n",
       "      <td>66.0</td>\n",
       "      <td>1.74</td>\n",
       "      <td>249.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Antonio Fernández Ocaña</td>\n",
       "      <td>51</td>\n",
       "      <td>H</td>\n",
       "      <td>62.0</td>\n",
       "      <td>1.72</td>\n",
       "      <td>276.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>Santiago Reillo Manzano</td>\n",
       "      <td>46</td>\n",
       "      <td>H</td>\n",
       "      <td>75.0</td>\n",
       "      <td>1.85</td>\n",
       "      <td>280.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>Macarena Álvarez Luna</td>\n",
       "      <td>53</td>\n",
       "      <td>M</td>\n",
       "      <td>55.0</td>\n",
       "      <td>1.62</td>\n",
       "      <td>262.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     nombre  edad sexo  peso  altura  colesterol\n",
       "5         Antonio Ruiz Cruz    68    H  66.0    1.74       249.0\n",
       "6   Antonio Fernández Ocaña    51    H  62.0    1.72       276.0\n",
       "9   Santiago Reillo Manzano    46    H  75.0    1.85       280.0\n",
       "10    Macarena Álvarez Luna    53    M  55.0    1.62       262.0"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "colesterol_df[(colesterol_df['edad'] >= 40) & (colesterol_df['colesterol'] > 200)]"
   ]
  },
  {
   "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}