Tema10.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Tema10.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "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/fedechaves/Practica_python/blob/main/Tema10.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qUOdgOhTv1si"
      },
      "source": [
        "# Funciones\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r55MQssxE_7o"
      },
      "source": [
        "## Función\n",
        "\n",
        "**Función.** Una función en `Python` es una pieza de código reutilizable que solo se ejecuta cuando es llamada.\n",
        "\n",
        "Se define usando la palabra reservada `def` y estructura general es la siguiente:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8dlBOgqCwDC-"
      },
      "source": [
        "def nombre_funcion(input1, input2, ..., inputn):\n",
        "  cuerpo de la función\n",
        "  return output"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JakkE-fEwODq"
      },
      "source": [
        "**Observación.** La instrucción `return` finaliza la ejecución de la función y devuelve el resultado que se indica a continuación. Si no se indicase nada, la función finalizaría, pero no retornaría nada.\n",
        "\n",
        "Como hemos visto, en general, las funciones constan de 3 partes:\n",
        "\n",
        "- **Inputs (parámetros o argumentos).** Son los valores que le pasamos como entrada a la función.\n",
        "- **Cuerpo.** Son todas las operaciones que lleva a cabo la función.\n",
        "- **Output.** Es el resultado que devuelve la función.\n",
        "\n",
        "**Observación.** Los parámetros son variables internas de la función. Si probásemos a ejecutar una de dichas variables en el entorno global, nos saltaría un error. Este tema lo trataremos más en detalle más adelante.\n",
        "\n",
        "Con lo visto anteriormente, a la hora de construir una función hau que hacerse las siguientes preguntas:\n",
        "\n",
        "- ¿Qué datos necesita conocer la función? (inputs)\n",
        "- ¿Qué hace la función? (cuerpo)\n",
        "- ¿Qué devuelve? (output)\n",
        "\n",
        "**Observación.** Los inputs y el output son opcionales: podemos definir una función sin necesidad de proporcionarle inputs y sin que nos devuelva nada.\n",
        "\n",
        "Una vez definida una función, para llamarla utilizamos su nombre seguido de paréntesis:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "x8uWQGoyunpo"
      },
      "source": [
        "def my_first_function():\n",
        "    print(\"Tu primera función te saluda\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NBmMdkWou0W4",
        "outputId": "5bf5546e-21f4-47d4-9de5-86c7d5b4f428"
      },
      "source": [
        "my_first_function()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Tu primera función te saluda\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6gyFc8hV8337"
      },
      "source": [
        "Hemos dicho que tanto los inputs como el output son opcionales. Veamos algunos ejemplos con diferentes casos.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BFnz-v2UFCpe"
      },
      "source": [
        "---\n",
        "\n",
        "#### Ejemplo 1\n",
        "\n",
        "Veamos otro ejemplo que no necesite ningún parámetro y no nos devuelva nada, tal y como ocurría con `my_first_function()`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3Io5aN0O827D"
      },
      "source": [
        "def hello_world():\n",
        "  print(\"Hola mundo!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wghoJ6CzcOP0",
        "outputId": "4bab608f-5150-4139-c099-a12079499941"
      },
      "source": [
        "hello_world()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hola mundo!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gLP-bEbEvP-v"
      },
      "source": [
        "Nuestra función `hello_world()`, cuando es llamada, imprime \"Hola mundo!\", pero no devuelve absolutamente nada."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_j8A5Pqg60NE"
      },
      "source": [
        "---\n",
        "\n",
        "#### Ejemplo 2\n",
        "\n",
        "Veamos un ejemplo de función que no necesita ningún input, pero que devuelve un output. Por ejemplo, una función que nos devuelve \"¡Buenos días!\""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zk2lCNwP6yf2"
      },
      "source": [
        "def good_morning():\n",
        "    return \"Buenos días\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F9JKMN9A7NF4"
      },
      "source": [
        "Ya hemos declarado la función. Si la llamamos, obtenemos el siguiente resultado:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "sjyyrAiL7I_g",
        "outputId": "8fa77d83-3401-4bcc-823d-0489d13da511"
      },
      "source": [
        "good_morning()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Buenos días'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OvaxNnGV8fiF"
      },
      "source": [
        "Como nos devuelve el saludo, lo podemos guardar en una variable, que será de tipo string"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FarS3Uqw8kpY",
        "outputId": "d7ecedc9-9957-48ac-ce94-4e992add9f87"
      },
      "source": [
        "goodMorning = good_morning()\n",
        "print(goodMorning)\n",
        "print(type(goodMorning))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Buenos días\n",
            "<class 'str'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NZXpjzpn7Qwv"
      },
      "source": [
        "---\n",
        "\n",
        "#### Ejemplo 3\n",
        "\n",
        "Veamos ahora un ejemplo de función que no nos devuelva nada, pero que sí toma algún parámetro"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fdiBL0Ug7J3n"
      },
      "source": [
        "def good_morning(name):\n",
        "  print(\"¡Buenos días, {}!\".format(name))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O0_9BaI_8zyN",
        "outputId": "054c97e3-b61b-4ebb-a0c8-58b6cd092a87"
      },
      "source": [
        "good_morning(name = \"Don Pepito\")\n",
        "good_morning(name = \"Don José\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "¡Buenos días, Don Pepito!\n",
            "¡Buenos días, Don José!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Oot-dCJQn9Xq",
        "outputId": "5bba4b87-6240-4920-8d35-c7e831a56492"
      },
      "source": [
        "good_morning(\"María\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "¡Buenos días, María!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O6TEfIiHwGn5"
      },
      "source": [
        "Ahora nuestra función `good_morning()` recibe como parámetro un nombre y nos muestra por pantalla un \"¡Buenos días!\" junto con el nombre indicado."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t9QrO9P3uYVG"
      },
      "source": [
        "---\n",
        "\n",
        "#### Ejemplo 4\n",
        "\n",
        "Por último, vamos a crear una función que nos calcule la división entera de dos números y nos retorne el cociente y el resto."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q4RI-bwXxZw8"
      },
      "source": [
        "def euclidean_division(x, y):\n",
        "  q = x // y\n",
        "  r = x % y\n",
        "  return q, r"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v4HSy360xmT_"
      },
      "source": [
        "Esta función, a la que hemos llamado `euclidean_division`, calcula el cociente y el resto de dos números cualesquiera y devuelve como resultado esos dos números calculados.\n",
        "\n",
        "Utilicemos ahora nuestra función para calcular el cociente y el resto de la división $41 \\div 7$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ibju6rm2x4XQ",
        "outputId": "d88c1053-8fa7-4d36-d825-16dc609d594e"
      },
      "source": [
        "euclidean_division(x = 41, y = 7)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(5, 6)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NyofiVRWp_vo",
        "outputId": "2fff0f55-9a2e-4daa-be90-3eb3e9972f6d"
      },
      "source": [
        "euclidean_division(41, 7)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(5, 6)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "n-4L5W48qF0F",
        "outputId": "4f0c83db-fafc-404e-80b6-294c4cc5ebb0"
      },
      "source": [
        "euclidean_division(y = 7, x = 41)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(5, 6)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "871_CMggyClo"
      },
      "source": [
        "Al llamar a la función e indicarle por parámetros `x = 41` e `y = 7`, hemos obtenido como resultado la tupla `(5, 6)`. El significado de dicho resulatdo es que el cociente entero de $41\\div 7$ es 5, mientras que el resto es $6$. Efectivamente\n",
        "\n",
        "$$41 = 7\\cdot 5 + 6$$\n",
        "\n",
        "También podríamos guardar en variables diferentes los resultados que nos devuelve nuestra función, para poder trabajar con ellos en el entorno global"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Rd8L122dx60o",
        "outputId": "f06e8d04-45da-43e8-880d-999a9c92647c"
      },
      "source": [
        "quotient, remainder = euclidean_division(x = 41, y = 7)\n",
        "print(quotient)\n",
        "print(remainder)\n",
        "print(41 == 7 * quotient + remainder)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "5\n",
            "6\n",
            "True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kUR-OjRKFHNv"
      },
      "source": [
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IFTMxwvJcNSE"
      },
      "source": [
        "## Parámetros\n",
        "\n",
        "Por defecto, una función debe ser llamada con el número correcto de argumentos. Esto es, si la función espera 2 argumentos, tenemos que llamar a la función con esos 2 argumentos. Ni más, ni menos.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BAqrsky_yugk"
      },
      "source": [
        "def complete_name(name, surname):\n",
        "  print(\"El nombre completo es\", name, surname)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "h5HzLkn-y8Bg",
        "outputId": "f293e0ae-88b9-4466-a6c0-a8e9936c7add"
      },
      "source": [
        "complete_name(\"María\", \"Santos\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "El nombre completo es María Santos\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BVIOAP8pOUaS",
        "outputId": "14fb25b9-3a6a-4b5a-aeb3-f028141f764c"
      },
      "source": [
        "complete_name(\"Juan Gabriel\", \"Gomila\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "El nombre completo es Juan Gabriel Gomila\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zcKikKOdzIBZ"
      },
      "source": [
        "Si intentamos llamar a la función `complete_name()` pasando 1 solo parámetro o 3 parámetros, entonces la función devuelve error."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SMtZKeWjzOZb",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 164
        },
        "outputId": "19516faf-e879-4427-a24d-8c5bbb5f9f26"
      },
      "source": [
        "complete_name(name = \"María\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-4-34fae0960c67>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mcomplete_name\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"María\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: complete_name() missing 1 required positional argument: 'surname'"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 164
        },
        "id": "WEP4ogVnOv02",
        "outputId": "3678cd3f-16f9-45b1-ed32-36eb3f5d9cca"
      },
      "source": [
        "complete_name(\"Juan\", \"Gabriel\", \"Gomila\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-5-3e2f24df3bbb>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mcomplete_name\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Juan\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"Gabriel\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"Gomila\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: complete_name() takes 2 positional arguments but 3 were given"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0RcJ96fHzVj9"
      },
      "source": [
        "### Número arbitrario de argumentos\n",
        "\n",
        "Si no sabemos el número de parámetros que van a ser introducidos, entonces añadimos un asterisco `*` previo al nombre del parámetro en la definición de la función. Los valores introducidos serán guardados en una tupla."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R08ZvAN1zrPl"
      },
      "source": [
        "def sum_numbers(*numbers):\n",
        "  sum = 0\n",
        "  for n in numbers:\n",
        "    sum += n\n",
        "  \n",
        "  return sum\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9-cPxa9az3ii",
        "outputId": "caec878e-e7d4-4bce-cb61-b217ff86bf16"
      },
      "source": [
        "sum_numbers(1, 2, 3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6jtx5Ocv0rR3",
        "outputId": "f1fa8ff6-b104-4d52-bb1e-e15c138f2fc4"
      },
      "source": [
        "sum_numbers(2, 4, 6, 8, 10)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "30"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sIFU7QxA1M1N"
      },
      "source": [
        "### Número arbitrario de claves de argumento\n",
        "\n",
        "Hasta ahora hemos visto que al pasar valores por parámetro a la función, podemos hacerlo con la sintaxis `clave_argumento = valor` o directamente pasar por parámetro el valor siguiendo el orden posicional de la definición de la función:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JyKVf3S115dw"
      },
      "source": [
        "def complete_name(name, surname):\n",
        "  print(\"El nombre completo es\", name, surname)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UMZPiqzx181k",
        "outputId": "cdf42369-9b29-4f12-d68b-adfa68058de2"
      },
      "source": [
        "complete_name(name = \"María\", surname = \"Santos\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "El nombre completo es María Santos\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Jv7zJ8eK1_iP",
        "outputId": "764255ff-4f86-46fa-ea3f-31137559cb03"
      },
      "source": [
        "complete_name(surname = \"Santos\", name = \"María\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "El nombre completo es María Santos\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Z6D0f7wK2D7Y",
        "outputId": "d34c8d2f-32f1-4891-cad3-67e1e68bfa52"
      },
      "source": [
        "complete_name(\"María\", \"Santos\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "El nombre completo es María Santos\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oLUVGV0a2JJ3"
      },
      "source": [
        "En realidad, los nombres completos pueden tener dos o incluso más apellidos, pero no sabemos si el usuario tiene 1 o 2 o más. Entones, podemos añadir dos asteriscos `**` antes del nombre del parámetro para así poder introducir tantos como queramos sin que salte error"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1AIX5W-Z2Iea"
      },
      "source": [
        "def complete_name(name, **surname):\n",
        "    print(\"El nombre completo es {}\".format(name), end = \" \")\n",
        "    for i in surname.items():\n",
        "      print(\"{}\".format(i[1]), end = \" \")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Qx1K7Ogr2qu_",
        "outputId": "224b41a3-97d8-4043-f1f3-ed7387910357"
      },
      "source": [
        "complete_name(name = \"María\", surname1 = \"Santos\", surname2 = \"Fernández\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "El nombre completo es María Santos Fernández "
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fi9tLbR52z4m",
        "outputId": "3e7a3e11-a045-4f4f-adea-d203acbfb9b2"
      },
      "source": [
        "complete_name(name = \"María\", surname = \"Santos\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "El nombre completo es María Santos "
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WAmAFPo2ycl-"
      },
      "source": [
        "### Parámetros por defecto\n",
        "\n",
        "Hemos visto que una función en `Python` puede tener o no parámetros.\n",
        "\n",
        "En caso de tener, podemos indicar que alguno tenga un valor por defecto.\n",
        "\n",
        "La función `diff()` calcula la diferencia entre los dos números que introducimos por parámetros. Podemos hacer que el sustraendo por defecto valga 1 del siguiente modo:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UVIKXoejc2GF"
      },
      "source": [
        "def diff(x, y = 1):\n",
        "  return x - y"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "G72rMbaUVWDp",
        "outputId": "e537e17e-51e3-4db8-8b2d-49a0484a209e"
      },
      "source": [
        "diff(65, 18)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "47"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yxif30gkdtLG"
      },
      "source": [
        "Si ahora llamamos a la función indicando únicamente el valor del parámetro `x`, ocurre lo siguiente:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9RUmhlc0d0Dk",
        "outputId": "4902d95a-9f26-41d0-ed2b-0f33d352eb3b"
      },
      "source": [
        "diff(x = 20)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "19"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "acen27Rtd4pR"
      },
      "source": [
        "Como resultado hemos obtenido 19, ya que el valor que ha tomado el parámetro `y` ha sido el que le hemos dicho que tome por defecto, es decir, $y = 1$ y, consecuentemente, $x-y = 20-1 = 19$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TKl7Kes2egTS"
      },
      "source": [
        "## Docstring\n",
        "\n",
        "**Docstring.** Son comentarios explicativos que ayudan a comprender el funcionamiento de una función.\n",
        "\n",
        "- Van entre triple comilla doble\n",
        "- Pueden ser multilínea\n",
        "- Se sitúan al principio de la definición de la función\n",
        "\n",
        "Retomando el ejemplo de la división entera, podríamos utilizar docstring del siguiente modo:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ajyjkuSSd2Fq"
      },
      "source": [
        "def euclidean_division(x, y):\n",
        "  \"\"\"\n",
        "  Esta función calcula el cociente y el resto de la\n",
        "  división entera de x entre y.\n",
        "\n",
        "  Args:\n",
        "    x (int): dividendo\n",
        "    y (int): divisor (que no puede ser cero)\n",
        "\n",
        "  Returns:\n",
        "    (q, r): tupla con el valor de (cociente, resto)\n",
        "  \"\"\"\n",
        "  q = x // y\n",
        "  r = x % y\n",
        "  return q, r"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "M8c-vyXWfXL3"
      },
      "source": [
        "Con la ayuda del método `.__doc__` podemos acceder directamente a la información indicada en el docstring de una función"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TDG2YLVgfeZO",
        "outputId": "8487260d-a8b5-43a4-9edb-3e7b07781e87"
      },
      "source": [
        "print(euclidean_division.__doc__)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "  Esta función calcula el cociente y el resto de la\n",
            "  división entera de x entre y.\n",
            "\n",
            "  Args:\n",
            "    x (int): dividendo\n",
            "    y (int): divisor (que no puede ser cero)\n",
            "\n",
            "  Returns:\n",
            "    (q, r): tupla con el valor de (cociente, resto)\n",
            "  \n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x4hH0f43fp4q"
      },
      "source": [
        "## Variables de una función\n",
        "\n",
        "Dentro de una función en `Python` existen dos tipos de variables:\n",
        "\n",
        "- **Variable local.** Aquella que es creada y solamente existe dentro de la función.\n",
        "- **Variable global.** Aquella que es creada en el entorno global.\n",
        "\n",
        "Dada la siguiente función:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Sq0f6N0dfijw"
      },
      "source": [
        "def arithmetic_operations(x, y):\n",
        "  sum = x + y\n",
        "  diff = x - y\n",
        "  prod = x * y\n",
        "  div = x / y\n",
        "  return {\"sum\": sum,\n",
        "          \"difference\": diff,\n",
        "          \"product\": prod,\n",
        "          \"division\": div}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7OilEVxgglpi"
      },
      "source": [
        "Si nosotros queremos imprimir por ejemplo el valor que toma la variable `prod` en el entorno global nos saltará un error, pues esta variable no existe a nivel global porque no ha sido declarada en dicho entorno ya que solamente ha sido declarada a nivel local, dentro de la función `arithmetic_operations()`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rqM-OG8jglAk",
        "outputId": "fd36e8d2-6122-49df-cfd0-c838b4648cc5"
      },
      "source": [
        "print(arithmetic_operations(x = 5, y = 3))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'sum': 8, 'difference': 2, 'product': 15, 'division': 1.6666666666666667}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eFhWzCT3gevd",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 164
        },
        "outputId": "c2cb0f35-26a5-40d4-dfa3-1fcd1818db6c"
      },
      "source": [
        "print(prod)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-34-9e0a762e5f10>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprod\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m: name 'prod' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bRGOMrr-hzOe"
      },
      "source": [
        "Si se diese el caso de que sí hubiese sido definida la variable `prod` en el entorno global, como lo que ocurre en el siguiente bloque de código, por mucho que la variable local tenga el mimso nombre y por mucho que ejecutemos la función, el valor de la variable global no se ve modificado"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "v0LdovRQghnz",
        "outputId": "96ecace6-21ea-4e3f-faea-f95d6e5c934e"
      },
      "source": [
        "prod = 10\n",
        "print(arithmetic_operations(x = 5, y = 3))\n",
        "print(prod)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'sum': 8, 'difference': 2, 'product': 15, 'division': 1.6666666666666667}\n",
            "10\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X7h_mZNeiLJ4"
      },
      "source": [
        "Si dentro de una función utilizamos la palabra reservada `global` a una variable local, ésta automáticamente pasa a ser una variable global previamente definida.\n",
        "\n",
        "Veamos un ejemplo de función que nos devuelve el siguiente número del entero `n` definido en el entorno global:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hK1kS1AuiHp8",
        "outputId": "f3800f65-0a90-4916-cec9-8789d31cf12e"
      },
      "source": [
        "n = 7\n",
        "\n",
        "def next_n():\n",
        "  global n\n",
        "  return n + 1\n",
        "\n",
        "next_n()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "8"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AKYIJ-Uj5iOg"
      },
      "source": [
        "### Paso por copia vs. paso por referencia\n",
        "\n",
        "Dependiendo del tipo de dato que pasemos por parámetro a la función, podemos diferenciar entre\n",
        "\n",
        "- **Paso por copia.** Se crea una copia local de la variable dentro de la función.\n",
        "- **Paso por referencia.** Se maneja directamnete la variable y los cambios realizados dentro de la función afectan también a nivel global.\n",
        "\n",
        "En general, los tipos de datos básicos como enteros, en coma flotante, strings o booleanos se pasan por copia, mientras que estructuras de datos como listas, diccionarios, conjuntos o tuplas u otros objetos se pasan por referencia.\n",
        "\n",
        "Un ejemplo de paso por copia sería"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mL27Pg_p5xNZ"
      },
      "source": [
        "def double_value(n):\n",
        "    n = n*2\n",
        "    return n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pmw6xMZA52Xa",
        "outputId": "8c6c2e7b-6cbd-47c3-8acc-6f525f70bc81"
      },
      "source": [
        "num = 5\n",
        "print(double_value(num))\n",
        "print(num)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "10\n",
            "5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CO1OLE_U5_p7"
      },
      "source": [
        "Un ejemplo de paso por referencia sería"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V8eGf2qD6B44"
      },
      "source": [
        "def double_values(ns):\n",
        "  for i, n in enumerate(ns):\n",
        "    ns[i] *= 2\n",
        "\n",
        "  return ns"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WFuevE1T6beZ",
        "outputId": "c82e319c-2e0e-4f55-f32f-3d1215687c51"
      },
      "source": [
        "nums = [1, 2, 3, 4, 5]\n",
        "print(double_values(nums))\n",
        "print(nums)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[2, 4, 6, 8, 10]\n",
            "[2, 4, 6, 8, 10]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6GVBQGcQ7oEq"
      },
      "source": [
        "Para evitar la modificación de la lista original, podemos hacerlo introduciendo por parámetro una copia de dicha lista"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MGOs-7Ul7nao",
        "outputId": "b19306fd-29cc-48cd-9f24-fef106d40b7e"
      },
      "source": [
        "nums = [1, 2, 3, 4, 5]\n",
        "print(double_values(nums[:]))\n",
        "print(nums)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[2, 4, 6, 8, 10]\n",
            "[1, 2, 3, 4, 5]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vSHQn0k7iKek"
      },
      "source": [
        "## Funciones más complejas\n",
        "\n",
        "Las funciones pueden ser más completas, pues admiten tanto operadores de decisión como de iteración.\n",
        "\n",
        "Volviendo al ejemplo 4, la función creada claramente es muy sencilla, pues suponemos que el usuario va a introducir por parámetros números enteros.\n",
        "\n",
        "**Ejercicio.** Mejora la función `euclidean_division()` para que\n",
        "\n",
        "- Compruebe que los números introducidos son enteros. En caso de no ser así, indicar que se ha tomado la parte entera de los valores introducidos.\n",
        "- Realice la división entera del mayor parámetro (en valor absoluto) entre el menor parámetro. Esto es, si el usuario introduce `x = -2` e `y = -10`, como 10 > 2, entonces la función debe llevar a cabo la división entera de -10 entre -2.\n",
        "- Imprima por pantalla una frase indicando la división realizada y el cociente y el resto obtenidos.\n",
        "- Devuelva el cociente y el resto a modo de tupla\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "elF6Tw3wxcUu"
      },
      "source": [
        "def euclidean_division(x, y):\n",
        "  ints = (x == int(x)) and (y == int(y))\n",
        "  \n",
        "  if not ints:\n",
        "    x = int(x)\n",
        "    y = int(y)\n",
        "    print(\"Se tomarán como parámetros la parte entera de los valores introducidos.\")\n",
        "  \n",
        "  if abs(x) >= abs(y):\n",
        "    q = x // y\n",
        "    r = x % y\n",
        "    print(\"Se ha realizado la división {} entre {} y se ha obtenido como cociente q = {} y como resto, r = {}\".format(x, y, q, r))\n",
        "\n",
        "  else:\n",
        "    q = y // x\n",
        "    r = y % x\n",
        "    print(\"Se ha realizado la división {} entre {} y se ha obtenido como cociente q = {} y como resto, r = {}\".format(y, x, q, r))\n",
        "\n",
        "\n",
        "  return q, r"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fMMpS6udxlO0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "624e166a-dd15-4d50-81a5-ba46b8d5b22e"
      },
      "source": [
        "quotient, remainder = euclidean_division(x = -10.3, y = -5)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Se tomarán como parámetros la parte entera de los valores introducidos.\n",
            "Se ha realizado la división -10 entre -5 y se ha obtenido como cociente q = 2 y como resto, r = 0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hDs_HqLVxlsW",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a983b992-5152-4bc4-a8e6-c99eac0ebeee"
      },
      "source": [
        "-10 == -5 * quotient + remainder"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 44
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0M9j4borzPTA",
        "outputId": "9dff996e-6540-403b-cc41-434e33e20812"
      },
      "source": [
        "euclidean_division(x = -3, y = 19)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Se ha realizado la división 19 entre -3 y se ha obtenido como cociente q = -7 y como resto, r = -2\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(-7, -2)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 45
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UldoeHHuxVNs"
      },
      "source": [
        "---\n",
        "\n",
        "#### Ejemplo 5\n",
        "\n",
        "Veamos una función que dado un número, nos dice si éste es positivo, negativo o vale 0.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9PzQHbBSjehe"
      },
      "source": [
        "def sign(num):\n",
        "  \"\"\"\n",
        "  Función que dado un número devuelve el signo positivo, \n",
        "  negativo o cero del mismo\n",
        "\n",
        "  Args:\n",
        "    num (int): número del cual queremos hallar su signo\n",
        "\n",
        "  Returns:\n",
        "    signo (string): string positivo, negativo o cero\n",
        "  \"\"\"\n",
        "  if num > 0:\n",
        "    return \"Positivo\"\n",
        "  elif num < 0:\n",
        "    return \"Negativo\"\n",
        "  else:\n",
        "    return \"Cero\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3QnJ-7gJUOCw",
        "outputId": "2860432e-5742-4aac-d119-090b53595972"
      },
      "source": [
        "print(sign(num = 3.1415))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Positivo\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "x4VkYFXkUPsv",
        "outputId": "41f92177-7459-49a7-e7d0-c7807c69be0d"
      },
      "source": [
        "print(sign(num = -100))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Negativo\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7Rpv6NNGURKm",
        "outputId": "08fd3fa0-b370-4d57-ec8c-ad48b704ac93"
      },
      "source": [
        "print(sign(num = 0))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Cero\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dgiLR9QQjwlu"
      },
      "source": [
        "---\n",
        "\n",
        "#### Ejemplo 6\n",
        "\n",
        "Veamos ahora una función que contiene un bucle `for` y que dado un número entero, nos imprime su tabla de multiplicar con sus 10 primeros múltiplos y nos devuelve una lista con todos esos múltiplos:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HBhmElsujqRQ"
      },
      "source": [
        "def multiplication_table10(num):\n",
        "  \"\"\"\n",
        "  Dado un número entero, imprimimos su tabla de multiplicar con\n",
        "  los 10 primeros múltiplos y devolvemos una lista de los múltiplos. \n",
        "\n",
        "  Args:\n",
        "    num (int): valor del cual vamos a calcular sus tabla de multiplicar\n",
        "\n",
        "  Returns: \n",
        "    multiples (list): lista con los 10 primeros múltiplos de num\n",
        "  \"\"\"\n",
        "  multiples = []\n",
        "  print(\"La tabla de multiplicar del {}:\".format(num))\n",
        "  \n",
        "  for i in range(1, 11):\n",
        "    multiple = num * i\n",
        "    print(\"{} x {} = {}\".format(num, i, multiple))\n",
        "    multiples.append(multiple)\n",
        "  \n",
        "  return multiples"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "efIribXxVJzL",
        "outputId": "daac4c57-6b36-49e9-9346-039cab437647"
      },
      "source": [
        "multiples7 = multiplication_table10(num = 7)\n",
        "print(multiples7)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "La tabla de multiplicar del 7:\n",
            "7 x 1 = 7\n",
            "7 x 2 = 14\n",
            "7 x 3 = 21\n",
            "7 x 4 = 28\n",
            "7 x 5 = 35\n",
            "7 x 6 = 42\n",
            "7 x 7 = 49\n",
            "7 x 8 = 56\n",
            "7 x 9 = 63\n",
            "7 x 10 = 70\n",
            "[7, 14, 21, 28, 35, 42, 49, 56, 63, 70]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O3pgpZRckezm"
      },
      "source": [
        "Vamos ahora a mejorar la función `multiplication_table10()` para que si el usuario decide introducir un número que no sea entero, nuestra función le avise y le explique el error que está cometiendo:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wAeuky2NkXOL"
      },
      "source": [
        "def multiplication_table10(num):\n",
        "  \"\"\"\n",
        "  Dado un número entero, primero comprovamos si es entero. \n",
        "  Si no lo es, no devolvemos nada.\n",
        "  Si lo es, imprimimos su tabla de multiplicar con los 10 \n",
        "  primeros múltiplos y devolvemos una lista de los múltiplos. \n",
        "\n",
        "  Args:\n",
        "    num (int): valor del cual vamos a calcular sus 10 primeros múltiplos\n",
        "\n",
        "  Returns: \n",
        "    multiples (list): lista con los 10 primeros múltiplos de num\n",
        "  \"\"\"\n",
        "\n",
        "  if type(num) != type(1):\n",
        "    print(\"El número introducido no es entero\")\n",
        "    return\n",
        "\n",
        "  multiples = []\n",
        "  print(\"La tabla de multiplicar del {}:\".format(num))\n",
        "  \n",
        "  for i in range(1, 11):\n",
        "    multiple = num * i\n",
        "    print(\"{} x {} = {}\".format(num, i, multiple))\n",
        "    multiples.append(multiple)\n",
        "  \n",
        "  return multiples"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dgKYK1shmxgx",
        "outputId": "5cf5cb40-0612-4be9-b479-f9f6f3a0a9fb"
      },
      "source": [
        "multiples3 = multiplication_table10(num = 3)\n",
        "print(multiples3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "La tabla de multiplicar del 3:\n",
            "3 x 1 = 3\n",
            "3 x 2 = 6\n",
            "3 x 3 = 9\n",
            "3 x 4 = 12\n",
            "3 x 5 = 15\n",
            "3 x 6 = 18\n",
            "3 x 7 = 21\n",
            "3 x 8 = 24\n",
            "3 x 9 = 27\n",
            "3 x 10 = 30\n",
            "[3, 6, 9, 12, 15, 18, 21, 24, 27, 30]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Usl-Jxoimi0E",
        "outputId": "15cc7464-d359-429c-9eb2-b7fe6465bdd8"
      },
      "source": [
        "multiples_float = multiplication_table10(num = \"3.7\")\n",
        "print(multiples_float)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "El número introducido no es entero\n",
            "None\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KnXYBINqnG6S"
      },
      "source": [
        "---\n",
        "\n",
        "#### Ejemplo 7\n",
        "\n",
        "Creemos ahora una función que dada una frase acabada en punto, nos devuelva si contiene o no la letra \"a\" haciendo uso de un bucle `while`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rBy4w_xUm2ok"
      },
      "source": [
        "def contains_a(sentence):\n",
        "  i = 0\n",
        "  while sentence[i] != \".\":\n",
        "    if sentence[i] == \"a\":\n",
        "      return True\n",
        "    i += 1\n",
        "  return False"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kFGPJgTKnfn5",
        "outputId": "8f9195e7-a2f9-4d39-8175-c3dae1c48d4d"
      },
      "source": [
        "contains_a(\"El erizo es bonito.\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 59
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DIftpZoCnje3",
        "outputId": "11e3d8fd-3096-41f1-d345-e098eb09857b"
      },
      "source": [
        "contains_a(\"El elefante es gigante.\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c1AspPOInpbi"
      },
      "source": [
        "**Ejercicio.** Generalizad la función `contains_a()` a una función llamada contains_letter() que devuelva si una frase cualquiera (no necesariamente acabada en punto) contiene o no la letra indicada también por el usuario. Tenéis que hacerlo únicamente con operadores de decisión e iteración. No vale usar ningún método existente de `string`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zYlnccPZnmWr",
        "outputId": "c05f77df-982c-454a-e802-6cd9a7e8670c"
      },
      "source": [
        "def contains_letter(sentence, letter):\n",
        "  for c in sentence:\n",
        "    if c == letter:\n",
        "      return True\n",
        "  return False\n",
        "\n",
        "contains_letter(\"Mi amigo es muy inteligente, pero un poco pesado\", \"t\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 64
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8eeiieccoUs2"
      },
      "source": [
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P0oNlzpCFR3a"
      },
      "source": [
        "## Funciones recursivas\n",
        "\n",
        "**Función recursiva.** Es una función que se llama a sí misma.\n",
        "\n",
        "**¡Cuidado!** Hay que tener mucho cuidado con este tipo de funciones porque podemos caer en un bucle infinito. Es decir, que la función no acabara nunca de ejecutarse.\n",
        "\n",
        "Una función recursiva que entraría en bucle infinito sería la siguiente."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Plx_wkdjoSiq"
      },
      "source": [
        "def powers(x, n):\n",
        "  print(x ** n)\n",
        "  powers(x, n + 1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x17PU3Mmo0aC"
      },
      "source": [
        "¿Por qué decimos que entra en bulce infinito? Pues porque solo parará si nosotros interrumpimos la ejecución.\n",
        "\n",
        "Esto se debe a que no le hemos indicado un caso de parada a la función, denominado caso final.\n",
        "\n",
        "**Caso final.** Es el caso que indica cuándo debe romperse la recursión. Hay que indicarlo siempre para no caer en un bucle infinito.\n",
        "\n",
        "En el caso de la función `powers()`, podemos indicar como caso final cuando el valor resultante supere 1000000. Lo indicamos con un `if`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fE0oHkRxpHNF"
      },
      "source": [
        "def powers(x, n):\n",
        "  if x ** n > 1000000:\n",
        "    return x ** n\n",
        "\n",
        "  print(x ** n)\n",
        "  powers(x, n + 1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1F67YP2sgwgO",
        "outputId": "6363ebf7-ff2c-413f-ce4f-f90e8b820789"
      },
      "source": [
        "powers(2, 1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2\n",
            "4\n",
            "8\n",
            "16\n",
            "32\n",
            "64\n",
            "128\n",
            "256\n",
            "512\n",
            "1024\n",
            "2048\n",
            "4096\n",
            "8192\n",
            "16384\n",
            "32768\n",
            "65536\n",
            "131072\n",
            "262144\n",
            "524288\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jSxRl_n5pj9z"
      },
      "source": [
        "---\n",
        "\n",
        "#### Ejemplo 8\n",
        "\n",
        "Veamos ahora un ejemplo clásico de función recursiva que funciona correctamente.\n",
        "\n",
        "Queremos una función que nos imprima el término $i$-ésimo de la sucesión de Fibonacci. Es decir, nosotros le indicamos el índice del término y la función nos devuelve el valor de dicho término.\n",
        "\n",
        "La sucesión de Fibonacci es\n",
        "\n",
        "$$1, 1, 2, 3, 5, 8, 13,\\dots$$\n",
        "\n",
        "Es decir, cada término se obtiene de la suma de los dos anteriores.\n",
        "\n",
        "$$F_0 = F_1 = 1$$\n",
        "$$F_n = F_{n-1} + F_{n-2}, n\\geq 2$$\n",
        "\n",
        "Con lo cual, la función que queremos y a la que hemos llamado `Fibonacci()` es:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xwIbeKmUqDvW"
      },
      "source": [
        "def Fibonacci(index):\n",
        "  if index == 0 or index == 1:\n",
        "    return 1\n",
        "  \n",
        "  return Fibonacci(index - 1) + Fibonacci(index - 2) "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EdmRCbcFqjpH"
      },
      "source": [
        "Como veis, le hemos indicado a la función cuando parar. Esto es, el caso final resulta ser cuando el índice vale 0, pues no existen índices negativos."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FqCHxCfVqsxM",
        "outputId": "612a403d-efd6-43a2-f1a6-c0c7ff9908e1"
      },
      "source": [
        "Fibonacci(index = 7)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "21"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 68
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KtkKo-9pjsjD",
        "outputId": "f87f2bea-7655-4ca3-b364-297875a1e817"
      },
      "source": [
        "Fibonacci(8)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "34"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 69
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "U4H5L7lZjuq3",
        "outputId": "4e5faa5b-b46e-4fa0-8970-dc81b29c857a"
      },
      "source": [
        "Fibonacci(30)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1346269"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 72
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XAYyDkJ5q4Cg"
      },
      "source": [
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MYnhAmr6FfEN"
      },
      "source": [
        "## Funciones helper\n",
        "\n",
        "Al igual que las funciones pueden llamarse a sí mismas, también pueden llamar a otras funciones.\n",
        "\n",
        "**Función helper.** Es una función cuyo propósito es evitar la repetición de código.\n",
        "\n",
        "Si nos dan la siguiente función"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sfKPqma1quEa"
      },
      "source": [
        "def sign_sum(x, y):\n",
        "  if x + y > 0:\n",
        "    print(\"El resultado de sumar {} más {} es positivo\".format(x, y))\n",
        "  elif x + y == 0:\n",
        "    print(\"El resultado de sumar {} más {} es cero\".format(x, y))\n",
        "  else:\n",
        "    print(\"El resultado de sumar {} más {} es negativo\".format(x, y))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "phZKuwq_rywC",
        "outputId": "d44ce0a3-81d5-4fd9-970a-8d6a2a9d17dd"
      },
      "source": [
        "sign_sum(5, 4)\n",
        "sign_sum(3, -3)\n",
        "sign_sum(1, -8)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "El resultado de sumar 5 más 4 es positivo\n",
            "El resultado de sumar 3 más -3 es cero\n",
            "El resultado de sumar 1 más -8 es negativo\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kx3GlWT7rNcw"
      },
      "source": [
        "Vemos que el `print` se repite salvo por la última palabra.\n",
        "\n",
        "Podríamos pensar en crear la función helper siguiente:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TPFYDAbarS77"
      },
      "source": [
        "def helper_print(x, y, sign):\n",
        "  print(\"El resultado de sumar {} más {} es {}.\".format(x, y, sign))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7Owq3ZANrZCX"
      },
      "source": [
        "Si utilizamos la función helper, la función `sign_sum()` quedaría modificada del siguiente modo:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oeE2MImqrej7"
      },
      "source": [
        "def sign_sum(x, y):\n",
        "  if x + y > 0:\n",
        "    helper_print(x, y, \"positivo\")\n",
        "  elif x + y == 0:\n",
        "    helper_print(x, y, \"cero\")\n",
        "  else:\n",
        "    helper_print(x, y, \"negativo\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hpqbKSx1sEqv",
        "outputId": "349a50f0-b810-4909-9061-8d7d52b608c4"
      },
      "source": [
        "sign_sum(5, 4)\n",
        "sign_sum(3, -3)\n",
        "sign_sum(1, -8)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "El resultado de sumar 5 más 4 es positivo.\n",
            "El resultado de sumar 3 más -3 es cero.\n",
            "El resultado de sumar 1 más -8 es negativo.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uNZoSwLDrqK-"
      },
      "source": [
        "Con lo cual ya no hay código repetido.\n",
        "\n",
        "Y como se puede observar, la función original funciona correctamente."
      ]
    }
  ]
}