C - Intro a Pandas.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "C - Intro a Pandas",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyN1uyubti2jv5tTwCvc6uKI",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/GabrielMissael/cdecmx/blob/main/C%20-%20Intro%20a%20Pandas.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V1kR35Lr95Lu"
      },
      "source": [
        "# Introducción a Pandas.\n",
        " \n",
        "En este cuaderno veremos los elementos y funciones básicas de la librería **Pandas**. Los contenidos específicos son:\n",
        " \n",
        "1. Introducción a Pandas.\n",
        "2. Dónde encontrar datos.\n",
        "3. Carga de datos de diferentes formatos.\n",
        "4. Series y DataFrames.\n",
        "5. Revisando los datos.\n",
        "6. Selección de datos por etiqueta.\n",
        "7. Selección de datos por posición.\n",
        "8. Operaciones básicas: Estadísticos.\n",
        "9. Operaciones básicas: Apply.\n",
        "10. Unión de datos: Concatenación.\n",
        " \n",
        "### Planteamiento del problema:\n",
        " \n",
        "Limpiar, analizar y obtener información de un conjunto de datos tabulados es útil al tratar de **obtener conocimiento** de la información que tenemos. Utilizaremos lo aprendido en este módulo para analizar tres datasets distintos. \n",
        " \n",
        "## ¿Qué es Pandas? \n",
        " \n",
        "<center>\n",
        "    <img width=\"30%\" src=\"https://pandas.pydata.org/docs/_static/pandas.svg\">\n",
        "</center>\n",
        " \n",
        "**Pandas** es una librería de Python con la que puedes trabajar con datos tabulados. Es muy útil para limpiar, analizar y procesar datos.\n",
        " \n",
        "De acuerdo con Wikipedia: _\"(...) es una biblioteca de software escrita como extensión de **NumPy** para manipulación y análisis de datos para el lenguaje de programación Python. En particular, ofrece estructuras de datos y operaciones para manipular tablas numéricas y series temporales.\"_\n",
        " \n",
        "### Objetos en Pandas.\n",
        " \n",
        "En Pandas, los objetos con los que trabajaremos son dos: **DataFrames** y Series. Un DataFrame lo puedes entender como un **tabla** (como las de Excel), y una **Series** como una **tabla con una sola columna**. Más adelante veremos mas a detalle a estos dos objetos que son los objetos base de Pandas."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "stnODbMd-EI3"
      },
      "source": [
        "# Importamos el módulo que aprenderemos en este módulo :)\n",
        "import pandas as pd\n",
        "\n",
        "# También usaremos un poco Numpy\n",
        "import numpy as np"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tjXN3eJuM44K"
      },
      "source": [
        "## ¿Dónde encontrar datos?\n",
        " \n",
        "En internet existen repositorios de **datos abiertos** de los que puedes descargar datasets, jugar con ellos, analizarlos y aprender. Algunos ejemplos:\n",
        " \n",
        "1. [Kaggle](https://www.kaggle.com/datasets): Sitio web para prácticar y aprender sobre **ciencia de datos y machine learning**. Además de los datasets que hay en el sitio, ¡puedes correr notebooks como este!. Los dataset están por lo general explicados y listos para usarse.\n",
        "2. [UC Irvine Machine Learning Repository](http://archive.ics.uci.edu/ml/index.php): En este repositorio hay más de **500 datasets** de diversos temas. Usualmente son útiles para practicar y aprender sobre machine learning.\n",
        "3. [Datos Abiertos de México](https://datos.gob.mx/): En este sitio web se encuentra una recopilación de datos abiertos de diversas instituciones, así como del **gobierno federal y gobiernos estatales**. \n",
        "4. [INEGI](https://www.inegi.org.mx/datos/): Datos obtenidos de los diversos **censos** que realiza el Instituto Nacional de Estadística y Geografía.\n",
        " \n",
        "Incluso puedes encontrar **datos abiertos de ciencia**: \n",
        "1. [CERN Opendata](https://opendata.cern.ch/): Más de dos petabytes de datos de **física de partículas**.\n",
        "2. [NASA Open Data Portal](https://data.nasa.gov/): Datos aeroespaciales, de ciencias de la tierra... **¡Muchos datos!**✨\n",
        " \n",
        "Esta no es una lista exhaustiva, hay muchos más recursos disponibles con los que puedes trabajar.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mA84olu4M5fG"
      },
      "source": [
        "## Carga de datos de diferentes formatos.\n",
        " \n",
        "Con Pandas puedes **cargar datos** de archivos externos, los cuales pueden estar en internet o en tu computadora (quizá bajaste alguna de las páginas de arriba 👀). Por lo general se utilizan datos tabulados (tablas) en Pandas, y los tipos de archivos desde los que puedes cargar datos son varios. Los más comunes son archivos con _valores separados por comas_ o CSV, por sus siglas en inglés, con extensión **.csv** y archivos de Excel con extensión **.xlsx**.\n",
        " \n",
        " \n",
        "```python\n",
        "# Para importar un archivo csv\n",
        "datos = read_csv('nombre_del_archivo.csv')\n",
        " \n",
        "# Para importar un archivo de excel\n",
        "datos = read_excel('nombre_del_archivo.xlsx') \n",
        "```\n",
        " \n",
        "<center>\n",
        "    <img width=\"90%\" src=\"https://pandas.pydata.org/docs/_images/02_io_readwrite.svg\">\n",
        "</center>\n",
        " \n",
        "Hay más tipos de archivos válidos, como **.html** o **.json** y se importan al igual que los ejemplos anteriores. De la misma manera en la que cargamos datos, podemos guardar un DataFrame o una Series en un archivo con extensión válida: \n",
        " \n",
        "```python\n",
        "# Guardamos los datos en un archivo CSV\n",
        "datos.to_csv('datos_guardados.csv')\n",
        "```\n",
        "Ahora, cargaremos tres datasets que usaremos más adelante. Este primer dataset viene de: _Kaggle_, [Titanic - Machine Learning from Disaster](https://www.kaggle.com/c/titanic/data). El dataset describe información de personas que viajaban en el Titanic."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HbgjsCkOGEfE"
      },
      "source": [
        "# Importamos un archivo de Excel que está en un repositorio en GitHub\n",
        "df_titanic = pd.read_excel('https://raw.githubusercontent.com/GabrielMissael/'+\n",
        "                           'cdecmx/gh-pages/assets/datasets/Titanic.xlsx')\n",
        " \n",
        "# Podemos ver el inicio de un DataFrame con .head()\n",
        "df_titanic.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pVScM7QNZjES"
      },
      "source": [
        "El siguiente dataset viene de muestra dentro de Google Colab, y describe información poblacional e inmobiliaria de California."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aT4-WQF1M5ly"
      },
      "source": [
        "# Importamos un archivo CSV que viene de ejemplo en Google Colab\n",
        "df_casas = pd.read_csv('sample_data/california_housing_test.csv')\n",
        "df_casas.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_J03hiE8_rWH"
      },
      "source": [
        "Finalmente, datos de: [Wikipedia - World population](https://en.wikipedia.org/wiki/World_population), sobre los 10 países más densamente poblados en el mundo."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a_dkw4kJ-jzm"
      },
      "source": [
        "# Podemos importar tablas que estén en páginas Web como wikipedia\n",
        "tabla_poblacion = pd.read_html('https://en.wikipedia.org/wiki/World_population', \n",
        "                            match = '10 most densely populated countries')\n",
        "\n",
        "df_poblacion = tabla_poblacion[0].set_index('Country')\n",
        "df_poblacion"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "orngfmWGaZHu"
      },
      "source": [
        "## Series y DataFrames.\n",
        " \n",
        "Como ya mencionamos, una Series se puede entender como una **tabla con una sola columna**, aunque también puedes verla como una lista donde cada elemento tiene una etiqueta, un **índice** el cual por default es un número entero de la posición del elemento.\n",
        " \n",
        "<center>\n",
        "    <img width=\"12%\" src=\"https://pandas.pydata.org/docs/_images/01_table_series.svg\">\n",
        "</center>\n",
        "Para crear una serie partiendo de una lista:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-JBIpGSVM5zQ"
      },
      "source": [
        "serie = pd.Series(['Hola', 3.1416, 'A'])\n",
        "\n",
        "# Imprimimos la serie que creamos\n",
        "print(serie)\n",
        "\n",
        "# Información de la serie\n",
        "print(\"\\nTipo de dato: \", type(serie))\n",
        "print(\"Tamaño: \", serie.size)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fhhAhDF5bMM3"
      },
      "source": [
        "Observamos cómo cada elemento de la lista ahora tiene un índice. Podemos especificar el índice explícitamente: "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K10hkWJrbWmq"
      },
      "source": [
        "serie = pd.Series(data = ['Aaa', 'Bbb', 'Ccc'], \n",
        "                  index = ['Elemento 1', 'Elemento 2', 'Elemento 2'])\n",
        " \n",
        "print(serie)\n",
        " \n",
        "# Podemos obtener un elemento con su índice\n",
        "print(serie['Elemento 1'])\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dwkmLggUM5sO"
      },
      "source": [
        "Los **DataFrames** son más complejos que las Series, ya que ahora tenemos una **tabla con varias columnas**. En este caso, tendremos **índices** para cada fila y también etiquetas para las **columnas**. Los valores default son también enteros que indican la posición.\n",
        " \n",
        "<center>\n",
        "    <img width=\"30%\" src=\"https://pandas.pydata.org/docs/_images/01_table_dataframe.svg\">\n",
        "</center>\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UQgL3uU8fExw"
      },
      "source": [
        "# Creemos DataFrame con una matriz aleatoria.\n",
        "df = pd.DataFrame(data = np.random.rand(3, 4))\n",
        " \n",
        "print(\"Tipo: \", type(df)) # Tipo de objeto\n",
        "print(\"Tamaño: \", df.size)  #El tamaño es igual al número de celdas\n",
        "df # Visualizamos el DataFrame completo"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fnM6Ual-lcWS"
      },
      "source": [
        "# Podemos crear DataFrames a partir de diccionarios CUADRADOS\n",
        "df_dict = pd.DataFrame({\n",
        "    'Nombre':['Juan', 'María', 'Guadalupe'],\n",
        "    'Edad':[18, 22, 34],\n",
        "    'Altura':[1.73, 1.80, 1.50],}, \n",
        "    index = ['Persona 1', 'Persona 2', 'Persona 3']) # Especificamos índice\n",
        "df_dict"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W73BhXXoysU6"
      },
      "source": [
        "Ejercicio: \n",
        "- Crea un DataFrame con una matriz de ceros con dimensión (5, 4)\n",
        "- Asigna números enteros pares como índice.\n",
        "- Asigna letras como columnas."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yUwaSH-dy84q"
      },
      "source": [
        "# To-Do\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ovp65auHM55T"
      },
      "source": [
        "## Revisando los datos.\n",
        " \n",
        "Para visualizar los datos de un DataFrame, tenemos dos opciones:\n",
        " \n",
        "```python\n",
        "# Mostramos las primeras 7 filas.\n",
        "df.head(n = 7)\n",
        " \n",
        "# Mostramos las últimas 4 filas.\n",
        "df.tail(n = 4)\n",
        "```\n",
        "Si queremos ver un DataFrame completo, lo ponemos solo en una celda.\n",
        " \n",
        "```python\n",
        "# Para ver todo el DataFrame\n",
        "df\n",
        "```\n",
        "Si el DataFrame es muy grande, no se podrá visualizar completo. Veamos los primeros tres y los últimos cuatro elementos del DataFrame de los datos que cargamos del Titanic.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xn3YfBSlM5_s"
      },
      "source": [
        "df_titanic.head(n = 3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rV_TP6dUon5J"
      },
      "source": [
        "df_titanic.tail(n = 4)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SG3-VF49tzAT"
      },
      "source": [
        "Además de consultar partes del DataFrame, también podemos consultar las etiquetas en las **filas** y las **columnas**, así como todos los **valores** del DataFrame.\n",
        " \n",
        "```python\n",
        "columnas = df.columns  # Obtenemos columnas\n",
        "indice = df.index  # Obtenemos filas\n",
        "valores = df.values  # Obtenemos valores\n",
        "```\n",
        "Veamos un ejemplo de esto:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BJQX6Su5uc55"
      },
      "source": [
        "columnas = df_dict.columns\n",
        "filas = df_dict.index\n",
        "valores = df_dict.values\n",
        "\n",
        "print('Columnas: ', columnas, '\\nFilas: ', filas)\n",
        "print(valores, type(valores))  # Los valores son una matriz de NumPy!!\n",
        "\n",
        "df_dict   # Recordamos el DataFrame de donde obtenemos estos valores"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7zzgbT7B0Qo9"
      },
      "source": [
        "Finalmente, cuando tenemos un conjunto de datos, nos será útil hacer un análisis inicial (exploratorio) de los datos. Si consideramos que en las columnas tenemos **variables** y en las filas distintos registros de estas, podemos obtener valores de interés con: \n",
        " \n",
        "```python\n",
        "# Describimos en general el DataFrame\n",
        "df.describe()\n",
        "```\n",
        "Por ejemplo, obtenemos una descripción del DataFrame de la densidad poblacional:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GKrr4_3T0Pgo"
      },
      "source": [
        "df_poblacion.describe()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4KCcaNPmI96x"
      },
      "source": [
        "Obtenemos valores de interés de las variables, como el valor máximo, valor mínimo, media, etc. Pero, ¿qué pasa si tenemos las variables en las filas?. Podemos **trasponer** el DataFrame, de manera similar a lo que se hizo en el módulo de NumPy:\n",
        " \n",
        "```python\n",
        "# Trasponemos un dataframe y guardamos el resultado\n",
        "df_traspuesto = df.T\n",
        "```\n",
        "Por ejemplo:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yxKmkK6NJwnD"
      },
      "source": [
        "df_poblacion_traspuesto = df_poblacion.T\n",
        "df_poblacion_traspuesto"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KtzwM_0AM6GG"
      },
      "source": [
        "## Selección de datos por etiqueta.\n",
        " \n",
        "Podemos seleccionar una o varias **columnas** específicas de un DataFrame utilizando las etiquetas. Se crea un nuevo **DataFrame** con las columnas especificadas. \n",
        " \n",
        "<center>\n",
        "    <img width=\"60%\" src=\"https://pandas.pydata.org/docs/_images/03_subset_columns.svg\">\n",
        "</center>\n",
        " \n",
        "De manera similar, podemos seleccionar **filas** utilizando el índice. Podemos seleccionar una o varias filas y se crea también un nuevo **DataFrame**\n",
        " \n",
        "<center>\n",
        "    <img width=\"70%\" src=\"https://pandas.pydata.org/docs/_images/03_subset_rows.svg\">\n",
        "</center>\n",
        " \n",
        "Para seleccionar utilizando las **etiquetas** (nombres de filas y columnas) usamos el método **loc()**. Funciona como sigue:\n",
        " \n",
        "```python\n",
        "# Seleccionamos una sola columna.\n",
        "serie_columna = df.loc[:, ['Columna1']]\n",
        " \n",
        "# Seleccionamos más de una columna.\n",
        "df_columnas = df.loc[:, ['Columna1','Columna2']]\n",
        " \n",
        "# Seleccionamos más de una fila.\n",
        "df_filas = df.loc[['Indice1', 'Indice2'], :]\n",
        "```\n",
        "Es importante notar que esta selección no afecta al DataFrame original, y que además lo que no se selecciona se conserva (por ejemplo, al seleccionar una sola columna, el nuevo DataFrame conserva todas las filas). Veamos un ejemplo con los datos de densidad poblacional.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Z-9dVIP5xHCy"
      },
      "source": [
        "# Seleccionamos dos columnas\n",
        "rank_densidad = df_poblacion.loc[:,['Rank', 'Density(pop/km2)']]\n",
        "rank_densidad.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xGDmr62wxQVO"
      },
      "source": [
        "# Seleccionamos una sola columna\n",
        "poblacion = df_poblacion.loc[:,['Population']]\n",
        "poblacion "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kOzDXJkVzo0y"
      },
      "source": [
        "# Seleccionamos solo 3 países (3 filas)\n",
        "paises_seleccionados = df_poblacion.loc[['India', 'Taiwan', 'Haiti'],:]\n",
        "paises_seleccionados"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GghoO0aHWhqZ"
      },
      "source": [
        "También puedes seleccionar al mismo tiempo columnas y filas:\n",
        "\n",
        "<center>\n",
        "    <img width=\"70%\" src=\"https://pandas.pydata.org/docs/_images/03_subset_columns_rows.svg\">\n",
        "</center>\n",
        "\n",
        "Ejercicio: \n",
        "- Del DataFrame de densidad poblacional, filtra las columnas de población y área, y las filas de Singapore, Bangladesh y Lebanon. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Lwwj6bzxe2GS"
      },
      "source": [
        "# To-Do\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tuD5iy6gfp9k"
      },
      "source": [
        "Finalmente, puedes obtener una única celda de dos maneras:\n",
        "\n",
        "```python\n",
        "dato = df.loc['Fila', 'Columna']\n",
        "dato = df.at['Fila', 'Columna'] # Lo mismo, pero más rápido\n",
        "```\n",
        "Por ejemplo, obtenemos la densidad poblacional de la India:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6f91qlAxgarO"
      },
      "source": [
        "densidad_india = df_poblacion.at['India', 'Density(pop/km2)']\n",
        "print(densidad_india)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uhYn4toLNot3"
      },
      "source": [
        "## Selección de datos por posición.\n",
        " \n",
        "En la sección anterior, seleccionamos dado a **etiquetas**, esto es, con los nombres de las filas y las columnas. Podemos hacer lo mismo pero está vez con la **posición**. Para esto, en lugar de **loc()** y **at()**, usamos **iloc()** y **iat()**. \n",
        " \n",
        "```python\n",
        "# Seleccionamos las primeras 2 columnas.\n",
        "df_columnas = df.iloc[:, 0:1]\n",
        " \n",
        "# Seleccionamos las últimas 3 filas\n",
        "df_filas = df.iloc[-3:, :]\n",
        " \n",
        "# Elemento unico\n",
        "dato = df.iat[0, 0]\n",
        "```\n",
        "Retomamos el ejemplo con la densidad de población.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AHk_654sNozk"
      },
      "source": [
        "poblacion_area = df_poblacion.iloc[:, 1:3]\n",
        "poblacion_area.head(3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eSpR6VgmkAds"
      },
      "source": [
        "tres_paises = df_poblacion.iloc[-3:, :]\n",
        "tres_paises"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v5KjssyWkoAb"
      },
      "source": [
        "dato = df_poblacion.iat[3, 3]\n",
        "print(dato)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MeiC0lYQlUJF"
      },
      "source": [
        "Ejercicio: \n",
        "- Del DataFrame del Titanic, filtra y quédate solo con columnas y filas pares."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Mb7xZTJSlUy6"
      },
      "source": [
        "# To Do"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R7wnDW31No5V"
      },
      "source": [
        "## Operaciones básicas: Estadísticos.\n",
        " \n",
        "Como se ha mencionado anteriormente, en cada columna normalmente se tendrá una **variable**, como nombres, edad, etc. y en cada fila habrá un registro de esa variable. Hay diversos **estadísticos** que podemos calcular para conocer más sobre la variable y como se comporta. Por ejemplo, si suponemos que una variable sigue un comportamiento normal, entonces conocer su media (promedio) $\\mu$ y su desviación estándar $\\sigma$ nos será de mucha utilidad. Si $\\mu = 10$ y $\\sigma = 3$, tenemos:\n",
        " \n",
        "<center>\n",
        "    <img width=\"40%\" src=\"https://i.imgur.com/aqUvIQK.png\">\n",
        "</center>\n",
        " \n",
        "Si quieres ver como hacer una gráfica como esta con Python, visita este [link](https://gist.github.com/GabrielMissael/6987ffd5e7fd83e2906ae201245d847b#file-normal_dist-py). Ya obtuvimos algunos valores con **.describe()**, y ahora veremos algunas otras funciones útiles.\n",
        " \n",
        "```python\n",
        "# Obtenemos la media de todas las columnas\n",
        "promedios = df.mean()\n",
        " \n",
        "# Media de una sola columna usando .loc()\n",
        "promedio = df.loc[:,'Columna1'].mean()\n",
        " \n",
        "# Podemos usar describe() en solo una sección del df\n",
        "descripcion = df.iloc[0:15, [2, 4]]\n",
        " \n",
        "# También podemos obtener la desviación estándar\n",
        "stds = df.std()\n",
        " \n",
        "# Valores mínimos y máximos\n",
        "maxs = df.max()\n",
        "mins = df.min()\n",
        "```\n",
        "Obtengamos algunos valores del dataframe de las casas de California:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gdqnp3gxn26h"
      },
      "source": [
        "# Promedio de población en cada sección\n",
        "promedio_poblacion = df_casas.loc[:,'population'].mean()\n",
        "promedio_poblacion"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1wwIh691oAmf"
      },
      "source": [
        "# Desviaciones estándar de cada variable\n",
        "stds = df_casas.std()\n",
        "stds"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hvCQIiLzoc9Z"
      },
      "source": [
        "# Obtenemos el intervalo de las variables\n",
        "mins = df_casas.min()\n",
        "maxs = df_casas.max()\n",
        "intervalo = maxs-mins\n",
        "intervalo"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xT9hcuKJNpEq"
      },
      "source": [
        "## Operaciones básicas: Apply.\n",
        " \n",
        "En muchas ocasiones, no sólo estaremos interesados en consultar o describir los datos, si no también en **operarlos**. Podemos aplicar funciones a los datos para obtener valores de interés. Para esto, usamos **.apply()**.\n",
        " \n",
        "```python\n",
        "# Aplicamos la función seno a los datos\n",
        "df_seno = df.apply(np.sin)\n",
        "```\n",
        "Veamos un ejemplo:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8csO2fqGNpKT"
      },
      "source": [
        "df_seno = df_poblacion.apply(np.sin)\n",
        "df_seno.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Whmh__Y7pgPq"
      },
      "source": [
        "En este caso no tiene mucho sentido aplicar $sin(x)$ a datos de población y área; \n",
        " \n",
        "**Ejercicio**\n",
        "Queremos conocer la densidad de los países el siguiente año. Si suponemos que la población de todos crecerá un $5\\%$, entonces:\n",
        "- Calcula la nueva población y actualiza esta columna."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WU4HNrheqRKL"
      },
      "source": [
        "# TO DO\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AiPyGKEuNpO2"
      },
      "source": [
        "## Unión de datos: Concatenación\n",
        " \n",
        "Podemos unir dos DataFrames. Si ambos comparten columnas, entonces será como agregar más filas al final: \n",
        " \n",
        "<center>\n",
        "    <img width=\"70%\" src=\"https://pandas.pydata.org/docs/_images/08_concat_row.svg\">\n",
        "</center>\n",
        " \n",
        "Si se tienen algunas columnas diferentes, el DataFrame final tendrá columnas extra y **valores faltantes** (aunque también puedes elegir eliminar las columnas que no coinciden).\n",
        " \n",
        "Para esto, usamos: \n",
        " \n",
        "```python\n",
        "# Unimos dos DataFrames.\n",
        "df_nuevo = pd.concat([df1, df2])\n",
        "```\n",
        "Veamos algunos ejemplos:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CrvItaXLNpTV"
      },
      "source": [
        "df1 = pd.DataFrame(data = np.random.rand(3, 3), \n",
        "                   columns = ['A', 'B', 'C'])\n",
        "df1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9mnXjswntWSj"
      },
      "source": [
        "df2 = pd.DataFrame(data = np.random.rand(2, 3), \n",
        "                   columns = ['A', 'B', 'C'], \n",
        "                   index = ['Elemento 1', 'Elemento 2'])\n",
        "df2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "963a_Iufta1Z"
      },
      "source": [
        "df3 = pd.DataFrame(data = np.random.rand(2, 3), columns = ['A', 'B', 'D'])\n",
        "df3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fNSbIP_6t5w4"
      },
      "source": [
        "df = pd.concat([df1, df2])\n",
        "df"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iTBCR7IGuCE0"
      },
      "source": [
        "# Outer o inner\n",
        "df = pd.concat([df1, df3], join = 'outer')\n",
        "df"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NbRrO25Tx7MF"
      },
      "source": [
        "Ejercicio: \n",
        "- A partir del dataframe que creaste con la nueva población, crea uno nuevo pero con la densidad poblacional correcta."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GGZHlRnhOfCg"
      },
      "source": [
        "# To-Do\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LNrJfQTXyJsD"
      },
      "source": [
        "## Bonus: Gráficas en pandas.\n",
        "\n",
        "Podemos gráficar fácilmente los datos en un DataFrame:\n",
        "\n",
        "```python\n",
        "# Gráfica de linea\n",
        "df.plot(x = 'Columna1', y = 'Columna2')\n",
        "\n",
        "# Gráfica de puntos\n",
        "df.plot.scatter(x = 'Columna1', y = 'Columna2')\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TkjKQeXdyi5g"
      },
      "source": [
        "df_poblacion.plot(x = 'Rank', y = 'Density(pop/km2)')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jQQNMEFHyiwz"
      },
      "source": [
        "df_casas.plot.scatter(x = 'population', y = 'total_rooms', alpha = 0.5)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7Sv-GME3nPON"
      },
      "source": [
        "-----\n",
        "> Contenido creado por **Missael Barco** ([CdeCMx](https://clubesdeciencia.mx/) / [Future Lab](https://futurelab.mx/), 2021) <br>\n",
        "> Contacto: [@GMissaelBarco](https://twitter.com/GMissaelBarco), missaelgabo@gmail.com\n"
      ]
    }
  ]
}