notebooks/03_Colecciones.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "03-Colecciones",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyPgQ/ZnG9E4frckhGvuPFYe",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/CodeandoMexico/hacking-civico/blob/master/notebooks/03_Colecciones.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zKQ6pRbHJdIT",
        "colab_type": "text"
      },
      "source": [
        "<p align=\"center\">\n",
        "<img src=\"http://codeandomexico.org/resources/img/codeandomexico.png\" width=\"500\" alt=\"Codeando México\"><br>\n",
        "<a href=\"http://www.codeandomexico.org/\" target=\"_blank\"><img src=\"https://img.shields.io/badge/website-CodeandoMexico-00D88E.svg\"></a>\n",
        "<a href=\"http://slack.codeandomexico.org/\" target=\"_blank\"><img src=\"https://img.shields.io/badge/slack-CodeandoMexico-EC0E4F.svg\"></a>\n",
        "</p>\n",
        "<!-- __ -->\n",
        "\n",
        "# Curso de Datos Abiertos y Hacking Cívico\n",
        "\n",
        "Este curso tiene como objetivo habilitar las capacidades de la ciudadanía y los servidores públicos en el uso y generación de datos abiertos para el bien común. Puedes encontrar más información [aquí](https://github.com/CodeandoMexico/hacking-civico)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Dr4r2w-ZKNuL",
        "colab_type": "text"
      },
      "source": [
        "# Python 101: Colecciones\n",
        "\n",
        "A lo largo de este Notebook se explicarán colecciones en Python. Los contenidos específicos a cubrir en este cuaderno interactivo son los siguientes:\n",
        "\n",
        "1. Listas\n",
        "2. Indexación\n",
        "3. Diccionarios\n",
        "4. Casos de uso"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zJbeRnwXM_JN",
        "colab_type": "text"
      },
      "source": [
        "## Listas\n",
        "\n",
        "Una lista es una colección ordenada de objetos, donde dichos objetos pueden ser de cualquier tipo (`int`, `float`, etc.).\n",
        "\n",
        "Las listas se crean de manera similar a una variable, respetando las reglas de nombreamiento y asignación.\n",
        "\n",
        "Para crear una lista, los elementos se ponen dentro de corchetes `[ ]`.\n",
        "\n",
        "**Veamos un ejemplo.**\n",
        "\n",
        "Supongamos que tenemos una lista de periodos (años) en los que se han estado recopilando datos de especies de árboles pertenecientes al vivero municipal de León.\n",
        "\n",
        "En este ejemplo suponfremos que los datos son almacenados en un archivo de Excel, pero para fines prácticos de este ejemplo, los cargaremos en formato de lista en Python (un poco como motivación, pues en el siguiente módulo podremos acceder a datos desde archivos estructurados)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9Wb18RJzJQVC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "periodos = [\n",
        "    '2015',\n",
        "    '2016',\n",
        "    '2017',\n",
        "    '2018'\n",
        "]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sydD6IljOpjQ",
        "colab_type": "text"
      },
      "source": [
        "Podemos imprtimir la lista completa de elementos con nuestra ya conocida función `print`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nJbABpXCOu_U",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(periodos)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QTRORgXxOxT0",
        "colab_type": "text"
      },
      "source": [
        "De este ejemplo podemos darnos cuenta que en lugar de almacenar una variable para cada periodo, podemos crear una lista que contenga a todos los periodos."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JE-tvJ4UVSa1",
        "colab_type": "text"
      },
      "source": [
        "**Ejercicio:** Crea una lista llamada `hobbies`, donde añadas cadenas de texo con tus hobbies favoritos e imprime dicha lista. Un ejemplo sería:\n",
        "\n",
        "```python\n",
        "hobbies = [\n",
        "    'leer',\n",
        "    'programar',\n",
        "    'ver series en Netflix'\n",
        "]\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6FupoYDhVqbW",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Escribe tu código aquí\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C6yowUR-Nsf8",
        "colab_type": "text"
      },
      "source": [
        "Supongamos que a la lista anterior de periodos queremos agregar dos periodos más `2019` y `2020`. Para ello, las listas tienen un método propio que se llama `append`, donde como argumento le especificamos qué más nos gustaría agregar a la lista:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6aB-DbKFPJ-D",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "periodos.append('2019')\n",
        "periodos.append('2020')\n",
        "print(periodos)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EjdTV7rZVwoh",
        "colab_type": "text"
      },
      "source": [
        "**Ejercicio:** Añade dos hobbies más a tu lista de hobbies utilizando `append` e imprime la nueva lista."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "jDPFctFIV5pp",
        "colab": {}
      },
      "source": [
        "# Escribe tu código aquí\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BLQmFRC2NC1f",
        "colab_type": "text"
      },
      "source": [
        "## Indexación\n",
        "\n",
        "Podríamos pensar en que si quisiea accesar a un periodo específico, tendría mayor ventaja el crear una variable para cada valor del periodo, **lo que nos lleva a preguntarnos de qué manera podemos acceder a un valor específico.** Esto podemos resolverlo accediendo a la información de una lista mediante **índices**.\n",
        "\n",
        "Para nuestro caso, un índice será un valor numérico que especifica la posición del elemento de una lista. Los índices inician en 0 y llegan, de este modo, hasta el número de elementos de la lista, menos 1. Para poder acceder a los elementos de una lista, especificaremos el índice entre corchetes.\n",
        "\n",
        "Por ejemplo, para imprimir el valor correspondiente al primer, segundo y cuarto elemento de nuestra lista de periodos, haremos:\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "64KxRbinP8fP",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(periodos[0]) # Primero elemento de la lista => índice 0\n",
        "print(periodos[1]) # Segundo elemento de la lista => índice 1\n",
        "print(periodos[3]) # Cuarto elemento de la lista => índice 3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vpUWoW94QhSo",
        "colab_type": "text"
      },
      "source": [
        "Los índices será muy útiles porque nos permitirán acceder a información de las listas, ya sea para obtener un dato o para modificarlo.\n",
        "\n",
        "Si quisiéramos imprimir todas las listas, podemos hacer uso de los ciclos que ya conocemos:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d1WkpWKMQcAz",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "n = len(periodos) # len devuelve la longitud de la lista\n",
        "\n",
        "for index in range(n):\n",
        "    print(periodos[index])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_erDNFzIRD2D",
        "colab_type": "text"
      },
      "source": [
        "Una ventaja de las listas, es que pueden considerarse como una representación abstracta de información tabular, ya que podemos crear listas cuyos contenidos sean listas.\n",
        "\n",
        "Un ejemplo de lo anterior sería considerar la siguiente tabla:\n",
        "\n",
        "| Periodo | Árboles |\n",
        "| ------- | ------- |\n",
        "|    2015 |     156 |\n",
        "|    2016 |     230 |\n",
        "|    2017 |     428 |\n",
        "|    2018 |     749 |\n",
        "|    2019 |     921 |\n",
        "|    2020 |    1048 |\n",
        "\n",
        "Podríamos representar esta tabla en forma de lista creando una lista de listas (esto es, una matriz) de la siguiente manera:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IUHZPRwWQ3x5",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "datos = [\n",
        "    ['2015', 156],\n",
        "    ['2016', 230],\n",
        "    ['2017', 428],\n",
        "    ['2018', 749],\n",
        "    ['2019', 921],\n",
        "    ['2020', 1048]\n",
        "]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nGXpd_JXR-gr",
        "colab_type": "text"
      },
      "source": [
        "Y como ya hemos mencionado, podemos acceder a elementos específicos utilizando índices:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U_aja0IjR8_o",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(\"Periodo:\", datos[2][0])\n",
        "print(\"# Árboles:\", datos[2][1])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pK5kit_NWGNs",
        "colab_type": "text"
      },
      "source": [
        "**Ejercicio:** Considera la siguiente tabla con datos sobre escolaridad en jóvenes:\n",
        "\n",
        "| Periodo | Jóvenes (18-29) | % con estudios universitarios |\n",
        "| ------- | --------------- | ----------------------------- |\n",
        "|    2015 |          256000 |                          46.0 |\n",
        "|    2016 |          330000 |                          48.5 |\n",
        "|    2017 |          385000 |                          56.3 |\n",
        "|    2018 |          476000 |                          49.0 |\n",
        "|    2019 |          605000 |                          57.2 |\n",
        "|    2020 |          870000 |                          62.4 |\n",
        "\n",
        "- Crea una lista de listas que se llame `escolaridad` y que contenga la información de la tabla.\n",
        "- Utiliza un ciclo para iterar sobre los contenidos de dicha lista.\n",
        "\n",
        "> **Pista:** Para saber cuántos elementos puedes iterar, utilizar la función `len` será de gran ayuda. Por ejemplo, si haces `n = len(escolaridad)`, `n` contendrá la cantidad de filas de la tabla (o número de elementos en la lista) y `m = len(escolaridad[0])` el número de columnas (o número de elementos por renglón)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "Iegta3chYCcA",
        "colab": {}
      },
      "source": [
        "# Escribe tu código aquí\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gqAgfhV-JtRc",
        "colab_type": "text"
      },
      "source": [
        "> **Nota:** Además de la indexación, existe otra manera de iterar los contenidos de una lista, y es utilizando una variable que va tomando el valor de los contenidos de una lista, por ejemplo:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZjHxn704J3Gb",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "comite_evaluador = [\n",
        "    'José López',\n",
        "    'Jimena Macías',\n",
        "    'Mariana Andrade',\n",
        "    'Mario Pérez'\n",
        "]\n",
        "\n",
        "for miembro in comite_evaluador:\n",
        "    print(miembro)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WictP7M0YDHG",
        "colab_type": "text"
      },
      "source": [
        "## Diccionarios\n",
        "\n",
        "Los diccionarios nos ayudan a mantener información de manera estructurada, sin embargo, con contenidos con un orden no necesariamente definido. \n",
        "\n",
        "A diferencia de las listas, los índices se llaman llaves y son cadenas de texto que representan el contenido o valor que albergan. Asimismo, una diferencia importante es que al no tener índices numéricos, los contenidos de un diccionario no cuentan con un orden particular.\n",
        "\n",
        "Para crear un diccionario, utilizaremos llaves (o braquets) `{ }` y definiremos sus pares de contenidos (llave-valor).\n",
        "\n",
        "**Veamos un ejemplo.**\n",
        "\n",
        "Supongamos que contamos con información de algún senador, podríamos albergar su información como sigue:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "06eXAMORSNgk",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "senador = {\n",
        "    \"nombre\": \"Juan Martínez\",\n",
        "    \"edad\": 48,\n",
        "    \"partido\": \"Partido del Verdadero Cambio\",\n",
        "    \"sesiones\": 56,\n",
        "    \"asistencias\": 48\n",
        "}\n",
        "\n",
        "print(senador)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IUqJoUqTH6ML",
        "colab_type": "text"
      },
      "source": [
        "Los diccionarios cuentan con algunos métodos que nos permiten acceder a la información de manera que podamos iterar sobre la misma, ya sea sólo extrayendo las llaves, los valores o ambos:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L4o8aVDefdA5",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Para extraer las llaves en forma de lista\n",
        "llaves = list(senador.keys())\n",
        "print(llaves)\n",
        "\n",
        "# Para extraer los valores en forma de lista\n",
        "valores = list(senador.values())\n",
        "print(valores)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MMQdE0UUIY5o",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Para iterar ambos\n",
        "for llave, valor in senador.items():\n",
        "    print(\"- Llave:\", llave) \n",
        "    print(\"- Valor:\", valor)\n",
        "    print()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S1K8OIoIJXch",
        "colab_type": "text"
      },
      "source": [
        "## Casos de uso\n",
        "\n",
        "Ya hemos visto que de manera general podemos reunir información diversa a través de colecciones, sin embargo, hay casos de uso más general, por lo que en esta parte exploraremos algunos ejemplos donde se pueden utilizar estos elementos."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lo1UKHfgKd3g",
        "colab_type": "text"
      },
      "source": [
        "### a. Bases de datos - APIs\n",
        "\n",
        "Un primer ejemplo es crear una lista de diccionarios, donde para nuestro caso crearemos un directorio de miembros de un comité electoral:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vf7IQiAwIpcf",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "directorio = [\n",
        "    {\n",
        "        \"nombre\": \"José López\",\n",
        "        \"edad\": 34,\n",
        "        \"municipio\": \"León\"\n",
        "    },\n",
        "    {\n",
        "        \"nombre\": \"Jimena Macías\",\n",
        "        \"edad\": 25,\n",
        "        \"municipio\": \"León\"\n",
        "    },\n",
        "    {\n",
        "        \"nombre\": \"Mariana Andrade\",\n",
        "        \"edad\": 28,\n",
        "        \"municipio\": \"León\"\n",
        "    },\n",
        "    {\n",
        "        \"nombre\": \"Mario Pérez\",\n",
        "        \"edad\": 26,\n",
        "        \"municipio\": \"León\"\n",
        "    }\n",
        "]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CpBobvgQSGsy",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for miembro in directorio:\n",
        "    print(\"- Nombre:\", miembro['nombre'])\n",
        "    print(\"- Edad:\", miembro['edad'])\n",
        "    print(\"- Municipio:\", miembro['municipio'])\n",
        "    print()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ubuue5XbSX4a",
        "colab_type": "text"
      },
      "source": [
        "Esta representación tiene demasiad utilidad, pues nos permite exportar el directorio en uno de los formatos estándares que se utilizan actualmente, el formato JSON.\n",
        "\n",
        "Un ejemplo de cómo/dónde se utiliza este formato es al consumir portales de datos abiertos a través de su API (protocolo que sirve datos/información). Por ahora no es necesario comprender a profundidad esto, pues más adelante profundizarás en qués son y cómo funcionan las APIs."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jn5DchoJUdq5",
        "colab_type": "text"
      },
      "source": [
        "### b. Bases de datos - CSV\n",
        "\n",
        "Si cargásemos algún archivo CSV con información abierta, el archivo cargaría en formato de tabla, por lo que si quisiéramos extraer los valores de una columna, la columna sería extraída en formato de lista."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nHfSnPFoSV5F",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import pandas as pd\n",
        "\n",
        "df = pd.read_csv('sample_data/california_housing_test.csv')\n",
        "df.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "430teYeBUvhU",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "df[['longitude']].values.tolist()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xzaQJC65VCJ-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}