Taller_03_Funciones.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "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/gabrielawad/Fundamentos-de-Python/blob/main/Taller_03_Funciones.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## *«Todos los ríos van al mar, pero el mar no se desborda».*\n",
        "### Proverbio chino"
      ],
      "metadata": {
        "id": "Mk8dlPa97e5U"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mCkyuX8p2SYu"
      },
      "source": [
        "# Taller 03 Funciones\n",
        "En este taller aprenderá los conceptos básicos de Python 3 relativos a funciones.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w0t0Fl-Hyo_H"
      },
      "source": [
        "# Instalación del Tutor Magic\n",
        "El Tutor Magic le permitirá realizar pruebas de escritorio de sus programas.\n",
        "\n",
        "El primer paso es instalar el Tutor Magic en Google Colaboratory.\n",
        "\n",
        "La siguiente celda se debe ejecutar cada vez que abra este notebook para poder que funcione el tutor magic en Google Colaboratory"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6kexUkZ5yvPm"
      },
      "source": [
        "# Instalar el tutormagic\n",
        "!pip install tutormagic\n",
        "\n",
        "# Cargar la extensión\n",
        "%load_ext tutormagic"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WVeC9CLPn4Wk"
      },
      "source": [
        "# Funciones\n",
        "### ¿Qué es una función?\n",
        "Una función es un pedazo de código que ejecuta una serie de instrucciones que queremos utilizar frecuentemente. Para evitar reescribir estas instrucciones específicas cada vez que las vayamos a utilizar, les asignamos un nombre y posteriormente, las llamamos (o invocamos) utilizando ese nombre.\n",
        "\n",
        "Conviene definir nuestras propias funciones cuando tenemos una operación que realizamos varias veces, a modo de simplificar el código. Un buen ejemplo son las funciones de entrada y salida por consola en Python.\n",
        "\n",
        "Las funciones <b>input()</b> y <b>print()</b> son funciones propias de Python. Internamente, ellas realizan un proceso que permite leer o imprimir por consola una cadena de caracteres. Cada vez que necesitamos ingresar o mostrar un valor por consola, basta con invocar la función correspondiente.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ExHBNxFem9K_"
      },
      "source": [
        "## Funciones definidas por el usuario\n",
        "Para crear nuestras propias funciones, utilizamos la expresión def, seguida por el nombre de la función y todos los datos que recibiría, separados por comas.\n",
        "\n",
        "La estructura básica para definir una función es:\n",
        "\n",
        "\n",
        "\tdef nombre_funcion (parametro):\n",
        "\t\t'''documentacion'''\n",
        "\t  \tinstrucciones\n",
        "\t  \treturn variable"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YGOpYXbsn4Wk"
      },
      "source": [
        "# la siguiente línea activa el tutor magic para el ejemplo específico\n",
        "%%tutor --lang python3 -s\n",
        "\n",
        "# se define la función impuesto con dos parámetros: valor y porcentaje\n",
        "def impuesto(valor, porcentaje):\n",
        "  '''calcular impuestos a partir de un porcentaje'''\n",
        "  calc = valor*porcentaje/100\n",
        "  return calc\n",
        "\n",
        "# se invoca la función impuesto con los argumentos 100 (valor) y 19 (porcentaje)\n",
        "print(impuesto(100, 19))\n",
        "\n",
        "# se invoca la función impuesto con los argumentos 13500 (valor) y 19 (porcentaje)\n",
        "print(impuesto(13500, 19))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ns87DDMan4Wk"
      },
      "source": [
        "En este caso, la función se llama \"impuesto.\"  Debe de recibir el valor sobre el cual calcular el impuesto y el porcentaje a pagar para funcionar; estos se llaman los **parámetros** de la función. La función se define con la cantidad de parámetros que necesite, y estos pueden utilizarse dentro de ella libremente.\n",
        "\n",
        "Para invocar una función dentro de nuestro código, debemos de utilizar su nombre seguido por paréntesis, y debemos pasar los valores que pida la función. Al momento que pasamos valores a una función, estos toman el nombre de **argumentos**.\n",
        "\n",
        "Un **parámetro** sólo existe dentro de la función y no tiene un valor específico. Un **argumento** es lo que se le pasa a la función al momento en que esta es llamada o invocada. En el ejemplo anterior, *valor* y *porcentaje* son **parámetros** mientras que (100 y 19) o (13500, 19) son **argumentos**.\n",
        "\n",
        "Las funciones más simples, como *impuesto()*, suelen retornar un valor al programa desde el cual se invocan. Este valor debe ser asignado o utilizado inmediatamente en el código o se pierde y no podremos utilizarlo posteriormente sin volver a invocar la función."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6gM_nss8nsq6"
      },
      "source": [
        "# la siguiente línea activa el tutor magic para el ejemplo específico\n",
        "%%tutor --lang python3 -s\n",
        "\n",
        "# crear función para duplicar un valor\n",
        "def duplicar(n):\n",
        "  '''Duplicar un valor'''\n",
        "  z = n * 2\n",
        "  return z\n",
        "\n",
        "# asignar a la variable x el resultado de invocar la función duplicar\n",
        "x = duplicar(4)\n",
        "\n",
        "# mostrar el resultado obtenido\n",
        "print(x) # print es una función!"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hbb-v1-nnsrA"
      },
      "source": [
        "Generalmente, una función solo retorna valores cuando se quiere continuar manipulando los resultados dentro del programa principal. Operaciones como mostrar por pantalla no suelen necesitar un retorno de información.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E5kIyDransrB"
      },
      "source": [
        "# la siguiente línea activa el tutor magic para el ejemplo específico\n",
        "%%tutor --lang python3 -s\n",
        "\n",
        "# crear una función que invoca dos funciones incorporadas de Python\n",
        "def mi_funcion(l):\n",
        "    '''modificar una lista'''\n",
        "    n = len(l)\n",
        "    for i in range(n):\n",
        "        l[i] = l[i] + n\n",
        "    return l\n",
        "\n",
        "def combinar_listas(a, b):\n",
        "  '''Combinar dos listas'''\n",
        "  return mi_funcion(a) + mi_funcion(b)\n",
        "\n",
        "x = mi_funcion([1, 2, 3])\n",
        "\n",
        "print(\"Resultado de x:\",x)\n",
        "\n",
        "print(\"Resultado de combinar dos listas:\", combinar_listas([1,2,3,4], [8, -5, 6]))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_c2sULcynsrE"
      },
      "source": [
        "Cada vez que se ejecuta **mi_funcion()**, se invocan las funciones **len()** y **range()**, que son funciones predefinidas de Python.\n",
        "\n",
        "Esto quiere decir que, al invocar **mi_funcion()**, se interrumpe la ejecución del programa principal para ejecutar el código de **mi_funcion()**. Luego, al invocar las funciones predefinidas **len()** y **range()**, se interrumpe la ejecución de **mi_funcion()** para que estas puedan realizar sus respectivas tareas. Cuando **len()**, y posteriormente **range()**, terminan su ejecución, se regresa a la ejecución de **mi_funcion()**. Solo cuando esta termina y retorna **l** se regresa a la ejecución del programa principal.\n",
        "\n",
        "También es posible invocar funciones definidas por el usuario dentro de otra función, como se puede apreciar en el caso de **combinar_listas()**. Dentro del código de **combinar_istas()**, se invoca la previamente definida **mi_funcion()**, lo que hace que se tengan varias llamadas dentro de la ejecución."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tn07wdR8nsq6"
      },
      "source": [
        "## Funciones incorporadas (built-in) en Python\n",
        "\n",
        "El propósito principal detrás de la creación de funciones dentro de un programa es la reutilización de código, lo que lleva a mayores niveles de abstracción. Muchos lenguajes de programación tienen funciones predefinidas para las operaciones básicas de listas, tal como calcular la longitud, invertir la lista, eliminar un elemento de esta, etcétera. Otras funciones comúnmente predefinidas son las matemáticas.\n",
        "\n",
        "### Otras funciones propias de Python\n",
        "\n",
        "Python tiene muchas funciones propias que hacen alguna tarea específica. Algunas de ellas son:\n",
        "\n",
        "* <b>len()</b>: Recibe una variable y retorna la longitud de esta.\n",
        "* <b>min()</b>: Retorna el menor elemento numérico entre varios.\n",
        "\n",
        "Se invita a consultar información adicional en los siguientes enlaces:\n",
        "* [Pyhton.org Built-in Functions](https://docs.python.org/3/library/functions.html)\n",
        "* [Programiz Built-in Functions](https://www.programiz.com/python-programming/methods/built-in)\n",
        "* [w3schools Built-in Functions](https://www.w3schools.com/python/python_ref_functions.asp)\n",
        "\n",
        "Las funciones en Python generalmente tienen parámetros y realizan operaciones sobre ellos. Muchas veces, las funciones retornan un valor al programa que fue interrumpido cuando se invocaron, el cual puede ser utilizado posteriormente de la siguiente forma:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TygjdRlHU9pQ"
      },
      "source": [
        "# ejemplo de funciones incorporadas de Python\n",
        "\n",
        "def triplicar(n):\n",
        "    '''Triplica el valor de un número'''\n",
        "    return n*3\n",
        "\n",
        "def esPar(n):\n",
        "  '''Identifica números pares'''\n",
        "  y = True\n",
        "  if n%2!=0:\n",
        "    y = False\n",
        "  return y\n",
        "\n",
        "numeros =list(range(1,10))\n",
        "\n",
        "print(f\"Lista de números construida con la función range: {numeros}\")\n",
        "\n",
        "pares= list(filter(esPar, numeros))\n",
        "\n",
        "y = list(map(triplicar, numeros))\n",
        "\n",
        "print(f\"Tamaño de la lista numeros: {len(numeros)}\")\n",
        "\n",
        "print(f\"Valor mínimo de la lista numeros: {min(numeros)}\")\n",
        "\n",
        "print(f\"Valor máximo de la lista numeros: {max(numeros)}\")\n",
        "\n",
        "print(f\"Lista de números pares extraída usando la función filter: {pares}\")\n",
        "\n",
        "print(f\"Lista de números triplicados utilizando la función map: {y}\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1eKY7mGp-RYf"
      },
      "source": [
        "## Acceder a la documentación de una función\n",
        "\n",
        "Con la expresión **.\\_\\_doc\\_\\_** se puede conocer la documentación de una función sea propia o incorporada de Python"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5RLCKyf_-XeR"
      },
      "source": [
        "# con la expresión .__doc__ se puede conocer la documentación de una función\n",
        "\n",
        "# documentación de una función propia\n",
        "print(f\"Esta es la documentación de la función impuesto: \\n{impuesto.__doc__} \\n\")\n",
        "\n",
        "# documentación de una función incorporada\n",
        "print(f\"Esta es la documentación de la función abs:\\n{abs.__doc__}\\n\")\n",
        "print(f\"Esta es la documentación de la función filter:\\n{filter.__doc__}\\n\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NtjV_a2VnsrM"
      },
      "source": [
        "# Ámbito de las variables\n",
        "\n",
        "Las variables utilizadas dentro de las funciones son invisibles para el resto del código, y viceversa. Los **parámetros** (variables que necesita recibir la función y que son utilizados dentro de su cuerpo) y los ***return*** de las funciones ayudan a comunicar la ejecución del programa principal y con la función.\n",
        "\n",
        "Generalmente, al pasar una variable como **argumento** a una función, esta no es modificada independientemente de lo que le ocurra dentro de la función. Esto se conoce como pasar un argumento **\"por valor\".** En otras palabras, no se pasa la variable como tal, sino el valor de ella. Sin embargo, cuando se pasa una lista a una función, se está pasando un argumento **\"por referencia\".** Esto quiere decir que, si se modifica el valor de ese argumento dentro de la ejecución de la función, será modificado en todo el programa.\n",
        "\n",
        "En el siguiente ejemplo, se tienen dos funciones:\n",
        "* una que manipula un número entero\n",
        "* una que manipula una lista"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yEDI6BjGlV7N"
      },
      "source": [
        "## Pasar un argumento \"por valor\""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iFoXVH_rnsrN"
      },
      "source": [
        "# la siguiente línea activa el tutor magic para el ejemplo específico\n",
        "%%tutor --lang python3 -s\n",
        "\n",
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "\n",
        "# Ejemplo de pasar argumentos por valor a una función.\n",
        "\n",
        "# Los argumentos por valor son los de tipo primitivo: int, str, etc.\n",
        "def argsPorValor(n): # Pruebe a cambiar la letra n por x, evidenciara que el nombre del parámetro no importa\n",
        "    '''Duplicar un valor'''\n",
        "    n = n*2\n",
        "    print(\"x dentro de la función:\", n)\n",
        "\n",
        "x = 4\n",
        "\n",
        "print(\"x antes de la función:\", x)\n",
        "\n",
        "argsPorValor(x)\n",
        "print(\"x despues de la función:\", x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vWwj0P_0lkha"
      },
      "source": [
        "## Pasar un argumento \"por referencia\""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tryThHeunsrR"
      },
      "source": [
        "# la siguiente línea activa el tutor magic para el ejemplo específico\n",
        "%%tutor --lang python3 -s\n",
        "\n",
        "# Ejecute estas instrucciones y observe el resultado obtenido\n",
        "# Ejemplo de pasar argumentos por referencia a una función.\n",
        "# Los argumentos por referencia son los de tipo objeto (\"compuesto\"): list, dict, object, etc.\n",
        "\n",
        "def argsPorRef(l):\n",
        "    '''Cambiar el valor de la primera posición en una lista'''\n",
        "    l[0] = 30\n",
        "    print(\"y dentro de la función:\", l)\n",
        "\n",
        "y = [1,2]\n",
        "print(\"y antes de la función:\", y)\n",
        "argsPorRef(y)\n",
        "print(\"y despues de la función:\", y)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ehNJMerunsrT"
      },
      "source": [
        "Como se puede apreciar, el valor de **x** no se modifica, ya que esta fue pasada por valor. **y**, por otra parte, es modificada y **y[0]** toma el valor de 30.\n",
        "\n",
        "# Funciones anidadas\n",
        "\n",
        "Una función anidada es, como con las iteraciones o condiciones anidadas una función dentro de otra, el uso de este tipo de funciones se ve cuando en ocasiones, la implementación de una función repite fragmentos de código frecuentemente o deseamos dividir a la función en partes bien definidas.\n",
        "\n",
        "Observe la siguiente función:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sDQsnrwrnsrU"
      },
      "source": [
        "# la siguiente línea activa el tutor magic para el ejemplo específico\n",
        "#%%tutor --lang python3 -s\n",
        "\n",
        "# Se recomienda que, en caso de usar la herramienta tutor use valores pequeños para a, b\n",
        "# y numero de intervalos\n",
        "\n",
        "# función que calcula el área bajo la curva x^2 dentro del rango [a,b] --> integral de x^2 entre a y b\n",
        "def area_bajo_la_curva(a, b):\n",
        "    '''calcula el área bajo la curva x^2 dentro del rango [a,b] --> integral de x^2 entre a y b'''\n",
        "    def validar_datos(a, b):\n",
        "        '''Funcion que valida que a y b esten correctos.'''\n",
        "        if b < a:\n",
        "            print(\"b debe ser mayor que a.\")\n",
        "            return False\n",
        "        return True\n",
        "\n",
        "    def calcular_area_bajo_curva(a, b):\n",
        "        '''Calcular área bajo curva'''\n",
        "        def calcular_area_rectangular(ancho, alto):\n",
        "            '''Calcular área rectangular'''\n",
        "            return ancho * alto\n",
        "\n",
        "        if validar_datos(a, b):\n",
        "            numero_intervalos = 1000000\n",
        "            delta = (b - a) / numero_intervalos\n",
        "            x = a\n",
        "            area = 0\n",
        "            while(x<b):\n",
        "                area += calcular_area_rectangular(x**2, delta)\n",
        "                x += delta\n",
        "            return area\n",
        "\n",
        "    return calcular_area_bajo_curva(a, b)\n",
        "# Aquí comienza el código principal\n",
        "area_bajo_la_curva(0, 2)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5rFgpsA4nsrY"
      },
      "source": [
        "Fíjese en el **árbol de funciones**:\n",
        "* area_bajo_la_curva\n",
        "    * validar_datos\n",
        "    * calcular_area_bajo_curva\n",
        "        * calcular_area_rectangular\n",
        "\n",
        "**Como regla particular de las funciones anidadas:**\n",
        "* Una función puede llamar a otra siempre y cuando la función que se requiera esté en el mismo nivel o uno superior a ella.\n",
        "\n",
        "Es por esto que **calcular_area_bajo_curva** puede llamar a **validar_datos** pero **validar_datos** no puede llamar a **calcular_area_rectangular**\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QiobQZeKv6Xp"
      },
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A_qw0mOsn4Wk"
      },
      "source": [
        "# Librerías\n",
        "\n",
        "Existen librerías que han sido creadas para Python. Contienen las definiciones e instrucciones para funciones específicas que no son utilizadas en todos los casos. Las incluimos en nuestro código con la instrucción *import*, seguida del nombre de la librería. Algunos ejemplos comunes:\n",
        "\n",
        "* **math:** incluye una gran variedad de funciones matemáticas como seno, coseno, raiz cuadrada, entre muchas otras.\n",
        "* **datetime:** incluye los tipos de datos y funciones necesarias para tratar fechas dentro de Python.\n",
        "* **random:** incluye las funciones necesarias para generar números aleatorios dentro de Python.\n",
        "* **openpyxl:** incluye los tipos de datos y funciones necesarias para manipular hojas de calculo de Excel.\n",
        "\n",
        "Ejemplos de algunas funciones de las librerías **random** y **math**\n",
        "* <b>random.choice()</b>: Recibe una lista de elementos, selecciona uno al azar.\n",
        "* <b>random.randrange()</b>: A partir de un inicio y fin, selecciona un entero aleatorio en ese rango\n",
        "* <b>math.sqrt()</b>: Calcula la raíz cuadrada de un elemento.\n",
        "\n",
        "\n",
        "A continuación, se presentan las referencias oficiales de los módulos de datetime, math, random, openpyxl:\n",
        "\n",
        "* Random:  https://docs.python.org/3/library/random.html#module-random\n",
        "* Math: https://docs.python.org/3/library/math.html\n",
        "* Date y Datetime: https://docs.python.org/3/whatsnew/3.2.html#datetime-and-time\n",
        "* Openpyxl: https://openpyxl.readthedocs.org/en/latest/index.html\n",
        "\n",
        "Cuando se necesita realizar algún cálculo es útil verificar en esta documentación si ya existe una función propia de Python que lo realice por nosotros. En ocasiones también podremos encontrarnos con *operadores*, que nos facilitan dichos cálculos. Un ejemplo es común es el operador \"in\", el cual nos dice si un elemento está o no en una lista."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ea0bUsk4qRNB"
      },
      "source": [
        "### Ejemplo uso de librerías"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CnkJoVNTn4Wk"
      },
      "source": [
        "# la siguiente línea activa el tutor magic para el ejemplo específico\n",
        "#%%tutor --lang python3 -s\n",
        "\n",
        "# ---- EJEMPLO CARTA DE AMOR LOCO -------\n",
        "import random as rnd\n",
        "\n",
        "# Funcion que devuelve una palabra aleatoria de una lista de palabras\n",
        "def seleccionar_palabra(palabras):\n",
        "    '''Seleccionar las palabras a incluir'''\n",
        "    palabra_a_seleccionar = rnd.randrange(0,len(palabras))\n",
        "    return palabras[palabra_a_seleccionar]\n",
        "\n",
        "def armar_carta(numero_palabras):\n",
        "    '''Establecer la longitud de la carta'''\n",
        "    carta = ''\n",
        "    for i in range(0,numero_palabras):\n",
        "        carta += seleccionar_palabra(lista_palabras) + ' '\n",
        "    return carta\n",
        "\n",
        "# Codigo principal\n",
        "lista_palabras = ['de', 'a', 'o', 'hola', 'amor', 'te', 'amo', 'salir', 'aniversario', 'feliz']\n",
        "print(armar_carta(5))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lxZIOnUQn4Wk"
      },
      "source": [
        "Evidencie que en el ejemplo anterior se usaron:\n",
        "* Librerias:\n",
        "    * random\n",
        "* Funciones propias:\n",
        "    * len\n",
        "    * range\n",
        "    * print\n",
        "* Funciones del usuario:\n",
        "    * seleccionar_palabra\n",
        "    * armar_carta"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AJq_clpSnsr9"
      },
      "source": [
        "En el ejemplo anterior, la condición recursiva sigue siendo la misma. En este caso, lo que retorna la función es una lista, en la cual se han modificado todos los elementos de L al sumarles un valor N (Nótese que sumarN() retorna una lista nueva; la lista original se preserva).\n",
        "\n",
        "Se puede observar cómo se realiza una operación sobre la cabeza de la lista (sumarle N) y luego se concatena este resultado con la lista que generará aplicar sumarN() al resto de los elementos de la lista. Para operaciones simples, puede resultar trivial resolver el problema de forma iterativa. Sin embargo, a la hora de realizar operaciones complejas (tal como ordenar una lista) puede resultar más fácil de comprender la estructura recursiva."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sSt6oi23nsri"
      },
      "source": [
        "# Recursividad\n",
        "\n",
        "Python tiene la capacidad de invocar funciones dentro de otra función. Cuando una función se llama a sí misma, se presenta un caso particular conocido como función recursiva.\n",
        "\n",
        "Normalmente, la recursividad (la idea de definir un concepto por medio de ese mismo concepto) se encuentra en conceptos matemáticos. Por ejemplo en el caso del factorial:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UyL1CPeonsrj"
      },
      "source": [
        "# la siguiente línea activa el tutor magic para el ejemplo específico\n",
        "%%tutor --lang python3 -s\n",
        "\n",
        "def factorial(N):\n",
        "  '''Calcular el factorial de un número entero'''\n",
        "  return N * factorial(N-1)\n",
        "\n",
        "print(factorial(4))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OAi6zCbFnsrr"
      },
      "source": [
        "Al intentar ejecutar el código anterior, se presenta un error, ya que ese código genera un ciclo infinito. Esto ocurre ya que la función se llama a sí misma constantemente, y nunca se detiene.\n",
        "\n",
        "Es por esto que toda función recursiva debe tener tanto una <b>condición recursiva</b> como al menos una <b>condición de parada</b>. Las condiciones recursivas son los casos generales; todo momento en el que la función puede (¡y debe!) llamarse a sí misma para proceder con la ejecución del código. Las condiciones de parada, por otra parte, son aquellas condiciones cuando la función debe realizar una operación específica en lugar de invocarse a sí misma nuevamente.\n",
        "\n",
        "A continuación se presenta la función factorial redefinida:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sJfooGeHnsr3"
      },
      "source": [
        "def factorialIterativo(N):\n",
        "    '''Calcular el factorial de forma iterativa'''\n",
        "    #Los casos base se declaran explicitamente, aún cuando se resuelve el problema de forma iterativa.\n",
        "    if N < 0:\n",
        "        return -1\n",
        "    elif N == 0:\n",
        "        return 1\n",
        "    else:\n",
        "        # El acumualador se inicializa en 1 porque se va a utilizar en una multiplicación\n",
        "        acumulador = 1\n",
        "        while N > 0:\n",
        "            acumulador = acumulador*N\n",
        "            N = N - 1\n",
        "        return acumulador\n",
        "\n",
        "print(factorialIterativo(4))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YlRjce5Ensrs"
      },
      "source": [
        "def factorialCorregido(N):\n",
        "    '''Calcular factorial de un número entero de forma recursiva'''\n",
        "    #Esta es la condición recursiva; siempre que N sea mayor a 1, factorialCorregido() será invocada nuevamente.\n",
        "    if N > 1:\n",
        "        return N * factorialCorregido(N-1)\n",
        "\n",
        "    #Esta es la condición de parada; cuando N sea menor o igual a 1 simplemente retorna N, sin invocar a factorialCorregido().\n",
        "    else:\n",
        "        return N\n",
        "\n",
        "print (factorialCorregido(4))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZKMFC1yVnsrv"
      },
      "source": [
        "Ahora, el factorial tiene unas características: no está definido para numeros que no sean enteros positivos y particularmente, factorial(0) está definido como 1. Esto se conoce como un <b>caso base</b>. No todas las funciones recursivas tienen casos base, pero muchas los tienen. Es importante especificarlos explicitamente dentro del cuerpo de la función."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Omh6UwB8nsrw"
      },
      "source": [
        "# la siguiente línea activa el tutor magic para el ejemplo específico\n",
        "%%tutor --lang python3 -s\n",
        "\n",
        "def factorialMejorado(N):\n",
        "    '''Forma alterna de calcular el factorial de un número entero'''\n",
        "    #Esto es un caso base: los numeros negativos retornan -1 para indicar un error.\n",
        "    if N < 0:\n",
        "        return -1\n",
        "    #Ahora biene el caso base es N = 0\n",
        "    elif N == 0:\n",
        "        return 1\n",
        "    #Esta es la condición recursiva; para todo N mayor o igual a 1.\n",
        "    else:\n",
        "        return N * factorialMejorado(N-1)\n",
        "\n",
        "print(factorialMejorado(6))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WEYjQN68nsry"
      },
      "source": [
        "También existen casos donde la recursividad puede ser indirecta:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XHUGlkXBnsrz"
      },
      "source": [
        "def f(X):\n",
        "    '''Ejemplo de recursividad indirecta'''\n",
        "    if X > 0:\n",
        "        return g(X- X*2/3)\n",
        "    else:\n",
        "        return X\n",
        "\n",
        "def g(X):\n",
        "    '''Ejemplo de recursividad indirecta'''\n",
        "    if X % 2 == 0:\n",
        "        return f(X - X/2)\n",
        "    else:\n",
        "        return f(X-1)\n",
        "\n",
        "print(f(14))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uUk9avmbnsr3"
      },
      "source": [
        "En este caso, se observa como f() invoca a g(), quien a su vez invoca a f() nuevamente. Para que estas dos funciones se ejecuten correctamente, es necesario que exista una condición de parada confiable: el valor de X, eventualmente, será negativo. Nótese que no es problema que g() siempre invoque a f(), siempre y cuando f() tenga una condición de parada alcanzable dentro de su código.\n",
        "\n",
        "No se debe utilizar la recursividad si existe una solución iterativa (ciclos <i>for</i> y <i>while</i>) más simple. Esto debido a que la carga sobre la memoria es mucho mayor.\n",
        "\n",
        "Como dato curioso, todo proceso iterativo puede realizarse recursivamente, pero no todo proceso recursivo puede realizarse iterativamente. A modo de ejemplo, se presenta una forma de escribir la función factorial de forma iterativa:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "okUyZzmznsr5"
      },
      "source": [
        "Al convertir una solución iterativa en una recursiva, generalmente conviene pensar que la condición del \"while\" es la condición recursiva, y que en el momento en que esta deja de ser verdad se convierte en una condición de parada. Nótese que aunque el valor de N cambia, solo se invoca factorialIterativo() una vez; todo lo demás ocurre dentro del ciclo while.\n",
        "\n",
        "Sin embargo, utilizar funciones recursivas puede simplificar la interpretación del código y facilitar su escritura. Esto se evidencia a la hora de manipular estructuras similares a listas:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KljBa_IKnsr6"
      },
      "source": [
        "def suma(L):\n",
        "    '''Función que suma de manera recursiva los elementos de una lista'''\n",
        "    if(len(L) > 0):\n",
        "        return L[0] + suma(L[1:])\n",
        "    else:\n",
        "        return 0\n",
        "\n",
        "print(suma([1,2,4]))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jVholirpnsr8"
      },
      "source": [
        "En el ejemplo anterior se presenta la suma de todos los elementos que se encuentran en una lista de forma recursiva. Para hacerlo, se verifica que la lista tenga elementos y, posteriormente, se suma el valor de la <b>\"cabeza\"</b> (el primer elemento de la lista) con el resultado de aplicar suma() sobre la <b>\"cola\"</b> de la lista (la cola son todos los otros elementos de la lista original).\n",
        "\n",
        "En otras palabras, es posible recorrer recursivamente una lista al realizar una operación de algún tipo sobre su cabeza e invocar la función recursiva sobre los demás elementos de esta. <b>En estos casos, la condición de parada suele ser el encontrarse con una lista vacía. </b>\n",
        "\n",
        "<i>Nota: Formalmente, la cabeza de una lista es una sublista que únicamente contiene el primer elemento de la lista original y la cola es una sublista que contiene todos los demás elementos. Esto para poder decir que \"una lista está compuesta por una lista que sólo tiene un elemento y otra lista que contiene los demás. Cualquiera de estas dos listas puede estar vacía.\" </i>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WqwmlRdPqBeN"
      },
      "source": [
        "# Iteración vs. recursividad"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j2ZIV8JUnsr8"
      },
      "source": [
        "X = [8, 7, 3]\n",
        "\n",
        "#Solución iterativa para aumentar el valor de todos los elementos de una lista en N\n",
        "def sumarNIterativo(L,N):\n",
        "    '''incrementar los valores de una lista de forma iterativa'''\n",
        "    aux = []\n",
        "    for i in range(len(L)):\n",
        "        aux = aux + [L[i] + N]\n",
        "    return aux\n",
        "\n",
        "print(sumarNIterativo(X,-5))\n",
        "\n",
        "\n",
        "#Solución recursiva.\n",
        "def sumarN(L,N):\n",
        "    ''' incrementar los valores de una lista de forma recursiva'''\n",
        "    if(len(L) > 0):\n",
        "        return ([L[0] + N] + sumarN(L[1:], N))\n",
        "    else:\n",
        "        return L\n",
        "\n",
        "print(sumarN(X, 4))"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}