notebooks/04_Funciones_y_módulos.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "04-Funciones y módulos",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyO/Jykojt4HHcbxYNPzmQSf",
      "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/04_Funciones_y_m%C3%B3dulos.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 qué son y cómo se pueden crear funciones en Python, así como entender cómo funciona importar módulos que contienen cierta funcionalidad. Los contenidos específicos a cubrir en este cuaderno interactivo son los siguientes:\n",
        "\n",
        "#### A. Funciones\n",
        "1. Sintaxis\n",
        "2. Parámetros de una función\n",
        "3. Retorno de una función\n",
        "\n",
        "#### B. Módulos\n",
        "1. Importar paqueterías\n",
        "2. Ejemplos"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zJbeRnwXM_JN",
        "colab_type": "text"
      },
      "source": [
        "## A. Funciones\n",
        "\n",
        "La sintaxis de una función es muy sencilla. Para el nomberamiento, las funciones comparten las reglas que tienen las variables. Sin embargo, un detalle importante es anteponer la palabra reservada `def`, pues es la que especificará que se trata de una función. Una vez que hayamos especificado el nombre de la función, añadiremos los parámetros necesarios entre paréntesis y a continuación añadiremos el bloque de código que realizará la función, seguida de dos puntos para iniciar el bloque.\n",
        "\n",
        "Podemos ver un ejemplo sencillo de la sintaxis a continuación:\n",
        "\n",
        "```python\n",
        "def ejemplo_de_funcion():\n",
        "    print(\"Hola.\")\n",
        "```\n",
        "\n",
        "Una vez que hayamos definido una función, será necesario llamar o invocar a la función para que se ejecute:\n",
        "\n",
        "```python\n",
        "ejemplo_de_funcion()\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jaOJR7MxViqu",
        "colab_type": "text"
      },
      "source": [
        "Intentemos ejecutar una función que imprima una suma. Comenzaremos definiendo la función:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CsmOPLMRVwnE",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def primer_intento_de_suma():\n",
        "    print(1 + 2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CP4dh0PxV5ls",
        "colab_type": "text"
      },
      "source": [
        "Ahora procedemos a llamar o invocar a dicha función:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7D6CSfjZV9DJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "primer_intento_de_suma()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0Z5YuG4eV_-f",
        "colab_type": "text"
      },
      "source": [
        "Notemos que queremos que no siempre nos devuelva el resultado de sumar 1 y 2, sino que podamos de alguna manera especificar qué variables queremos operar. Es aquí donde entran los argumentos o parámetros de una función."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N7_SuyjnWNnL",
        "colab_type": "text"
      },
      "source": [
        "### Parámetros de una función\n",
        "\n",
        "Si prestamos atención, ya hemos utilizado algunas funciones hasta ahora. Un ejemplo es la función `print`, a la que dentro de los paréntesis le especificamos un parámetro (o parámetros) que queremos que imprima. De esta misma manera podemos especificar parámetros a nuestras funciones dentro de los paréntesis. \n",
        "\n",
        "Volviendo al ejemplo de la función que suma, podemos hacer que la función imprima el resultado de sumar dos variables cualesquiera:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "goWZoU0iWstC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def segundo_intento_de_suma(a, b):\n",
        "    print(a + b)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3sRciF_nWw6c",
        "colab_type": "text"
      },
      "source": [
        "Notemos que dentro de los paréntesis de la definición de la función hemos especificado los parámetros que utiliza una función para operar. Ahora invoquemos tres veces la función con valores numéricos distintos:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WCPCnarJW8eX",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "segundo_intento_de_suma(1, 2)\n",
        "segundo_intento_de_suma(5, 8)\n",
        "segundo_intento_de_suma(1, -3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p61b4NljXFZ_",
        "colab_type": "text"
      },
      "source": [
        "Como podemos ver, cada llamada a la función con distintos parámetros nos devuelve el resultado correspondiente."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JE-tvJ4UVSa1",
        "colab_type": "text"
      },
      "source": [
        "**Ejercicio:** Crea una función llamada `imprime_producto`, que reciba 2 parámetros `a` y `b`, y que **imprima** el producto `a * b`."
      ]
    },
    {
      "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": "L78z72yBdGI8",
        "colab_type": "text"
      },
      "source": [
        "### Retorno de una función\n",
        "\n",
        "Para finalizar esta sección, hace falta comprender sobre el retorno de una función; y es que si quisiéramos generalizar el empaquetar funcionalidad de manera modular para que podamos reproducir un proceso, será necesario entender esto.\n",
        "\n",
        "Una función, como hemos visto hasta ahora, empaqueta un bloque de código que podemos invocar al llamar a la función. Hasta ahora ya sabemos que se le pueden pasar argumentos de **entrada** pero comprendamos cómo podemos obtener variables resultantes de **salida**.\n",
        "\n",
        "Una función cuenta con una palabra reservada `return`, que cuando llamamos a una función y encuentra dicha palabra, la función termina su ejecución sin importar que haya código dentro de la función más abajo de dicha palabra. La palabra reservada `return` nos permite especificar qué se retorna de salida dentro de una función, por ejemplo:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BWeevLAteKOg",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def tercer_intento_de_suma(a, b):\n",
        "    resultado = a + b\n",
        "    return resultado"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nh6HuF3_eQSa",
        "colab_type": "text"
      },
      "source": [
        "Esta función permite retornar un valor resultante al llamar a la función, por lo que podemos igualar la función a una variable donde queremos que se guarde el resultado:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zub7izDSeZXc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a_mas_b = tercer_intento_de_suma(23, 45)\n",
        "print(a_mas_b)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iaoHD-f_efq_",
        "colab_type": "text"
      },
      "source": [
        "Como podemos ver, el poner un retorno de función nos permite almacenar el resultado de la suma en la variable `a_mas_b`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "liJ-QX9Menmr"
      },
      "source": [
        "**Ejercicio:** Crea una función llamada `retorna_producto`, que reciba 2 parámetros `a` y `b`, y que **retorne** el producto `a * b`.\n",
        "\n",
        "Llama a la función para distintos valores e imprime los resultados."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "M6Afqv8JeqBU",
        "colab": {}
      },
      "source": [
        "# Escribe tu código aquí\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q8KLZEere1Mv",
        "colab_type": "text"
      },
      "source": [
        "> **Nota:** Crear funciones nos permite estructurar código reutilizable. Por ejemplo, si tengo una lista de diccionarios que contiene un directorio de senadores y tengo el procesamiento que nos permite acceder a información uno de ellos, podemos crear una función y procesar la información de todos de la misma manera.\n",
        "> \n",
        "> Evaluemos lo anterior y creamos el directorio:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oVpQnb4wfV29",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "directorio = [\n",
        "    {\n",
        "        \"nombre\": \"José López\",\n",
        "        \"edad\": 34,\n",
        "        \"municipio\": \"León\",\n",
        "        \"partido\": \"Partido del Verdadero Cambio\",\n",
        "        \"sesiones\": 56,\n",
        "        \"asistencias\": 20\n",
        "    },\n",
        "    {\n",
        "        \"nombre\": \"Jimena Macías\",\n",
        "        \"edad\": 25,\n",
        "        \"municipio\": \"León\",\n",
        "        \"partido\": \"Partido del Verdadero Cambio\",\n",
        "        \"sesiones\": 56,\n",
        "        \"asistencias\": 48\n",
        "    },\n",
        "    {\n",
        "        \"nombre\": \"Mariana Andrade\",\n",
        "        \"edad\": 28,\n",
        "        \"municipio\": \"León\",\n",
        "        \"partido\": \"Partido del Cambio Oportuno\",\n",
        "        \"sesiones\": 56,\n",
        "        \"asistencias\": 40\n",
        "    },\n",
        "    {\n",
        "        \"nombre\": \"Mario Pérez\",\n",
        "        \"edad\": 26,\n",
        "        \"municipio\": \"León\",\n",
        "        \"partido\": \"Partido del Cambio Oportuno\",\n",
        "        \"sesiones\": 56,\n",
        "        \"asistencias\": 54\n",
        "    }\n",
        "]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FhosS112fx6B",
        "colab_type": "text"
      },
      "source": [
        "Ahora creamos una función que nos indicará si del total de las sesiones (56) los senadores han asistido al menos al 70% de las mismas:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K5GBHZIPf6B9",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def verifica_asistencias(senador, porcentaje_esperado):\n",
        "    total = senador['sesiones']\n",
        "    asistencias = senador['asistencias']\n",
        "\n",
        "    # Efectuamos una regla de 3 para calcular\n",
        "    # el porcentaje de asistencia\n",
        "    porcentaje_real = asistencias * 100 / total\n",
        "    \n",
        "    if porcentaje_real >= porcentaje_esperado:\n",
        "        mensaje = \"Ha cumplido con el porcentaje de asistencias.\"\n",
        "    else:\n",
        "        mensaje = \"NO ha cumplido con el porcentaje de asistencias.\"\n",
        "    \n",
        "    return mensaje"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k4wFHiF-gfJ0",
        "colab_type": "text"
      },
      "source": [
        "Y con esta función, de manera muy sencilla podemos iterar el directorio de funcionarios:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "85Uj7jDZgPl0",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "n = len(directorio)\n",
        "for index in range(n):\n",
        "    asistencia = verifica_asistencias(directorio[index], 75)\n",
        "    print(asistencia)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i6w4eXE4PFLM",
        "colab_type": "text"
      },
      "source": [
        "## B. Módulos\n",
        "\n",
        "En Python existen muchas bibliotecas de funcioncioes y paquetes para funcionalidad específica, por ejemplo para realizar análisis de datos, gráficos y visualizaciónes interactivas, modelar datos astrofísicos, procesar imágenes, etcétera.\n",
        "\n",
        "En particular, estos paquetes están formados por distintos módulos, que contienen funciones y objetos útiles para su tema.\n",
        "\n",
        "Python ya cuenta con algunos módulos parte de su biblioteca estándar de funciones, que nos permiten trabajar con diferentes cosas como números aleatorios, medición del tiempo, operaciones matemáticas más elaboradas, entre otras cosas."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0LlMWbuXy2Co",
        "colab_type": "text"
      },
      "source": [
        "### Importar módulos\n",
        "\n",
        "Primero, necesitamos saber qué módulos existen, y la maner más sencilla es echar un vistazo a la documentación de Python.\n",
        "\n",
        "> Exploremos la `stdlib` de Python: https://docs.python.org/3/library/\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3ZNvy4CgzYRP",
        "colab_type": "text"
      },
      "source": [
        "Ahora que conocemos algunos módulos que tiene Python, podemos proceder a importar alguno.\n",
        "\n",
        "Lo primero que necesitamos saber es la sintaxis para hacerlo, por ejemplo si sabemos que existe el módulo `math`, la manera más sencilla es importar tódo el módulo:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NCOkRJULPGsO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import math"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JuZTW39EzmAT",
        "colab_type": "text"
      },
      "source": [
        "Lo anterior nos permitirá acceder a todas las funciones que tiene el módulo math, por ejemplo utilicemos la función factorial.\n",
        "\n",
        "Una vez que hemos importado `math`, podemos llamar directamente a la función `factorial`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GP3ah_o4zlko",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "math.factorial(3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EyLlbNI5z6e1",
        "colab_type": "text"
      },
      "source": [
        "Notemos que hemos importado la función colocando un punto después del nombre del módulo. \n",
        "\n",
        "Otra manera de hacer esto es importando `math` de otra manera. Veamos la siguiente sintaxis:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5HdqAjAdz573",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from math import *"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EOYGqDFH0H10",
        "colab_type": "text"
      },
      "source": [
        "Esta manera especifica que del módulo `math` importemos todas las funciones, así que esto nos ayuda a omitir el llamar a las funciones en el formato `módulo.función`. Veamos:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "337WpLQB0HQX",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "factorial(3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YKIycMZi0U_-",
        "colab_type": "text"
      },
      "source": [
        "Una última manera en la que podemos importar módulos es utilizando un alias, lo que nos ayuda a escribir código más limpio y corto. Para esto, la sintaxis que se utiliza es la siguiente:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MXojDvjx0SKL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import math as m"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m4mPrS4H0kF7",
        "colab_type": "text"
      },
      "source": [
        "En este caso utilizo el alias `m` para el módulo de `math`que tiene Python, así que podemos hacer uso de sus funciones en el formato `m.función`. Veamos:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Xi7XpMgC0jdO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "m.factorial(3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o4wceI7a0u7C",
        "colab_type": "text"
      },
      "source": [
        "### Ejemplos\n",
        "\n",
        "De esta manera hemos visto 3 formas en las que podemos importar algunos módulos y paquetes en Python. Esto nos resultará muy útil porque en las próximas sesiones estarás utilizando paquetes más robustos que permiten explorar y visualizar datos.\n",
        "\n",
        "Por ahora exploremos algunos ejemplos del módulo `random`, para crear números aleatorios."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y7yHjpzT0uJH",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import random as rnd"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vww-YRu81EvT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def lanza_dado():\n",
        "    num = rnd.randint(1, 6)\n",
        "    return num"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aSBOZ3oE1LgJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "dado_1 = lanza_dado()\n",
        "dado_2 = lanza_dado()\n",
        "\n",
        "print(\"Dado 1:\", dado_1)\n",
        "print(\"Dado 2:\", dado_2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fHNdS3CS1PaA",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def lanza_dados(n_dados):\n",
        "    total = 0\n",
        "    \n",
        "    for i in range(n_dados):\n",
        "        total = total + lanza_dado()\n",
        "    \n",
        "    return total"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MKZROg2C19o6",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "dados = lanza_dados(2)\n",
        "print(dados)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "LruuyYtG2Jko"
      },
      "source": [
        "**Ejercicio:** Crea una función llamada `lanza_dado(N)`, que reciba 1 parámetro `N` donde `N` es el número de caras del dado.\n",
        "\n",
        "> **Pista:** Usa `randint(a, b)` con `a = 1` y `b = N` para que el número aleatorio que te devuelva sea un valor entre 1 y N, el número de caras del dado."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Bijn9E9P2DE1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Escribe tu código aquí\n"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}