sesion4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d0a26e32-d974-47d0-b3f0-3b4b7043696a",
   "metadata": {},
   "source": [
    " # Sesion 4 : \n",
    "   ## - Biblioteca de Pandas\n",
    "   ## - Dataframes de Pandas"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d6ca512-a781-41a0-9a6a-03c29d4e8712",
   "metadata": {},
   "source": [
    "##########################################################"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f15efc64-2165-4042-b7db-bce2a07588d9",
   "metadata": {},
   "source": [
    "## 1. Biblioteca de Pandas\n",
    "Pandas es una biblioteca de Python de análisis y manipulación de datos de alto rendimiento. Define nuevas estructuras de datos basadas en los arrays de la librería NumPy pero con nuevas funcionalidades.\n",
    "\n",
    "Lo que hace que pandas sea tan atractivo es la potente interfaz para acceder a registros individuales de la tabla, el manejo adecuado de valores perdidos y las operaciones de bases de datos relacionales entre DataFrames.\n",
    "\n",
    "[Biblioteca Pandas](https://pandas.pydata.org/docs/user_guide/10min.html) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ae5af34a-a052-4182-8cab-51d05bbc539c",
   "metadata": {},
   "outputs": [],
   "source": [
    "### Dos tipos de datos importantes definidos por pandas son Series y DataFrame.\n",
    "\n",
    "Puede pensar en una serie como una “columna” de datos, como una colección de observaciones sobre una sola variable.\n",
    "\n",
    "Un DataFrame es un objeto para almacenar columnas de datos relacionadas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ba10cbe5-6a8f-4ecd-8617-8571f0ecd194",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. Importa la biblioteca Pandas\n",
    "import pandas as pd\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e244a53b-2af2-40a5-ad03-1974f24d3e67",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2. Lea un archivo de datos de valores separados por comas (CSV) con pd.read_csv\n",
    "# Asigne el resultado a una variable llamada \"data\" para almacenar los datos que se leyeron. \n",
    "# La variable data sera nuestra DataFrame\n",
    "data = pd.read_csv('data/gapminder_gdp_oceania.csv')\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71e6fef4-e346-471a-9e3e-20b100b34e55",
   "metadata": {},
   "source": [
    "* Si los datos se encuentran en un fichero o base de datos se deben usar las funciones propias como read_csv, read_excel, read_json o read_html segun corresponda.\n",
    "* Las columnas en un dataframe son las variables observadas, y las filas son las observaciones.\n",
    "* Pandas usa la barra invertida \\ para mostrar líneas ajustadas cuando la salida es demasiado ancha para caber en la pantalla."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "978f671e-c444-4d34-ae0d-20f82d7bad31",
   "metadata": {},
   "source": [
    "### Archivo no encontrado\n",
    "Estas lecciones almacenan sus archivos de datos en un subdirectorio data, razón por la cual la ruta al archivo es data/gapminder_gdp_oceania.csv. Si olvida incluir data/,**o si lo incluye pero su copia del archivo está en otro lugar**, obtendrá un runtime error que termina con una línea como esta:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5bf181ab-8898-4b3d-96e9-f4690106854d",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.read_csv('gapminder_gdp_oceania.csv')\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e97a5d1-0c60-4dce-8cc1-05de1e670827",
   "metadata": {},
   "source": [
    "### Utiliza index_col para especificar los valores de que columna deben usarse como fila de encabezado.\n",
    "* Los encabezados de fila son números (0 y 1 en este caso).\n",
    "* Indexar por país."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78082434-7aae-4b45-93a9-91add11ec561",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3. Pase el nombre de la columna a read_csv como su parámetro index_col (el indice de la tabla)\n",
    "data = pd.read_csv('data/gapminder_gdp_oceania.csv', index_col='country')\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "994e7f43-5cbd-4124-a529-82d30b1e2e85",
   "metadata": {},
   "source": [
    "### Utiliza DataFrame.info para obtener más información sobre un dataframe.\n",
    "* Para crear un DataFrame se usa la función constructora DataFrame() a la que se le proporciona una lista o diccionario con los datos a introducir.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "31ebb195-8ad1-4810-afa5-6b1f7d693282",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 4. Obtinene informacion del DataFrame \"data\" usando DataFrame.info\n",
    "data.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87220037-ff5b-495a-b988-6c85a2571cd5",
   "metadata": {},
   "source": [
    "* Este es un DataFrame\n",
    "* Dos filas llamadas 'Australia' y 'Nueva Zelanda'\n",
    "* Doce columnas, cada una de las cuales tiene dos valores de punto flotante de 64 bits.\n",
    "* Más adelante hablaremos de valores nulos, que se utilizan para representar observaciones faltantes.\n",
    "* Utiliza 208 bytes de memoria."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "229c37cb-4949-4b15-8326-08f8cd93e188",
   "metadata": {},
   "source": [
    "### El atributo DataFrame.shape muestra la forma de la matriz:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d1be1e1c-ea38-463b-a726-672928a24faf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Mostrar el numero de filas y columnas que tiene el DataFrame \"data'\n",
    "data.shape "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2c4dedc-59e0-48a7-9d07-5af2889f460d",
   "metadata": {},
   "source": [
    "### El atributo DataFrame.columns registra información sobre las columnas del dataframe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f540cb0b-e7eb-4d68-85fc-47131eae411c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5. Mostrar las informaciones de columnas y de indice.\n",
    "data.columns\n",
    "# data.index # valor vinculado a una fila"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4367c734-df1f-40d3-8e21-c9eb3c2419a2",
   "metadata": {},
   "source": [
    "* Ten en cuenta que se trata de datos, no de un método.\n",
    "* Por lo tanto, no uses () para intentar llamarlo."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5356c46-2644-4596-8783-00488389ed45",
   "metadata": {},
   "source": [
    "### Utiliza DataFrame.T para transponer el dataframe.\n",
    "* A veces se quiere tratar las columnas como filas y viceversa.\n",
    "* La transposición (escrita como .T) no copia los datos, solo cambia la vista del programa.\n",
    "* Al igual que columns, es una variable miembro."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a02dcfe2-181e-4722-9578-0bfda3ef002f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6. Transpone el DataFrame con DataFrame.T\n",
    "print(data.T)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "600ddebb-f3a7-4198-9562-207675327262",
   "metadata": {},
   "source": [
    "### Utiliza DataFrame.describe para obtener estadísticas resumidas sobre los datos.\n",
    "* DataFrame.describe() obtiene las estadísticas de resumen de solo las columnas que tienen datos numéricos. Todas las demás columnas se ignoran, a menos que use el argumento include = 'all'.\n",
    "* No es particularmente útil con solo dos registros, pero muy útil cuando hay miles."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5cf2bb33-f515-49ff-b204-13ebec4eee6d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7. Obtiene estadisticas resumidas de america con DataFrame.describe\n",
    "print(data.describe())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "863cce29-2591-4f2a-9874-865be110d508",
   "metadata": {},
   "source": [
    "### Ejercicio: Lectura de otros datos\n",
    "Lea los datos en gapminder_gdp_americas.csv (que debe estar en el mismo directorio que gapminder_gdp_oceania.csv) en una variable llamada americas y muestra sus estadísticas de resumen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "abdc0208-7316-4465-a8cf-1f01be0323cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. import pandas as pd \n",
    "import pandas as pd\n",
    "# 2. Lea un archivo de datos de valores separados por comas (CSV) con pd.read_csv('data/gapminder_gdp_americas.csv')\n",
    "# Asigne el resultado a una variable \"america\" para almacenar los datos que se leyeron\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "61459c31-81c4-4ad7-9228-7f960c277824",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3. Pase el nombre de la columna a read_csv como su parámetro index_col='country'\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4779b9c2-7905-432d-93b4-1259e9d50dfa",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 4. Obtinene informacion del DataFrame america con DataFrame.info()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9fe28ee7-fcf8-445f-b2bd-e6b87f7ef384",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Muestra la forma de america usando DataFrame.shape\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d95a776d-f10b-4916-a1e4-838c499e4350",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5. Muestra las informaciones de columnas y de indice.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3f70e01b-2040-445c-9072-ba63ab6801a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6. Transpone el DataFrame usando DataFrame.T\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bef8900c-2c47-499b-9799-9962388258d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7. Obtiene estadisticas resumidas de america usando DataFrame.describe\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d8341da-eb20-46a0-addb-1d44f53d4850",
   "metadata": {},
   "source": [
    "### DataFrame.head() \n",
    "* Podemos ver las primeras cinco filas de america ejecutando americas.head(). Podemos especificar el número de filas que deseamos ver especificando el parámetro n en nuestra llamada a americas.head().\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ae34309c-a66a-420e-9fb6-52f161183b4f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 8. Ejecute las primeras tres filas de america usando  dataframe.head(n=3) \n",
    "america.head(n=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d94fc1de-22d1-423f-8090-6c189ef27752",
   "metadata": {},
   "source": [
    "### DataFrame.tail()\n",
    "* Para ver las últimas tres filas de america, usaríamos el comando americas.tail (n = 3) , análogo a head () usado anteriormente. Sin embargo, aquí queremos ver las últimas tres columnas, que necesitamos para cambiar nuestra vista y luego usar tail(). Para hacerlo, creamos un nuevo DataFrame en el que las filas y las columnas se cambian.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "560b370f-263b-4e07-8abc-eb8ee36b0c99",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 9. Ejecute las ultimas tres filas del  DataFrame dataframe.head(n=3) \n",
    "# Creamos un nuevo DataFrame en el que las filas y las columnas se cambian usando DataFrame.T\n",
    "\n",
    "america_volteado = america.T\n",
    "america_volteado.T.tail(n=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "66c49099-d4f9-4ae3-9ee1-3104f3ff82cd",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "11744a91-f0c0-4e23-94c8-e591e5aad5e4",
   "metadata": {},
   "source": [
    "### Ejercicio\n",
    "Los datos de su proyecto actual se almacenan en un archivo llamado microbes.csv, que se encuentra en una carpeta llamada field_data. Estás haciendo un análisis en un cuaderno llamado analysis.ipynb en una carpeta llamada tesis: ¿Qué valor(es) debe pasar a read_csv para leer microbes.csv en analysis.ipynb?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73444d07-e72e-49d8-8bfa-8ca75c03183a",
   "metadata": {},
   "source": [
    "## 2. DataFrames de Pandas"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c40ef808-31c3-4ef3-873f-f96bf304b165",
   "metadata": {},
   "source": [
    "### DataFrame\n",
    "\n",
    "* Un DataFrame es una colección de Series; es una estructura de datos tabulares que se compone de columnas y filas ordenadas. \n",
    "* El DataFrame es la manera en que pandas representa una tabla y una Serie es la estructura de datos que usa Pandas para representar una columna. \n",
    "* Representa, ni más ni menos, a la típica tabla de datos de dos dimensiones, con filas y columnas. Además, cada fila y cada columna puede tener, opcionalmente, su nombre o etiqueta."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa07ff53-94fb-4e31-a551-1a60066cb1ff",
   "metadata": {},
   "source": [
    "### Seleccionando valores\n",
    "Para acceder a un valor en la posición [i, j] de un DataFrame, tenemos dos opciones, dependiendo de cuál es el significado de i en uso. Recuerda que un DataFrame proporciona un índex como una forma para identificar las filas de la tabla; Una fila, entonces, tiene una posición dentro de la tabla, así como una etiqueta, que identifica de forma única su entrada en el DataFrame."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0b1507f-ad6a-4902-bc12-e08806c32125",
   "metadata": {},
   "source": [
    "### Usa DataFrame.iloc[..., ...] para seleccionar valores por su (entrada) posición. \n",
    "* Puedes identificar la posicion por un indice numerico"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d53065e1-b900-4716-96c6-a9b304d0b9f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# import pandas as pd\n",
    "data = pd.read_csv('data/gapminder_gdp_europe.csv', index_col='country')\n",
    "print(data)\n",
    "print(data.iloc[0, 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bd81edd3-213a-4293-89fb-61d5053b7252",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(data.iloc[0, 0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f22b293-f585-4da6-b208-c2a1865f1ccd",
   "metadata": {},
   "source": [
    "### Usa DataFrame.loc[.., ..] para seleccionar valores por su (entrada) etiqueta.\n",
    "\n",
    "* Puedes especificar la posición por el nombre de la fila."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7865210b-1df9-473c-88ee-e1f94acb9dcc",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.read_csv('data/gapminder_gdp_europe.csv', index_col='country')\n",
    "print(data.loc[\"Albania\", \"gdpPercap_1952\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5cd06074-21b2-4f21-9762-bdb2ec007cdf",
   "metadata": {},
   "source": [
    "### Usa : para referirte a todas las columnas o todos los renglones.\n",
    "* Al igual que la notación de segmentación habitual de Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fd5e6aa6-fa4d-4c3d-baee-62ce14aa5480",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(data.loc[\"Albania\", :])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c1c9da9f-004b-401b-8c11-d000d1876d25",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Podría dar el mismo resultado imprimiendo \n",
    "data.loc[\"Albania\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cbad26a9-3ae7-4ffb-8cca-8049e60fd784",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Otro ejemplo\n",
    "print(data.loc[:, \"gdpPercap_1952\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b58c761f-42f3-4f78-9b87-45dadf611751",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Podría dar el mismo resultado imprimiendo \n",
    "data[\"gdpPercap_1952\"]\n",
    "# También puede dar el mismo resultado imprimiendo \n",
    "data.gdpPercap_1952 # No recomendado, porque es fácil confundir con la notación . "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "588d6f75-c7f9-42fc-95b7-9a1fb200b154",
   "metadata": {},
   "source": [
    "### Selecciona multiples columnas o filas usando DataFrame.loc y un segmento con nombre."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cf94772a-c295-468c-a9b3-35354d86914c",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.read_csv('data/gapminder_gdp_europe.csv', index_col='country')\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cd8e7181-b549-441e-b625-f1cfa6fe0d34",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(data.loc['Italy':'Poland', 'gdpPercap_1962':'gdpPercap_1972'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85a3f5e1-7fbf-4879-81c1-663c6daf5260",
   "metadata": {},
   "source": [
    "### El Resultado de los cortes pueden ser usados en otras operaciones.\n",
    "* Usualmente no solo imprimimos un corte.\n",
    "* Todos los operadores estadísticos que trabajan sobre DataFrames completos. trabajan de igual manera sobre los cortes. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bc56e6eb-7e2f-48fa-b7d6-90bd1bb67a65",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Por ejemplo, calcular el max de un corte\n",
    "print(data.loc['Italy':'Poland', 'gdpPercap_1962':'gdpPercap_1972'].max())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b759da8-173a-4bbd-923f-a50c64938507",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calcular el min de un corte\n",
    "print(data.loc['Italy':'Poland', 'gdpPercap_1962':'gdpPercap_1972'].min())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0523ae9d-9d04-41f7-b189-d0cd7ed25393",
   "metadata": {},
   "source": [
    "### Usa compariciones para seleccionar datos basados en el valor.\n",
    "* La comparación es aplicada elemento por elemento.\n",
    "* Regresa un DataFrame con una forma similar de True y False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "da7fbf37-e2b7-4bbc-843c-b863b196db07",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Usa un subconjunto de datos para mantener la salida legible.\n",
    "subset = data.loc['Italy':'Poland', 'gdpPercap_1962':'gdpPercap_1972']\n",
    "print('Subconjunto de datos:\\n', subset)\n",
    "\n",
    "# Cuales valores son más grandes que 10000 ?\n",
    "print('\\nDonde están los valores grandes?\\n', subset > 10000) #Operador Logico"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8508b70-2923-47c6-bcaa-0e4f240dcdfe",
   "metadata": {},
   "source": [
    "* Verdadero se refiere a los elementos que satisfacen la condición (mayores de 10000), y Falso se refiere a los elementos que no satisfacen la condición."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc17c2c4-d169-40f4-8d21-6d28af05b8db",
   "metadata": {},
   "source": [
    "### Selecciona valores o NaN usando una máscara Booleana.\n",
    "* Mask, Básicamente, funciona con una lista de valores booleanos (verdadero / falso), que cuando se aplica a la matriz original devuelve los elementos de interés.  \n",
    "* Obtendras el valor donde la máscara es verdadera y NaN (no es un número) donde es falsa\n",
    "* Esto es útil porque los NaNs son ignorados por operadores como max, min, average, etc.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c97e1fa-15db-4116-8d2e-5d1954ba9a47",
   "metadata": {},
   "outputs": [],
   "source": [
    "mask = subset > 10000\n",
    "print(subset[mask])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d1d3c44-9bd2-4134-88e6-ec7fd88eb9d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "#resumen stadistico\n",
    "print(subset[subset > 10000].describe())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfe96682-59bd-44e5-b4ae-dbf1460f6691",
   "metadata": {},
   "source": [
    "## Group By: cortar-aplicar-combinar\n",
    "* Los métodos de vectorización de pandas y las operaciones de agrupación son características que brindan a los usuarios mucha flexibilidad para analizar sus datos.\n",
    "\n",
    "* Por ejemplo, supongamos que queremos tener una visión más clara de cómo los países europeos se dividen según su PIB (GDP).\n",
    "\n",
    "1. Podemos echar un vistazo dividiendo los países en dos grupos durante los años encuestados, aquellos que presentaron un PIB más alto que el promedio europeo y aquellos con un PIB más bajo. \n",
    "2. Luego estimamos un puntaje de Riqueza basado en los valores históricos (de 1962 a 2007), donde contamos cuántas veces un país ha participado en los grupos de PIB más bajo o más alto\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2439fcdc-18c0-4641-848c-fb0b98e9ad22",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Crea mask _higher para otorgar un valor falso o verdadero \n",
    "# para aquellos paises que presentaron un PIB más alto que el promedio europeo \n",
    "# y aquellos con un PIB más bajo. \n",
    "mask_higher = data > data.median()\n",
    "print(mask_higher)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b7fbc379-152e-474d-82a7-2f9fa25261fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.Series([True, True, False, False]).count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b7784ad8-0690-46a7-b298-36b14fd7b3b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.Series([True, True, False, False]).aggregate(\"sum\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a89355e-ac88-4a61-ac33-ae10a17b0282",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Crea la variable wealth_score para estimar un puntaje de Riqueza basado en los valores históricos (de 1962 a 2007)\n",
    "# donde contamos cuántas veces un país ha participado en los grupos de PIB más bajo o más alto.\n",
    "wealth_score = mask_higher.aggregate(\"sum\", axis=1) / len(data.columns)\n",
    "print(wealth_score)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e610a343-c3b0-432b-b2f0-e477ba3cc77c",
   "metadata": {},
   "source": [
    "* El resultado muestra el Promedio de cuantas veces el pais observado ha estado en el grupo de los paises mas ricos \n",
    "* Donde  1 significa que ha estado todas las veces y 0 ni una sola vez.\n",
    "\n",
    "Finalmente, para cada grupo en la tabla wealth_score , nosotros sumamos sus contribuciones (financieras) a través de los años encuestados:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0fdb30e4-e485-40a0-ba72-3ef3ee710669",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "for x in data.groupby(wealth_score):\n",
    "    print(x)\n",
    "    print(\"=\"*80)\n",
    "\"\"\";"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "683ad369-5dc2-40c1-b57f-84945bf36985",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.groupby(wealth_score).sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a7466a9-b706-4e1d-93b7-6d578d9e38d7",
   "metadata": {},
   "source": [
    "* Se ha agrupado los datos segun el score de riqueza."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9180d3e-1394-4c84-a6f9-86bb86de8cab",
   "metadata": {},
   "source": [
    "### Puntos claves"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27a38213-40cc-4fd6-b8f7-28bbc8e542e2",
   "metadata": {},
   "source": [
    "* Biblioteca Pandas \n",
    "\n",
    "* Usa DataFrame.iloc[...,...]para seleccionar valores por su localización entera\n",
    "\n",
    "* Usa : solo, para referirte a todas las columnas o a todos los renglones\n",
    "\n",
    "* Selecciona múltiples columnas o filas usando DataFrame.loc y un segmento con nombre.\n",
    "\n",
    "* El resultado de cortar puede ser usado en operaciones adicionales\n",
    "\n",
    "* Usa comparaciones para seleccionar datos basados en un valor\n",
    "\n",
    "* Selecciona valores de NaN usando mascaras booleanas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2235476b-c4cd-4006-ba9a-a006f73eaa9b",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}