03.1-funciones.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Funciones\n",
    "\n",
    "* Porciones de código, reutilizables.\n",
    "* Las funciones y su código no se ejecutan hasta que son llamadas o invocadas.\n",
    "* Una función tiene la siguientes caracterísicas:\n",
    "    * Tiene un nombre.\n",
    "    * Recibe unos parámetros obligatorios u opcionales.\n",
    "        * Puede no tener parámetros, tener parámetros obligatorios, parametros opcionales o ambos.\n",
    "    * Tiene documentación (opcional).\n",
    "    * Tiene un cuerpo (sentencias).\n",
    "        * Si el cuerpo de la función está vacío, hay que utilizar la sentencia `pass` (debido a la sintaxis de Python)\n",
    "    * Devuelve un valor (opcional).\n",
    "        * Si la función no devuelve ningún valor, por defecto siempre se devuelve `None`\n",
    "* Para definir una función se utiliza la keywod `def`.\n",
    "```python\n",
    "def nombre_de_la_funcion(parametro1, parametro2=\"valor por defecto\"):\n",
    "    \"\"\"Docstring.\"\"\"\n",
    "    sentencia_1\n",
    "    sentencia_2\n",
    "    return valor\n",
    "```\n",
    "* Una función se invoca llamándola mediante su nombre, pasando los parámetros entre paréntesis `()`\n",
    "```python\n",
    "nombre_de_la_funcion(parametro1, parametro2=\"valor2\")\n",
    "``` \n",
    "* Según el PEP8, todas las funciones deberían dejar dos lineas en blanco respecto al código anterior.\n",
    "    * Pero no es un fallo de sintaxis\n",
    "* Se pueden definir funciones en cualquier lugar del código, incluso dentro de otras funciones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "def function():\n",
    "    pass\n",
    "\n",
    "res = function()\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "def funcion(parametro1, parametro2=\"valor por defecto\"):\n",
    "    \"\"\"Docstring.\"\"\"\n",
    "    return None\n",
    "\n",
    "res1 = funcion(1)\n",
    "res2 = funcion(1, parametro2=2)\n",
    "print(res1)\n",
    "print(res2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "unexpected EOF while parsing (<ipython-input-9-8a7f00d2525c>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-9-8a7f00d2525c>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    def funcion():\u001b[0m\n\u001b[0m                  ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m unexpected EOF while parsing\n"
     ]
    }
   ],
   "source": [
    "def funcion():"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Ejemplo: número par\n",
    "\n",
    "def es_par(i):\n",
    "    \"\"\"Devuelve True si el número i es par, False si es impar.\n",
    "    \n",
    "    :param i: entero para calcular si es par o no.\n",
    "    \"\"\"\n",
    "    if i % 2:\n",
    "        return False\n",
    "    else:\n",
    "        return True\n",
    "    \n",
    "print(es_par(3))\n",
    "print(es_par(4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Ejemplo: número par\n",
    "\n",
    "def es_par(i):\n",
    "    \"\"\"Devuelve True si el número i es par, False si es impar.\n",
    "    \n",
    "    :param i: entero para calcular si es par o no.\n",
    "    \"\"\"\n",
    "    return i % 2 == 0\n",
    "\n",
    "print(es_par(3))\n",
    "print(es_par(4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function es_par in module __main__:\n",
      "\n",
      "es_par(i)\n",
      "    Devuelve True si el número i es par, False si es impar.\n",
      "    \n",
      "    :param i: entero para calcular si es par o no.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Todo en Python es un objeto, luego:\n",
    "\n",
    "help(es_par)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(es_par.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Argumentos y scope\n",
    "\n",
    "* Los argumentos se definen en la cabecera de la función de la siguiente manera:\n",
    "```python\n",
    "def name(arg1, arg2, ..., argN, kwarg1=val1, kwarg2=val2, ..., kwargN=valN):\n",
    "```\n",
    "    * `arg1`, etc. son argumentos obligatorios\n",
    "        * Siempre hay que pasarselos a la función cuando sea invocada.\n",
    "        * No pueden tomar valores por defecto\n",
    "    * `kwarg1` son argumentos opcionales o _keyword arguments_.\n",
    "        * No hay por que pasarlos.\n",
    "        * Tienen que tener un valor por defecto, que se evalúa *una única vez*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "name() missing 1 required positional argument: 'arg'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-14-ba4ad6385f86>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m     \u001b[0;32mpass\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mname\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: name() missing 1 required positional argument: 'arg'"
     ]
    }
   ],
   "source": [
    "def name(arg):\n",
    "    pass\n",
    "\n",
    "name()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def name(kwarg=None):\n",
    "    pass\n",
    "name()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def name(arg, kwarg=None):\n",
    "    pass\n",
    "\n",
    "name(None)\n",
    "name(None, kwarg=None)\n",
    "name(kwarg=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Los argumentos que se definen en la cabecera de la función se llaman _argumentos formales_\n",
    "* Los argumentos con los que se llama la función son _argumentos reales_\n",
    "* Cuando se llama a una función:\n",
    "    * Los parámetros formales se asignan a los parámetros reales.\n",
    "    * Se crea un nuevo \"scope\" para la función: las nuevas variables solo existen dentro de la función.\n",
    "    * Aún así, una función puede acceder a una variable fuera de la función.\n",
    "    * Pero no puede escribir en ella a menos que sea declarada como global"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# i solo existe dentro de la función es par, y solo durante su invocación\n",
    "\n",
    "def es_par(i):\n",
    "    return i % 2 == 0\n",
    "\n",
    "es_par(2)\n",
    "i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "# Una función puede acceder a una variable fuera de su scope\n",
    "\n",
    "x = 5\n",
    "\n",
    "\n",
    "def foo():\n",
    "    print(x)\n",
    "    \n",
    "foo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "ename": "UnboundLocalError",
     "evalue": "local variable 'x' referenced before assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mUnboundLocalError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-16-9c0a66a858a8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      7\u001b[0m     \u001b[0mx\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0mfoo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-16-9c0a66a858a8>\u001b[0m in \u001b[0;36mfoo\u001b[0;34m()\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mfoo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m     \u001b[0mx\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0mfoo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mUnboundLocalError\u001b[0m: local variable 'x' referenced before assignment"
     ]
    }
   ],
   "source": [
    "# Una función no puede escribir en una variable fuera de su scope\n",
    "\n",
    "x = 5\n",
    "\n",
    "\n",
    "def foo():\n",
    "    x += 1\n",
    "    \n",
    "foo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Una función puede escribir en una variable global fuera de su scope\n",
    "\n",
    "x = 5\n",
    "\n",
    "\n",
    "def foo():\n",
    "    global x\n",
    "    x += 1\n",
    "    \n",
    "foo()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Hay que tener en cuenta la asignación de variables en Python.\n",
    "* Los parámetros formales *se asignan* a los parámetros reales.\n",
    "    * Es decir, que se pasan las referencias, *NO* los valores\n",
    "    * No se realiza una copia.\n",
    "* Esto no es un problema con objetos inmutables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Los paramétros de la función se asignan igual que si fuesen variables,\n",
    "# estando accesible dentro del scope de la función.\n",
    "\n",
    "def cuadrado(i):\n",
    "    i = i * i\n",
    "    return i \n",
    "\n",
    "i = 5\n",
    "print(cuadrado(i))\n",
    "print(\"i:\", i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Pero sí con objetos mutables!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Los paramétros de la función se asignan igual que si fuesen variables,\n",
    "# por lo que hay que tener cuidado con los objetos mutables\n",
    "\n",
    "def ordena_e_imprime(l):\n",
    "    l.sort()\n",
    "    print(\"l ordenada:\", l)\n",
    "\n",
    "l = [10, 2, 23, -1, 99, 12]\n",
    "\n",
    "print(\"   l antes:\", l)\n",
    "ordena_e_imprime(l)\n",
    "print(\" l despues:\", l)  # l se ha modificado!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solución: usar una copia si modificamos objetos mutables\n",
    "\n",
    "def ordena_e_imprime(l):\n",
    "    temp = l[:]\n",
    "    temp.sort()\n",
    "    print(\"l ordenada:\", temp)\n",
    "\n",
    "l = [10, 2, 23, -1, 99, 12]\n",
    "\n",
    "print(\"   l antes:\", l)\n",
    "ordena_e_imprime(l)\n",
    "print(\" l despues:\", l)  # l se ha modificado!!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Los _keyword arguments_ evaluan sus valores por defecto en el momento de su definición.\n",
    "* Esto es peligroso con objetos mutables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# El valor por defecto se evalua al momento de la definición, con lo que\n",
    "# a l se le asigna ya un objeto, lista vacía.\n",
    "\n",
    "def add_to_list(l=[]):\n",
    "    \"\"\"\n",
    "    Añade los valores \"a\", \"b\" y \"c\" a la lista l.\n",
    "    Si no se pasa ninguna lista, devuelve una con esos valores\n",
    "    \"\"\"\n",
    "    l.extend([\"a\", \"b\", \"c\"])\n",
    "    return l\n",
    "\n",
    "print(add_to_list())\n",
    "print(add_to_list())\n",
    "print(add_to_list())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solución, usar None en lugar de una lista vacía\n",
    "\n",
    "def add_to_list(l=None):\n",
    "    \"\"\"\n",
    "    Añade los valores \"a\", \"b\" y \"c\" a la lista l.\n",
    "    Si no se pasa ninguna lista, devuelve una con esos valores\n",
    "    \"\"\"\n",
    "    if l is None:\n",
    "        l = []\n",
    "    l.extend([\"a\", \"b\", \"c\"])\n",
    "    return l\n",
    "\n",
    "print(add_to_list())\n",
    "print(add_to_list())\n",
    "print(add_to_list())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## print vs return\n",
    "\n",
    "* `print()` y `return` son totalmente diferentes!!\n",
    "* `print()`\n",
    "    * escribe por pantalla los argumentos que se le pasen\n",
    "    * se puede llamar cuantas veces se quiera\n",
    "* `return`\n",
    "    * solo se puede utilizar dentro de una función\n",
    "    * solo se va a ejecutar una única vez\n",
    "* En el interprete, una llamada a una función con print y return puede resultar similar, si no se asigna el resultado a una variable, pero no es asi!\n",
    "    * El interprete (y Jupyter) evaluan una expresión y muestran su resultado si este es diferente a `None`.\n",
    "    * REPL: Read, Evaluate, Print, Loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def funcion():\n",
    "    return 1\n",
    "\n",
    "funcion()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "resultado = funcion()\n",
    "print(resultado)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "def funcion():\n",
    "    print(\"1\")\n",
    "    \n",
    "funcion()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "resultado = funcion()\n",
    "print(resultado)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}