1_Pandas.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cross-level",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "! mkdir -p datasets\n",
    "%cd datasets\n",
    "! wget -nc https://raw.githubusercontent.com/pablonoya/zigzag-ml/master/datasets/panel_data.csv\n",
    "%cd .."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lesbian-strip",
   "metadata": {},
   "source": [
    "# ¿Pandas? 🐼🐼\n",
    "Es una **librería** de Python que permite manejar **datos tabulares**, el nombre deriva de *panel datas*, un tipo de tabla que muestra datos sobre mediciones a lo largo del tiempo.\n",
    "\n",
    "|persona | año | ingreso | edad |\n",
    "|--------|-----|---------|------|\n",
    "| 1 | 2010 | 1300  | 22  |\n",
    "| 1 | 2011  | 1450  | 23 |\n",
    "| 2 | 2009  | 2300  | 25  |\n",
    "| 3 | 2010  | 2600  | 27  |\n",
    "\n",
    "\n",
    "Cuenta con funciones para leer tablas, analizarlas, seleccionar columnas, realizar limpieza de datos y transformaciones con estos 🤯.  \n",
    "Operaciones imprescindibles cuando queremos que la máquina aprenda de los datos 😉."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "random-integral",
   "metadata": {},
   "source": [
    "# Comma-separated values\n",
    "El **formato** más extendido para almacenar datos tabulares es ~~excel~~ **.csv**, este es un archivo de texto plano que describe **cada fila en una linea** de texto y **separa las columnas por comas** (sin espacios). La **primera fila es el encabezado**, contiene los nombres de cada columna, las siguientes filas contienen los datos.\n",
    "\n",
    "Para nuestra tabla, el archivo .csv tiene este formato:\n",
    "\n",
    "```\n",
    "persona,año,ingreso,edad\n",
    "1,2010,1300,22\n",
    "1,2010,1450,23\n",
    " ...\n",
    "```\n",
    "Esto nos permite almacenar grandes cantidades de datos de forma fácil y sin que ocupen demasiado espacio, pero no son sencillos de manejar si los tratamos como texto plano ☹️."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "geological-guatemala",
   "metadata": {},
   "source": [
    "# Cargando csv\n",
    "La función `pandas.read_csv` nos permite leer archivos, esta recibe una cadena con el **directorio** donde está el archivo, y retorna un objeto de tipo *DataFrame* el cual también contiene un índice y tiene métodos como `head` que nos permite ver las **primeras filas** de la tabla, por defecto nos mostrará cinco."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "advised-weather",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "pandas.core.frame.DataFrame"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "data = pd.read_csv('./datasets/panel_data.csv')\n",
    "type(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "legislative-bridge",
   "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>persona</th>\n",
       "      <th>año</th>\n",
       "      <th>ingreso</th>\n",
       "      <th>edad</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>2010</td>\n",
       "      <td>1300</td>\n",
       "      <td>22</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>2010</td>\n",
       "      <td>1450</td>\n",
       "      <td>23</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>2009</td>\n",
       "      <td>2300</td>\n",
       "      <td>25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>2010</td>\n",
       "      <td>2600</td>\n",
       "      <td>27</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>3</td>\n",
       "      <td>2011</td>\n",
       "      <td>2500</td>\n",
       "      <td>28</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   persona   año  ingreso  edad\n",
       "0        1  2010     1300    22\n",
       "1        1  2010     1450    23\n",
       "2        2  2009     2300    25\n",
       "3        3  2010     2600    27\n",
       "4        3  2011     2500    28"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ambient-vegetable",
   "metadata": {},
   "source": [
    "Podemos escoger el **número** de filas que nos mostrará mandando un entero como argumento"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "naval-prairie",
   "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>persona</th>\n",
       "      <th>año</th>\n",
       "      <th>ingreso</th>\n",
       "      <th>edad</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>2010</td>\n",
       "      <td>1300</td>\n",
       "      <td>22</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>2010</td>\n",
       "      <td>1450</td>\n",
       "      <td>23</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>2009</td>\n",
       "      <td>2300</td>\n",
       "      <td>25</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   persona   año  ingreso  edad\n",
       "0        1  2010     1300    22\n",
       "1        1  2010     1450    23\n",
       "2        2  2009     2300    25"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.head(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "moderate-recommendation",
   "metadata": {},
   "source": [
    "# Mirando DataFrames\n",
    "Estos objetos ya cuentan con los métodos necesarios para las operaciones que necesitamos, además de métodos que nos proporcionan información sobre el mismo, por ejemplo, podemos generar un **resumen** de esta tabla utilizando el método `info`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "periodic-horse",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 6 entries, 0 to 5\n",
      "Data columns (total 4 columns):\n",
      " #   Column   Non-Null Count  Dtype\n",
      "---  ------   --------------  -----\n",
      " 0   persona  6 non-null      int64\n",
      " 1   año      6 non-null      int64\n",
      " 2   ingreso  6 non-null      int64\n",
      " 3   edad     6 non-null      int64\n",
      "dtypes: int64(4)\n",
      "memory usage: 320.0 bytes\n"
     ]
    }
   ],
   "source": [
    "data.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "thorough-venture",
   "metadata": {},
   "source": [
    "Este resumen muestra **cuántos** datos tenemos, si tenemos datos **nulos** y el **tipo de dato** o 'dtype' de cada columna.\n",
    "Para esta tabla, no tenemos datos nulos, y todas las columnas tienen enteros.\n",
    "\n",
    "También podemos obtener algunos datos estadísticos con el método `describe`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "thousand-original",
   "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>persona</th>\n",
       "      <th>año</th>\n",
       "      <th>ingreso</th>\n",
       "      <th>edad</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>6.000000</td>\n",
       "      <td>6.000000</td>\n",
       "      <td>6.000000</td>\n",
       "      <td>6.00000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>2.333333</td>\n",
       "      <td>2010.166667</td>\n",
       "      <td>2225.000000</td>\n",
       "      <td>26.00000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>1.211060</td>\n",
       "      <td>0.752773</td>\n",
       "      <td>725.086202</td>\n",
       "      <td>3.34664</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>2009.000000</td>\n",
       "      <td>1300.000000</td>\n",
       "      <td>22.00000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>1.250000</td>\n",
       "      <td>2010.000000</td>\n",
       "      <td>1662.500000</td>\n",
       "      <td>23.50000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>2.500000</td>\n",
       "      <td>2010.000000</td>\n",
       "      <td>2400.000000</td>\n",
       "      <td>26.00000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>3.000000</td>\n",
       "      <td>2010.750000</td>\n",
       "      <td>2575.000000</td>\n",
       "      <td>27.75000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>4.000000</td>\n",
       "      <td>2011.000000</td>\n",
       "      <td>3200.000000</td>\n",
       "      <td>31.00000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        persona          año      ingreso      edad\n",
       "count  6.000000     6.000000     6.000000   6.00000\n",
       "mean   2.333333  2010.166667  2225.000000  26.00000\n",
       "std    1.211060     0.752773   725.086202   3.34664\n",
       "min    1.000000  2009.000000  1300.000000  22.00000\n",
       "25%    1.250000  2010.000000  1662.500000  23.50000\n",
       "50%    2.500000  2010.000000  2400.000000  26.00000\n",
       "75%    3.000000  2010.750000  2575.000000  27.75000\n",
       "max    4.000000  2011.000000  3200.000000  31.00000"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "genetic-spouse",
   "metadata": {},
   "source": [
    "Y verificar si contamos con elementos vacíos con el método `isna` este mostrará verdadero o falso según sea el caso."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "abstract-friday",
   "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>persona</th>\n",
       "      <th>año</th>\n",
       "      <th>ingreso</th>\n",
       "      <th>edad</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   persona    año  ingreso   edad\n",
       "0    False  False    False  False\n",
       "1    False  False    False  False\n",
       "2    False  False    False  False\n",
       "3    False  False    False  False\n",
       "4    False  False    False  False\n",
       "5    False  False    False  False"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.isna()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "institutional-table",
   "metadata": {},
   "source": [
    "Los cuales podemos eliminar con el método `dropna` en nuestro caso no temos elementos vacíos, por lo que la tabla no cambiará."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "outdoor-visitor",
   "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>persona</th>\n",
       "      <th>año</th>\n",
       "      <th>ingreso</th>\n",
       "      <th>edad</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>2010</td>\n",
       "      <td>1300</td>\n",
       "      <td>22</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>2010</td>\n",
       "      <td>1450</td>\n",
       "      <td>23</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>2009</td>\n",
       "      <td>2300</td>\n",
       "      <td>25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>2010</td>\n",
       "      <td>2600</td>\n",
       "      <td>27</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>3</td>\n",
       "      <td>2011</td>\n",
       "      <td>2500</td>\n",
       "      <td>28</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>4</td>\n",
       "      <td>2011</td>\n",
       "      <td>3200</td>\n",
       "      <td>31</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   persona   año  ingreso  edad\n",
       "0        1  2010     1300    22\n",
       "1        1  2010     1450    23\n",
       "2        2  2009     2300    25\n",
       "3        3  2010     2600    27\n",
       "4        3  2011     2500    28\n",
       "5        4  2011     3200    31"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = data.dropna()\n",
    "data.head(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "virgin-hopkins",
   "metadata": {},
   "source": [
    "## Columnas\n",
    "Podemos **manipular** las columnas como si tuviéramos un **diccionario**, esta operación nos devuelve un objeto *Series*, por lo que también nos mostrará un índice y el *dtype* de la columna al imprimirlo. Adicionalmente, podemos pasar una **lista** de nombres de columnas, intenta pasar algunas 😃"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "stock-telescope",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    22\n",
      "1    23\n",
      "2    25\n",
      "3    27\n",
      "4    28\n",
      "5    31\n",
      "Name: edad, dtype: int64\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "pandas.core.series.Series"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "columna = \"edad\"\n",
    "\n",
    "print(data[columna])\n",
    "type(data[columna])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "hired-walker",
   "metadata": {},
   "source": [
    "De la misma manera podemos **definir nuevas columnas** de manera dinámica.  \n",
    "Si deseamos almacenar el ingreso en miles en vez de unidades podríamos utilizar el siguiente código:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "closing-share",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Int64Index: 6 entries, 0 to 5\n",
      "Data columns (total 5 columns):\n",
      " #   Column            Non-Null Count  Dtype  \n",
      "---  ------            --------------  -----  \n",
      " 0   persona           6 non-null      int64  \n",
      " 1   año               6 non-null      int64  \n",
      " 2   ingreso           6 non-null      int64  \n",
      " 3   edad              6 non-null      int64  \n",
      " 4   ingreso_en_miles  6 non-null      float64\n",
      "dtypes: float64(1), int64(4)\n",
      "memory usage: 288.0 bytes\n"
     ]
    }
   ],
   "source": [
    "data[\"ingreso_en_miles\"] = data[\"ingreso\"] / 1000\n",
    "\n",
    "data.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "weird-footwear",
   "metadata": {},
   "source": [
    "Si deseamos eliminar la columna original utilizamos el método `drop` el argumento `axis=\"columns\"` indica que eliminaremos una columna."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "placed-calvin",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.drop('ingreso', axis=\"columns\", inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "powered-humidity",
   "metadata": {},
   "source": [
    "Por defecto `drop` no altera la variable original, en su lugar, retorna una copia con los cambios. Esto puede ser útil para evitar borrones no deseados."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "least-arrangement",
   "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>persona</th>\n",
       "      <th>año</th>\n",
       "      <th>edad</th>\n",
       "      <th>ingreso_en_miles</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>2010</td>\n",
       "      <td>22</td>\n",
       "      <td>1.30</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>2010</td>\n",
       "      <td>23</td>\n",
       "      <td>1.45</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>2009</td>\n",
       "      <td>25</td>\n",
       "      <td>2.30</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>2010</td>\n",
       "      <td>27</td>\n",
       "      <td>2.60</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>3</td>\n",
       "      <td>2011</td>\n",
       "      <td>28</td>\n",
       "      <td>2.50</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   persona   año  edad  ingreso_en_miles\n",
       "0        1  2010    22              1.30\n",
       "1        1  2010    23              1.45\n",
       "2        2  2009    25              2.30\n",
       "3        3  2010    27              2.60\n",
       "4        3  2011    28              2.50"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "restricted-phoenix",
   "metadata": {},
   "source": [
    "Si deseamos **alterar la instancia original**, debemos añadir el argumento `inplace=True` a la función `drop`, inténtalo en la celda de más arriba 😉"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "residential-focus",
   "metadata": {},
   "source": [
    "## Filas\n",
    "Para leer filas podemos usar el **índice**, pero debe ser junto al atributo `iloc`, este también nos permite **manipularlo como matriz**, para tener acceso de la forma **\\[fila\\]\\[columna\\]** o bien **\\[fila, columna\\]**\n",
    "\n",
    "Tambien podemos usar *slicing* para definir rangos, prueba definiendo alguno 😎"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "furnished-monkey",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   persona   año  edad  ingreso_en_miles\n",
      "2        2  2009    25               2.3\n",
      "3        3  2010    27               2.6\n",
      "4        3  2011    28               2.5\n",
      "5        4  2011    31               3.2\n"
     ]
    }
   ],
   "source": [
    "fila = 2\n",
    "print(data.iloc[fila:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "behind-proxy",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25.0\n",
      "25\n"
     ]
    }
   ],
   "source": [
    "fila, columna = 2, 2\n",
    "print(data.iloc[fila][columna])\n",
    "print(data.iloc[fila, columna])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "3a2bd466-9b7d-4c47-87cb-678d2ee972ff",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# slicing\n",
    "lista = [2, 5, 4, 6, 9]\n",
    "lista[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "bf073025-727d-4e7d-a926-084267fec481",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[6, 9]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista[3:]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "related-mambo",
   "metadata": {},
   "source": [
    "## Filtrando filas\n",
    "Una de las operaciones más curiosas es pasar una **lista de booleanos como índice**, esta debe tener el **número de filas** del *DataFrame*, podemos obtener este dato usando la función `len` sobre el mismo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "57ba9ad3-72a9-4767-806e-c8139942a391",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num_filas = len(data)\n",
    "num_filas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "16b50341-cdf0-4697-9b15-75640fff1034",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[True, True, True, True, True, True]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "indices_bool = [True] * num_filas\n",
    "indices_bool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "1497c8d3-64c6-4f22-b3c3-4f921d78bace",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[True, True, False, True, True, True]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "indices_bool[2] = False\n",
    "indices_bool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "1d7a388c-a374-4e21-9f97-145258d854f7",
   "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>persona</th>\n",
       "      <th>año</th>\n",
       "      <th>edad</th>\n",
       "      <th>ingreso_en_miles</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>2010</td>\n",
       "      <td>22</td>\n",
       "      <td>1.30</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>2010</td>\n",
       "      <td>23</td>\n",
       "      <td>1.45</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>2010</td>\n",
       "      <td>27</td>\n",
       "      <td>2.60</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>3</td>\n",
       "      <td>2011</td>\n",
       "      <td>28</td>\n",
       "      <td>2.50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>4</td>\n",
       "      <td>2011</td>\n",
       "      <td>31</td>\n",
       "      <td>3.20</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   persona   año  edad  ingreso_en_miles\n",
       "0        1  2010    22              1.30\n",
       "1        1  2010    23              1.45\n",
       "3        3  2010    27              2.60\n",
       "4        3  2011    28              2.50\n",
       "5        4  2011    31              3.20"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[indices_bool]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "retained-variety",
   "metadata": {},
   "source": [
    "0, 1, 3, 4, ... ¡Falta la fila con índice 2! 😰  \n",
    "Y aprovecharemos eso para **filtrar** las filas 😎 si escribimos una **condición** con alguna columna del *DataFrame*..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "given-replacement",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    False\n",
       "1    False\n",
       "2     True\n",
       "3     True\n",
       "4     True\n",
       "5     True\n",
       "Name: edad, dtype: bool"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data['edad'] > 23"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "marked-accused",
   "metadata": {},
   "source": [
    "Obtendremos una *Series* de booleanos, la cual también podemos usar como índice para filtrar 😎."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "bronze-deficit",
   "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>persona</th>\n",
       "      <th>año</th>\n",
       "      <th>edad</th>\n",
       "      <th>ingreso_en_miles</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>2009</td>\n",
       "      <td>25</td>\n",
       "      <td>2.3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>2010</td>\n",
       "      <td>27</td>\n",
       "      <td>2.6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>3</td>\n",
       "      <td>2011</td>\n",
       "      <td>28</td>\n",
       "      <td>2.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>4</td>\n",
       "      <td>2011</td>\n",
       "      <td>31</td>\n",
       "      <td>3.2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   persona   año  edad  ingreso_en_miles\n",
       "2        2  2009    25               2.3\n",
       "3        3  2010    27               2.6\n",
       "4        3  2011    28               2.5\n",
       "5        4  2011    31               3.2"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "condicion = data['edad'] > 23\n",
    "data[condicion]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "spatial-repository",
   "metadata": {},
   "source": [
    "Si quieres usar **varias condiciones**, debes utilizar los operadores lógicos `&` y `|`, que corresponden a `and` y `or` en Python, pero no podemos usar esas sentencias ☹️. Además, debes encerrar las condiciones en paréntesis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "twenty-escape",
   "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>persona</th>\n",
       "      <th>año</th>\n",
       "      <th>edad</th>\n",
       "      <th>ingreso_en_miles</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>3</td>\n",
       "      <td>2011</td>\n",
       "      <td>28</td>\n",
       "      <td>2.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>4</td>\n",
       "      <td>2011</td>\n",
       "      <td>31</td>\n",
       "      <td>3.2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   persona   año  edad  ingreso_en_miles\n",
       "4        3  2011    28               2.5\n",
       "5        4  2011    31               3.2"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "condicion = (data['edad'] > 23) & (data['año'] > 2010)\n",
    "data[condicion]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "every-grill",
   "metadata": {},
   "source": [
    "No es la forma más cómoda de escribirlas, pero existe una mejor, utilizando el método `query` podemos declarar las **condiciones como una cadena**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "unusual-ecuador",
   "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>persona</th>\n",
       "      <th>año</th>\n",
       "      <th>edad</th>\n",
       "      <th>ingreso_en_miles</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>3</td>\n",
       "      <td>2011</td>\n",
       "      <td>28</td>\n",
       "      <td>2.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>4</td>\n",
       "      <td>2011</td>\n",
       "      <td>31</td>\n",
       "      <td>3.2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   persona   año  edad  ingreso_en_miles\n",
       "4        3  2011    28               2.5\n",
       "5        4  2011    31               3.2"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.query(\"edad > 23 & año > 2010\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "diverse-seeking",
   "metadata": {},
   "source": [
    "# Ejercicios\n",
    "En algunas ocasiones, contaremos con columnas irrelevantes, como un identificador o nombres de personas.  \n",
    "¿Cómo evitamos cargarlas en un DataFrame? utiliza el archivo \"panel_data.csv\" para **evitar cargar la columna** \"persona\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "skilled-equipment",
   "metadata": {},
   "outputs": [],
   "source": [
    "# recuerda haber cargado el dataset y mira la documentación\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "exotic-council",
   "metadata": {},
   "source": [
    "Tener una tabla de verdaderos y falsos para verificar si existen valores nulos no es nada práctico.   \n",
    "¿Qué maneras se te ocurren para **contar valores nulos** en un dataset?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "quick-stomach",
   "metadata": {},
   "outputs": [],
   "source": [
    "# True puede ser 1 y False 0\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "advance-concern",
   "metadata": {},
   "source": [
    "# Pandas listo\n",
    "Estas serían algunas de las operaciones más básicas para manejar tablas en pandas 🐼  \n",
    "Continuemos con el [\"Hola mundo\" del Machine Learning](2_Hola_mundo.ipynb)"
   ]
  }
 ],
 "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": 5
}