AnalisisDatos.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "center",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Estadística Descriptiva Utilizando Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "<center><img src = AnalisisDatos.assets/title.png width=\"40%\" height=\"40%\" /></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "center",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Resumen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**Que <u>no</u> vamos a ver hoy**\n",
    "\n",
    "- Obtener el resultado de una regresión lineal\n",
    "- Programar modelos económicos en Python\n",
    "- Cómo programar Machine Learning.\n",
    "- Conseguir datos mediante Web Scrapping.\n",
    "- Hackear los servidores de Google."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**Que <u>sí</u> vamos a ver hoy:**\n",
    "- Introducción a Python: cajas, cosas, acciones\n",
    "- Pandas y manejo de datos\n",
    "- Estadísticas descriptivas\n",
    "- Visualización de datos "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Herramientas generales\n",
    "- Entornos de trabajo: Anaconda, Jupyter y Binder\n",
    "- Paquetes o librerías: \n",
    "\t- Pandas (bases de datos)\n",
    "\t- Plotnine / Altair (visualización de datos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Recursos:\n",
    "\n",
    "- [QuantEcon](https://lectures.quantecon.org/py/)\n",
    "- [Python Data Science Handbook]( https://github.com/jakevdp/PythonDataScienceHandbook)\n",
    "- [Pandas](https://pandas.pydata.org/) \n",
    "- [Altair](https://altair-viz.github.io/index.html) \n",
    "- [Introducción a Altair](https://vallandingham.me/altair_intro.html)\n",
    "- [Tutorial de Altair](https://medium.com/analytics-vidhya/exploratory-data-visualisation-with-altair-b8d85494795c)\n",
    "- [Plotnine]( https://plotnine.readthedocs.io/en/stable/index.html)\n",
    "- [Grammar of Graphics (R-ggplot!)]( http://moderngraphics11.pbworks.com/f/ggplot2-Book09hWickham.pdf)\n",
    "- [Python Plotting for Exploratory Data Analysis](https://pythonplot.com)\n",
    "- [A Dramatic Tour through Python’s Data Visualization Landscape](https://dsaber.com/2016/10/02/a-dramatic-tour-through-pythons-data-visualization-landscape-including-ggplot-and-altair/)\n",
    "- [Tidying Datasets in Python](https://medium.com/@aaronmak/tidying-datasets-in-python-8634f39159bc)\n",
    "- [Tidy Data in Python](https://www.jeannicholashould.com/tidy-data-in-python.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Intro a Python - Anaconda - Jupyter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "## Anaconda\n",
    "\n",
    "Anaconda es una distribución libre y gratuita de Python y R utilizada para la ciencia de datos. Incluye la instalación de ambos lenguajes de programación con múltiples paquetes y librerías y algunos programas especializados como Jupyter Notebook, Spyder y RStudio. Cuenta con una interfaz user-friendy (Anaconda Navigator, imagen debajo) y una consola."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "## Jupyter Notebook\n",
    "\n",
    "El notebook de jupyter integra código, sus resultados y texto en un visualizador. Para entrar es necesario escribir jupyter notebook en la consola de Anaconda o abrirlo desde el Anaconda Navigator."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Binder\n",
    "\n",
    "Binder es una plataforma donde se puede acceder a Jupyter Notebooks desde internet. Para acceder al notebook de esta presentación haga click [aquí](https://mybinder.org/v2/gh/ndharari/DataAnalisisPython/master)\n",
    "\n",
    "En el transcurso de la clase se va a trabajar con una pequeña introducción a Python con material para que puedan comenzar solos. Para una guía detallada de como instalar y utilizar Anaconda o Jupyter se recomienda que siga el instructivo de [QuantEcon](https://lectures.quantecon.org/py/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Introducción a Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<center><img src = AnalisisDatos.assets/pythonic.png width=\"80%\" height=\"80%\" /></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "La **filosofía** de Python es obtener código elegante y simple:\n",
    "\n",
    "**Elegante**: Un código en python tendria que ser fácil de escribir y recordar.\n",
    "\n",
    "**Simple**: La facilidad de lectura importa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = [i for i in range(10)]\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "> \"Devolvé i por cada i en el rango de 0 a 10\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Cosas, cajas, acciones\n",
    "\n",
    "Python como lenguaje de programación es *multiparadigma*. \n",
    "\n",
    "Breve, los paradigmas son distintas maneras de abordar el *problema* que el programa busca resolver. Que sea multiparadigma implica que se puede elegir uno entre varios de los que soporta. Sin embargo, el más prominente es el de **programación orientada a objetos**. ¿Qué significa esto? Que en Python existen **cosas**, **cajas** y **variables**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Cosas**: *Palabras, letras, números, bases de datos.* \n",
    "\n",
    ">Los **objetos** en python vienen relacionados con ciertas **acciones** específicas a ellos mismos. A estas las llamamos **métodos.** \n",
    ">\n",
    ">(Si creo el objeto *gato*, podría tener la **acción** de *arañar*)\n",
    "\n",
    "**Cajas**: *Variables*.\n",
    "\n",
    "**Acciones**: *Funciones, conectores lógicos, operaciones matemáticas*, etc\n",
    "\n",
    "⚠ No es necesario declarar una variable de antemano, solo basta con:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "X = 1 \n",
    "X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "> ⚠ El símbolo `=` asigna variables. \n",
    ">\n",
    ">Es distinto de `==` que es un operador relacional."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Antes de empezar:\n",
    "\n",
    "Escriban en el notebook la siguiente linea y oprmiman \"control + enter\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(\"Hola Mundo\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Paquetes\n",
    "\n",
    "En este contexto un paquete es una parte de código escrto por *la comunidad* específico para cumplir una función determinada. Para poder utilizarlo, se debe **instalar** e **importar**. Por suerte, al utilizar Anaconda ya tenemos instalados varios paquetes escenciales. Otros -de los que vamos a usar en la clase, Altair y Plotnine- deben ser instalados. Para una guía de como instalar e inicializar anaconda, se recomienda buscar en [QuantEcon](https://lectures.quantecon.org/py/). Una vez instalados, es necesario **importarlos**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Importar paquetes\n",
    "\n",
    "¿Por que es necesario *importar* un paquete? \n",
    "\n",
    "Porque si **todos los paquetes** fueran cargados **todas  las veces** que se corra un script significaría un gasto inútil de computación. Por eso, se importan sólamente los paquetes **absolutamente necesarios.** "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "center",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Para hacerlo, se utiliza -entre otras- la siguiente sintaxis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cell_style": "center",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "center",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Y para usar las funciones dentro del paquete (o librería) se utiliza:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cell_style": "center",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "math.sqrt(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "center",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Ahora bien, hay algunos paquetes con nombres muy largos y con funciones largas dentro de ellos.\n",
    "\n",
    "Es posible (y va a pasar) que queramos usar un **alias** más reducido para llamar al paquete dentro de nuestro código. Para esto, se utiliza:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cell_style": "center",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import math as m\n",
    "m.sqrt(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "center",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "También es posible que sepamos que vamos a utilizar mucho una serie de funciones que vienen de un paquete que no queremos llamar cada vez que lo utilicemos. Para eso, se utiliza la siguiente expresión:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cell_style": "center",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "from math import sqrt\n",
    "sqrt(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    ">\n",
    "> ⚠ Si se quiere importar todo el paquete se utiliza la expresión `from math import *`\n",
    ">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Pandas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "## Introducción a Pandas\n",
    "\n",
    "`Pandas` es un paquete que provee una forma simple de manejar estructuras de datos en Python. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Data Frames\n",
    "\n",
    "Los data frames son estructuras de datos que permite lectura y escritura de bases de datos en *CSV*, *txt*, *SQL* y *Excel*. El manejo de estos datos es simple. Cuenta además con formas simples de manejar datos faltantes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Importar y limpiar una base\n",
    "\n",
    "Para los siguientes ejercicios se utilizará la base de datos proporcionada por W. Greene (NYU Stern) en [Panel Data Sets - NYU Stern](http://people.stern.nyu.edu/wgreene/Econometrics/PanelDataSets.htm), originalmente utilizada en de Cornwell & Rupert (1998) en su trabajo sobre retornos a la educación. Las variables presentes en la base de datos son:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "center",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "| Variable |         Description         |\n",
    "| :------: | :-------------------------: |\n",
    "|   EXP    |     Experiencia laboral     |\n",
    "|   WKS    |     Semanas trabajadas      |\n",
    "|   OCC    |   Profesión, 1 si obrero    |\n",
    "|   IND    | 1 si manufactura industrial |\n",
    "|  SOUTH   |    1 si recide en el sur    |\n",
    "|   SMSA   |    1 si recide en ciudad    |\n",
    "|    MS    |         1 si casado         |\n",
    "|   FEM    |         1 si mujer          |\n",
    "|  UNION   |     1 si sindicalizado      |\n",
    "|    ED    |      Años de educación      |\n",
    "|   BLK    |    1 si afrodescendiente    |\n",
    "|  LWAGE   |         Log salario         |\n",
    "|  YEAR    |             Año             |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "center",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Es importante saber la ubicación del archivo para poder importarlo. Hay dos formas de importar un archivo:\n",
    "\n",
    "- Por su **ubicación objetiva** (ejemplo: `C:Windows//Users//Amantedepython`)\n",
    "\n",
    "- Por su **ubicación relativa** a la carpeta desde la cual se corre el programa.\n",
    "\n",
    "Esta presentación utiliza la segunda alternativa por lo que la dirección del archivo es: **\"data/cornwell&rupert.csv\"**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "center",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Para comenzar, importaremos la base de datos como un `DataFrame` de `pandas`, una tabla bidimensional de datos estructurada que acepta varios tipos de inputs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cell_style": "center",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"data/cornwell&rupert.csv\")\n",
    "df.index.name = \"id\"\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Exploración\n",
    "\n",
    "Hay distintas funciones que se pueden usar para administrar los datos desde Pandas. Se pueden obtener los *n* primeros o últimos elementos del DataFrame mediante `.head(n)` y `.tail(n)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "df.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "df.tail(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Como también se puede llamar valores por nombre de columna:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "df[\"WKS\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "df[[\"WKS\", \"SMSA\", \"LWAGE\"]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "También es posible obtener datos buscando por su ubicación. Si se busca por entrada - o id - se utiliza `.loc[id]`. Paralelamente, si se quiere buscar por su posición (ya sea por columna o por id) se utiliza `.iloc[m:n,p:q]`  donde `m,n = filas` y `p,q = columnas`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "df.loc[4] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "df.iloc[20:25,3:7]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Limpieza"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Como vimos antes tenemos dos problemas presentes en la base de datos:\n",
    "\n",
    "- Hay **datos faltantes** (not available o \"Na\").\n",
    "\n",
    "En este ejercicio los problemas fueron introducidos \"a mano\", ya que la base de datos estaba limpia desde un principio. En la mayoría de los casos el problema va a ser el formato que tengan la base de datos y como organizar la tabla. Para más información: [Tidying Datasets in Python](https://medium.com/@aaronmak/tidying-datasets-in-python-8634f39159bc) y [Tidy Data in Python](https://www.jeannicholashould.com/tidy-data-in-python.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "df = df.dropna(how=\"any\") # Elimina los valores \"NaN\"\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Estadísticas descriptivas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Una vez limpiada la base de datos, se suele comenzar el análisis de bases de datos generando ciertos estadísticos de tendencia, dispersión y forma. Estos, junto con gráficas y visualizaciones, ayudan a comprender rápidamente los datos.  A continuación se presentan ciertas funciones presentes presentes en `Pandas`:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Medidas de **tendencia**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "dfMean = df.mean() # Obtiene la media\n",
    "dfMedian = df.median() # Obtiene la mediana\n",
    "dfMode = df.mode() # Obtiene la moda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "dfMean\n",
    "dfMedian\n",
    "dfMode "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "De esta forma se obtienen los resultados de la **media**, **mediana** y **moda** para todas las variables de nuestra base de datos. También es posible hacerlo para ciertas columnas en especial, como se muestra a continuación:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "center",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Medidas de **dispersión**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "dfMin = df[\"EXP\"].min() # Valor mínimo de una variable\n",
    "dfMax = df[[\"WKS\", \"EXP\"]].max() # Valor máximo de ciertas variables\n",
    "dfRange = df[\"ED\"].max() - df[\"ED\"].min() # Rango de una variable\n",
    "dfVariance = df[\"LWAGE\"].var() # Obtiene la varianza\n",
    "df_sd = sqrt(dfVariance) # Obtiene el desvío."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "dfMin\n",
    "dfMax\n",
    "dfRange\n",
    "dfVariance\n",
    "df_sd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "También es posible utilizar `.describe()` para obtener ciertos estadísticos con rapidez:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# summary statistics\n",
    "df.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Estadísticas por grupos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sin embargo, es posible que los estadísticos varíen respecto dependiendo de ciertos grupos. Por ejemplo, el salario  medio de hombres puede ser mayor al de mujeres y el de trabajadores industriales más altos que quienes se encuentran en servicios. Para eso, se utiliza `groupby()`, de forma similar a `dplyr` en `R`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Escencialmente, `.groupby()` divide los datos según una variable elegida. Luego, se puede aplicar funciones descriptivas para obtener los estadísticos de cada grupo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Obtiene el salario más alto por profesión\n",
    "df.groupby(\"OCC\")[\"LWAGE\"].max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Obtiene la media de la experiencia laboral en norte-sur para hombres y mujeres\n",
    "df.groupby([\"SOUTH\", \"FEM\"])[\"EXP\"].mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cell_style": "center",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Obtiene la varianza en educación dividiendo por género y etnia.\n",
    "df.groupby([\"BLK\", \"FEM\"])[\"ED\"].var()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Visualizaciones simples en dos paquetes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "## Introducción a Plotnine y Altair\n",
    "\n",
    "Finalmente, vamos a terminar con ejemplos básicos de dos paquetes de visualización que tienen filosofías *similares.* En ambos, para hacer un gráfico es más importante  **qué** queres graficar que **cómo** debería ser graficado: esto significa que no hará falta específicar exactamente dónde estarán los puntos o las barras, sino que el paquete puede iterpretar de alguna manera nuestras intenciones. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "En forma general, lo necesario en ambos paquetes es especificar **los datos**, **las características estéticas** y **referencias** (como títulos y etiquetas)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Por un lado, `plotnine` es un port extensivo de la librería `ggplot2` de `R`, con sintaxis muy similar, por lo que trae consigo todos los beneficios de la **grammar of graphics**. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Por otro, `altair` aparece (hace muy poco!) como la competencia *pythonica* de `ggplot`, con una sintaxis símple e integración con Jupyter notebooks. Además, es posible realizar gráficos interactivos. 🥳🥳🥳🥳"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Para comenzar, importamos ambos paquetes y corremos ciertas configuraciones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import altair as alt\n",
    "import numpy as np\n",
    "from plotnine import * \n",
    "from random import uniform\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "alt.renderers.enable('notebook')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Histogramas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Base"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# plotnine\n",
    "(ggplot(df) + \n",
    "   aes(x='EXP') +\n",
    "   geom_histogram(binwidth = 2) + \n",
    "   ggtitle('Experiencia Laboral')\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "alt.Chart(df).mark_bar().encode(\n",
    "    x= alt.X(\"EXP\", bin=alt.Bin(step=2)),\n",
    "    y='count(EXP)'\n",
    ").properties(\n",
    "    title='Experiencia Laboral'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Agrupado por variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# plotnine\n",
    "# plotnine\n",
    "(ggplot(df) + \n",
    "   aes(x='EXP') +\n",
    "   geom_histogram(binwidth = 2) + \n",
    "   facet_wrap('FEM') +\n",
    "   ggtitle('Experiencia Laboral por género') \n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Altair\n",
    "alt.Chart(df).mark_bar().encode(\n",
    "    x= alt.X(\"EXP\", bin=alt.Bin(step=2)),\n",
    "    y='count(EXP)',\n",
    "    column = 'FEM:N'\n",
    ").properties(\n",
    "    title='Experiencia Laboral por género'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Gráficos de dispersión"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Base"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# plotnine\n",
    "\n",
    "(ggplot(df) + \n",
    "    aes(x = 'ED', y = 'LWAGE') +\n",
    "    geom_point() +\n",
    "    geom_jitter() +\n",
    "    xlab('Años de educación') +\n",
    "    ylab('Log Salario'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Altair\n",
    "## Interactive!\n",
    "\n",
    "# Altair aún no puede agregar jitter. Se agrega manualmente a un nuevo dataframe,\n",
    "jdf = df\n",
    "jdf['ED'] = jdf['ED'].map(lambda ED: ED + uniform(-0.25, 0.25))\n",
    "jdf\n",
    "\n",
    "alt.Chart(jdf).mark_circle().encode(\n",
    "    x = 'ED',\n",
    "    y = 'LWAGE',\n",
    "    tooltip=['ED', 'LWAGE','FEM', 'BLK']\n",
    ").interactive()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Coloreado por factor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# plotnine\n",
    "\n",
    "(ggplot(df) + \n",
    "    aes(x = 'ED', y = 'LWAGE', color = 'factor(FEM)') +\n",
    "    geom_point() +\n",
    "    geom_jitter() +\n",
    "    xlab('Años de educación') +\n",
    "    ylab('Log Salario'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Altair\n",
    "## Interactive !\n",
    "\n",
    "alt.Chart(jdf).mark_circle().encode(\n",
    "    x = 'ED',\n",
    "    y = 'LWAGE',\n",
    "    color = 'FEM:N',\n",
    "    tooltip=['ED', 'LWAGE','FEM']\n",
    ").interactive()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Serie Tiempo\n",
    "\n",
    "Para finalizar, podría resultar interesante ver si a lo largo del tiempo la media del `LWAGE` para hombres y mujeres cambia. \n",
    "\n",
    "Para eso, se obtiene la siguientes series de tiempo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "timeseries = df.groupby([\"YEAR\", \"FEM\"])[\"LWAGE\"].mean().reset_index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# plotnine\n",
    "\n",
    "(ggplot(timeseries) + \n",
    "    aes(x = 'YEAR', y = 'LWAGE', color = 'factor(FEM)') +\n",
    "    geom_line() \n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Altair\n",
    "## Interactive !\n",
    "\n",
    "alt.Chart(timeseries).mark_line().encode(\n",
    "    alt.Y('LWAGE:Q',\n",
    "        scale=alt.Scale(zero=False)\n",
    "    ),\n",
    "    x ='YEAR:O',\n",
    "    color='FEM:N'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# ¡Muchas Gracias!"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.7.4"
  },
  "rise": {
   "autolaunch": true,
   "scroll": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}