notebooks/200_modulos_funciones.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[comment]: <> (los titulares se generan en el siguiente link: https://docs.google.com/drawings/d/1TLM83sTn9w2Jmq0l0Jy1ivIeLRVO_rKBCamm5Tq11Yo/edit?usp=sharing)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](../img/titulo_modulos_funciones.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Contenido\n",
    "\n",
    "* [Modulos](#Modulos)\n",
    "    * [Modulos matemáticos - math y cmath](#Modulos-matematicos-\\--math-y-cmath)\n",
    "    * [From ... import](#From-...-import)\n",
    "    * [Import ... as](#Import-...-as)\n",
    "* [Funciones definidas por el usuario](#Funciones-definidas-por-el-usuario)\n",
    "    * [Encoding - codificacion del codigo fuente](#Encoding-\\--codificacion-del-codigo-fuente)\n",
    "    * [Definición de funciones](#Definicion-de-funciones)\n",
    "    * [Retorno - return](#Retorno-\\--return)\n",
    "    * [Scope](#Scope)\n",
    "    * [Argumentos](#Argumentos)\n",
    "* [Referencias usadas en el notebook](#Referencias-usadas-en-el-notebook)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Objetivos del notebook\n",
    "\n",
    "* Importar y trabajar con modulos externos.\n",
    "* Definir e instanciar funciones.\n",
    "* Trabajar con argumentos de funciones."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modulos\n",
    "\n",
    "Para aquellas funciones que **no están dentro de la librería estandar, se utilizan módulos (librerías), archivos Python **.py** que constan de código Python**. Un [módulo](http://docs.python.org.ar/tutorial/3/modules.html) puede definir funciones, clases y variables, además puede incluir código ejecutable. Se puede hacer referencia a cualquier archivo de Python como un módulo. Un archivo de Python llamado *hello.py* tiene el nombre de módulo \"hello\" que se puede importar a otros archivos de Python o utilizar en el intérprete de línea de comandos de Python. Estos módulos, a la vez, pueden formar parte de **paquetes**. Un paquete, **es una carpeta que contiene archivos .py**, pero para que una carpeta pueda ser considerada un paquete, debe **contener un archivo de inicio llamado __init__.py**. \n",
    "\n",
    "> **Nota:** este archivo, no necesita contener ninguna instrucción. De hecho, puede estar completamente vacío.\n",
    "\n",
    "La estructura general de un módulo es:\n",
    "\n",
    "![](../img/estructura_modulos.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modulos matematicos - math y cmath"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Operaciones matemáticas comunes\n",
    "\n",
    "import math\n",
    "\n",
    "print(\"sin(2\\u03c0/3) = {}\".format(math.sin(2 * math.pi / 3)))\n",
    "print(\"cos(2\\u03c0/3) = {}\".format(math.cos(2 * math.pi / 3)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# En cmath tambien se encuentran las de números complejos\n",
    "\n",
    "import cmath\n",
    "\n",
    "z = 2 + 3j\n",
    "print(\"{0:.3} = modulo = {1[0]:.3} fase = {1[1]:.3}\".format(z,cmath.polar(z)))\n",
    "print(\"sin(z) = {0:.3f}\".format(cmath.sin(z)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### From ... import\n",
    "\n",
    "Para hacer **referencia a los elementos de un módulo**, puede usar la declaración de `from ... import`. Cuando se importa un módulo de esta manera, puede referirse a las funciones por nombres y no a través de la notación de punto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import floor\n",
    "\n",
    "# redondear un número al entero anterior\n",
    "floor(5 / 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import ceil\n",
    "\n",
    "# redondear un número al entero posterior\n",
    "math.ceil(5 / 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import ... as\n",
    "\n",
    "Es posible **modificar los nombres de los módulos** utilizando la palabra clave `as`. Esto es útil para abreviar un nombre más largo. La construcción de esta declaración se ven así:`import [module] as [another_name]`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fae69290e50>]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as p # módulo para hacer plot\n",
    "\n",
    "p.plot(range(7),range(7),'-.',color='b' )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veamos otro ejemplo, la **aproximación de orden 3 del desarrollo de Taylor en 0 de la función seno** es (crean que es así...):\n",
    "\n",
    "$sen(x)\\approx x-x^{3}/6$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np  # módulo para trabajar con array\n",
    "import matplotlib.pyplot as plt # módulo para hacer plot\n",
    "\n",
    "x = np.linspace(-np.pi,+np.pi,100)\n",
    "aprox = x - np.power(x,3)/6\n",
    "\n",
    "plt.plot(x/np.pi,np.sin(x),'r',x/np.pi,aprox,'.')\n",
    "plt.xlabel(\"Radianes [$\\pi$]\")\n",
    "plt.ylabel(\"Amplitud\")\n",
    "plt.grid()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hay módulos de infinidad de disciplinas, a continuación algunas referencias de librerias más utilizadas:\n",
    "\n",
    "* [20 librerías de Python que son sencillamente irresistibles.](https://programacion.net/articulo/20_librerias_de_python_que_son_sencillamente_irresistibles_1061)\n",
    "* [15 librerías para Python que no te debes perder si te interesa la programación.](https://hipertextual.com/2015/01/librerias-para-python)\n",
    "* [Librerías Más Usadas en Python.](http://www.decodigo.com/2019/03/librerias-mas-usadas-python.html)\n",
    "* [Librerías de Python para Machine Learning.](https://iartificial.net/librerias-de-python-para-machine-learning/)\n",
    "\n",
    "Y muchas más. Lo ideal es, antes de comenzar a trabajar en un problema, investigar qué herramientas hay disponibles, para evitar hacer trabajo en vano."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones definidas por el usuario\n",
    "\n",
    "Una [función](http://docs.python.org.ar/tutorial/3/controlflow.html#definiendo-funciones) es la forma de **agrupar expresiones y sentencias** que realicen determinadas acciones, pero que éstas, solo **se ejecuten cuando son llamadas**. Es decir, que al colocar un algoritmo dentro de una función y se corre el archivo, el algoritmo no será ejecutado si no se ha hecho una referencia a la función que lo contiene. Las funciones se pueden considerar como una herramienta para controlar flujo.\n",
    "\n",
    "En definitiva lo más importante para programar, y no solo en Python, es saber organizar el código en piezas más pequeñas que hagan tareas independientes y combinarlas entre sí. Las funciones son el primer nivel de organización del código: reciben unas entradas, las procesan y devuelven unas salidas.\n",
    "\n",
    "![](../img/blackbox.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Encoding - codificacion del codigo fuente\n",
    "\n",
    "Por defecto, los archivos fuente de Python son codificados en [UTF-8](https://es.wikipedia.org/wiki/UTF-8) [G. Van Rossum., 2017].\n",
    "\n",
    "El encoding (o codificación) es otro de los elementos del lenguaje que no puede omitirse a la hora de hablar de estructuras de control. **El encoding no es más que una directiva que se coloca al inicio de un archivo Python, a fin de indicar al sistema, la codificación de caracteres utilizada en el archivo**.\n",
    "\n",
    "``` python\n",
    "# -*- coding: utf-8 -*-\n",
    "``` "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Definicion de funciones\n",
    "\n",
    "Lo vemos con un ejemplo concreto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fib(n):\n",
    "    \"\"\" Escribe la serie de Fibonacci hasta n. \"\"\"\n",
    "    \n",
    "    a, b = 0, 1  # asignacion multiple\n",
    "    while a < n:\n",
    "        print (a, end = ' ') # es para imprimirlos seguidos y no uno debajo del otro.\n",
    "        a, b = b, a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Object `fib(n)` not found.\n"
     ]
    }
   ],
   "source": [
    "?fib(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 "
     ]
    }
   ],
   "source": [
    "# Invocamos la función definida.    \n",
    "fib(2000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La palabra reservada `def` se usa para **definir funciones**. Debe seguirle el nombre de la función y la **lista de argumentos entre paréntesis**. Las sentencias que forman el cuerpo de la función empiezan en la línea siguiente, y deben estar con identado. **La primer sentencia** del cuerpo de la función puede ser opcionalmente una cadena de texto literal (utilizar `\"\"\"`, en lugar de `#`); esta es la cadena de texto de documentación de la función, o **docstring**. Es una buena práctica, no solo documentar las funciones, sino hacerlo con un estilo único y estandarizado. Una referencia respaldada en el ecosistema científico es el estilo de documentación de [NumPy](https://numpydoc.readthedocs.io/en/latest/format.html#docstring-standard)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Retorno - return\n",
    "\n",
    "Si lo que buscamos es escribir una función que **retorne** una lista con los números de la serie de Fibonacci en lugar de imprimirlos, podemos pensar en el siguiente ejemplo para completar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597]\n"
     ]
    }
   ],
   "source": [
    "def fib2(n):\n",
    "    \"\"\"Devuelve una lista conteniendo la serie de Fibonacci hasta n.\"\"\"\n",
    "    \n",
    "    resultado = [] # inicializo la lista completar! \n",
    "    a, b = 0, 1  # asignacion multiple\n",
    "    while a < n:\n",
    "        resultado # completar! \n",
    "        a, b = # completar! \n",
    "    return # completar! \n",
    "\n",
    "# Invocamos la función definida.    \n",
    "fib2000 = fib2(2000) \n",
    "print() # completar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%run ../code/fibo.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scope\n",
    "\n",
    "Es importante resaltar que **las variables que se crean dentro de las funciones no son accesibles una vez que termina la ejecución de la función**. En cambio, la función si que puede acceder a cosas que se han definido fuera de ella. No obstante, esto último no constituye una buena práctica de cara a la reproducibilidad, mantenibilidad y testeo de la función. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Argumentos\n",
    "\n",
    "También es posible definir funciones con un número variable de argumentos. Hay tres formas que pueden ser combinadas:\n",
    "\n",
    "* Argumentos con valores por omisión.\n",
    "* Palabras claves como argumentos.\n",
    "* Listas de argumentos arbitrarios."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Argumentos con valores por omision\n",
    "\n",
    "La forma más útil es especificar un valor por omisión para uno o más argumentos. Esto crea una función que puede ser llamada con menos argumentos que los que permite. Por ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pedir_confirmacion(prompt, reintentos=4, recordatorio=\"Por favor, intente nuevamente!\"):\n",
    "    while True:\n",
    "        ok = input(prompt)\n",
    "        if ok in (\"s\", \"S\", \"si\", \"Si\", \"SI\", \"sI\"):  # contemplando todos los casos, \"in\" palabra resevada para probar si una secuencia contiene o no un determinado valor.\n",
    "            return True\n",
    "        if ok in (\"n\", \"N\", \"no\", \"No\", \"NO\", \"nO\"):  # contemplando todos los casos\n",
    "            return False\n",
    "        reintentos -= 1\n",
    "        if reintentos < 0:\n",
    "            raise ValueError(\"respuesta de usuario inválida\")\n",
    "        print (recordatorio)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# pasando solo el argumento obligatorio\n",
    "\n",
    "pedir_confirmacion(\"¿Realmente queres salir?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# pasando uno de los argumento opcionales\n",
    "\n",
    "pedir_confirmacion(\"¿Sobreescribir el archivo?\", 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# pasando todos los argumentos\n",
    "\n",
    "pedir_confirmacion(\"¿Sobreescribir el archivo?\", 2, \"Vamos, solo si o no!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Palabras claves como argumentos\n",
    "\n",
    "Las funciones también puede ser llamadas usando argumentos con palabras claves (o argumentos nombrados) de la forma **keyword = value**. Por ejemplo, la siguiente función:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loro(tension, estado='muerto', accion='explotar', tipo='Azul Nordico'):\n",
    "    print(\"-- Este loro no va a\", accion, end=' ')\n",
    "    print(\"si le aplicás\", tension, \"voltios.\")\n",
    "    print(\"-- Gran plumaje tiene el\", tipo)\n",
    "    print(\"-- Está\", estado, \"!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Acepta un argumento obligatorio (tensión) y tres argumentos opcionales (estado, accion, y tipo). Esta función puede llamarse de cualquiera de las siguientes maneras:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "loro(1000)  # 1 argumento posicional"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "loro(tension=1000)  # 1 argumento nombrado, palabra clave"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "loro(tension=1000000, accion='BOOOOOM')  # 2 argumentos nombrados"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "loro(accion='BOOOOOM', tension=1000000) # 2 argumentos nombrados, sin orden"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cuando un parámetro formal de la forma `**nombre` está presente al final, **recibe un diccionario** conteniendo todos los argumentos nombrados excepto aquellos correspondientes a un parámetro formal. Esto puede ser combinado con un parámetro formal de la forma `*nombre` que **recibe una tupla** conteniendo los argumentos posicionales además de la lista de parámetros formales. (`*nombre` debe ocurrir antes de `**nombre`). Por ejemplo, si definimos una función así:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def venta_de_queso (tipo, *argumento, **palabrasclaves):\n",
    "    print(\"-- ¿Tiene\", tipo, \"?\")\n",
    "    print(\"-- Lo siento, nos quedamos sin\", tipo)\n",
    "    for arg in argumento:\n",
    "        print(arg)\n",
    "    print(\"-\" * 40)\n",
    "    for c in palabrasclaves:\n",
    "        print(c, \":\", palabrasclaves[c])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Puede ser llamada así:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "venta_de_queso(\"Limburger\", \"Es muy liquido, sr.\", \"Realmente es muy liquido, sr.\", \n",
    "               cliente=\"Juan Gomez\",\n",
    "               vendedor=\"Miguel Paez\",\n",
    "               puesto=\"Venta de Queso Argentino\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Listas de argumentos arbitrarios\n",
    "\n",
    "Finalmente, la opción menos frecuentemente usada es especificar que una función puede ser llamada con un número arbitrario de argumentos. Estos argumentos serán organizados en una tupla. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(*args):\n",
    "    return args"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f(1, 5, True, False, \"Hello, world!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Referencias usadas en el notebook\n",
    "\n",
    "* G. Van Rossum. El tutorial de Python. PyAr http://docs.python.org.ar/tutorial/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Licencia\n",
    "\n",
    "<a rel=\"license\" href=\"http://creativecommons.org/licenses/by-sa/4.0/\"><img alt=\"Licencia de Creative Commons\" style=\"border-width:0\" src=\"https://i.creativecommons.org/l/by-sa/4.0/88x31.png\" /></a><br />Este documento se destribuye con una <a rel=\"license\" href=\"http://creativecommons.org/licenses/by-sa/4.0/\">licencia Atribución CompartirIgual 4.0 Internacional de Creative Commons</a>.\n",
    "\n",
    "© 2019. Infiniem Labs Acústica. infiniemlab.dsp@gmail.com (CC BY-SA 4.0))"
   ]
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}