18b-Orientacion-a-Objetos-2parte.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Programación orientada a objetos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La idea básica en programación orientada a objetos es organizar los conceptos en **clases** o tipos de datos, cada uno de los cuales actuará como una unidad de información independiente. Estas clases se concretarán en uno o más **objetos**, instancias conretas del concepto representado pro la clase.\n",
    "\n",
    "Con más detalle:\n",
    "\n",
    "- Una clase define el conmportamiento de un nuevo concepto, mientras que un objeto es una variable concreta que representa a ese nuevo concreto.\n",
    "- Las clases y los objetos combinan datos (llamados **atributos**) y funciones que actúan sobre ellos (llamadas funciones **miembro***).\n",
    "- Las clases contienen funciones llamadas **constructores** que definen cómo debe ser creado un objeto particular.\n",
    "- Una clase puede **heredar** su comportamiento a partir de otra clase diferente y añadir o modificar sobre esta última aquello que necesite.\n",
    "\n",
    "Algunos conceptos usuales en orientación a objetos:\n",
    "\n",
    "- **Encapsulamiento**: Los objetos contienen o encapsulan datos\n",
    "- **Herencia**: Relación de jerarquía entre conceptos, según la cual una clase se deriva de (o extiende a) otra\n",
    "- **Polimorfismo**: Cada modelo, quizás derivado de otro, puede personalizar su comportamiento"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Un ejemplo en Python: la clase \"Tortuga\"\n",
    "\n",
    "El lenguaje de programación [Logo](https://es.wikipedia.org/wiki/Logo_(lenguaje_de_programaci%C3%B3n)) fue diseñado con fines didácticos y una de sus principales características es la posibilidad de producir [gráficas de tortuga](https://es.wikipedia.org/wiki/Gr%C3%A1ficas_tortuga).\n",
    "\n",
    "Según Wikipedia: *Gráfica tortuga* es un término usado en computación gráfica como método para programar gráficos vectoriales usando un cursor relativo (la «tortuga») a unas coordenadas cartesianas. La tortuga tiene tres atributos:\n",
    "\n",
    "- Una posición\n",
    "- Una orientación\n",
    "- Una pluma, teniendo atributos como color, ancho y un indicador de pluma arriba y abajo.\n",
    "\n",
    "La tortuga se mueve con comandos relativos a su posición, como «avanza 10 » y «gira a la izquierda 90». Los valores «10» o «90» representan magnitudes diferentes, las cuales se verifican en la práctica.\n",
    "\n",
    "Vamos a concretar este concepto en una clase, en principio vacía:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Tortuga(object):\n",
    "    \"\"\"Clase que define el concepto de *cursor relativo* utilizado en gráficas de tortuga\"\"\"\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos crear un objeto de tipo ``Tortuga`` de la siguiente forma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on Tortuga in module __main__ object:\n",
      "\n",
      "class Tortuga(builtins.object)\n",
      " |  Clase que define el concepto de *cursor relativo* utilizado en gráficas de tortuga\n",
      " |  \n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "casiopea = Tortuga()  # Casiopea era el nombre de la tortuga de Momo\n",
    "help(casiopea)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En la actualidad, la clase tortuga no presenta ninguna funcionalidad. Pero en Python podemos asignar atributos a los objetos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on Tortuga in module __main__ object:\n",
      "\n",
      "class Tortuga(builtins.object)\n",
      " |  Clase que define el concepto de *cursor relativo* utilizado en gráficas de tortuga\n",
      " |  \n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "casiopea.posicion = [0,0] # Situamos a esta tortuga en el origen (suponemos 2D)\n",
    "casiopea.orientacion = [0,1] # La tortuga mira hacia arriba\n",
    "casiopea.pluma_abajo = True # Tiene la pluma sobre el papel\n",
    "help(casiopea)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nos gustaría que todas las tortugas que construyamos tuvieran estos atributos. Para ello, podemos redefinir la clase Tortuga, dotándola de un constructor. En Python los constructores se definen a través de una función miembro llamada ``__init__`` (con doble guión bajo a izquierda y derecha).\n",
    "\n",
    "Vamos a añadir un nuevo atributo a la tortuga: un color (que luego asociaremos al color de pluma)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Tortuga(object):\n",
    "    \"\"\"Clase que define el concepto de *cursor relativo* utilizado en gráficas de tortuga\"\"\"\n",
    "    \n",
    "    def __init__(self, posicion=[0,0], orientacion=[1,0], color=\"Negro\"):\n",
    "        \"\"\"Constructor: inicializa una tortuga\"\"\"\n",
    "        self.posicion = posicion # Situamos a esta tortuga en el origen (suponemos 2D)\n",
    "        self.orientacion = orientacion # La tortuga mira hacia arriba\n",
    "        self.pluma_abajo = True # Tiene la pluma sobre el papel\n",
    "        self.color = color\n",
    "        \n",
    "    def info(self):\n",
    "        \"\"\"Imprime información sobre la tortuga\"\"\"\n",
    "        print(\"Posición:    \" + str(self.posicion))\n",
    "        print(\"Orientación: \" + str(self.orientacion))\n",
    "        print(\"Color:       \" + str(self.color))\n",
    "        print(\"Pluma abajo: \" + str(self.pluma_abajo))\n",
    "        \n",
    "    def __str__(self):\n",
    "        \"\"\"\n",
    "        Devuelve una representación de tipo string del objeto. \n",
    "        Es usada en particular por las funciones print() y chr()\n",
    "        \"\"\"\n",
    "        s = \"P=%s, V=%s, C=%s, p=%s\" % (self.posicion, self.orientacion, self.color, self.pluma_abajo)\n",
    "        return s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Posición:    [0, 0]\n",
      "Orientación: [1, 0]\n",
      "Color:       Negro\n",
      "Pluma abajo: True\n",
      "-----\n",
      "Casiopea: P=[0, 0], V=[1, 0], C=Negro, p=True\n"
     ]
    }
   ],
   "source": [
    "casiopea = Tortuga()\n",
    "casiopea.info()\n",
    "print(\"-----\")\n",
    "print(\"Casiopea:\", casiopea)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los objetos que definimos pueden aprovechar todas las características de Python. Por ejemplo, podríamos hacer una lista comprehensiva de tortugas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P=[0, 0], V=[1, 0], C=Azul, p=True\n"
     ]
    }
   ],
   "source": [
    "lista_tortugas = [Tortuga(color=c) for c in (\"Azul\", \"Rojo\", \"Naranja\", \"Violeta\") ]\n",
    "print(lista_tortugas[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O un diccionario de Tortugas Ninja ;-)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Leonardo...\tP=[0, 0], V=[1, 0], C=Azul, p=True\n",
      "Rafael...\tP=[0, 0], V=[1, 0], C=Rojo, p=True\n",
      "Michelangelo...\tP=[0, 0], V=[1, 0], C=Naranja, p=True\n",
      "Donatello...\tP=[0, 0], V=[1, 0], C=Violeta, p=True\n"
     ]
    }
   ],
   "source": [
    "tortugas_ninja = { \n",
    "    \"Leonardo\": Tortuga(color=\"Azul\"),\n",
    "    \"Rafael\" : Tortuga(color=\"Rojo\"),\n",
    "    \"Michelangelo\" : Tortuga(color=\"Naranja\"),\n",
    "    \"Donatello\" : Tortuga(color=\"Violeta\")\n",
    "}\n",
    "for nombre in tortugas_ninja.keys():\n",
    "    print(nombre + \"...\\t\" + str(tortugas_ninja[nombre]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Moviendo la tortuga en el plano\n",
    "\n",
    "En la siguiente versión añadimos métodos para mover y girar la tortuga. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import array, sin, cos, pi, dot\n",
    "\n",
    "class Tortuga(object):\n",
    "    \"\"\"Clase que define el concepto de *cursor relativo* utilizado en gráficas de tortuga\"\"\"\n",
    "    \n",
    "    def __init__(self, posicion=[0,0], orientacion=[1,0], color=\"Negro\"):\n",
    "        \"\"\"Constructor: inicializa una tortuga\"\"\"\n",
    "        self.posicion = array(posicion, dtype='float64') # array de coma flotante\n",
    "        self.orientacion = array(orientacion, dtype='float64')\n",
    "        self.pluma_abajo = True \n",
    "        self.color = color\n",
    "        \n",
    "    def info(self):\n",
    "        \"\"\"Imprime información sobre la tortuga\"\"\"\n",
    "        print(\"Posición:    \" + str(self.posicion))\n",
    "        print(\"Orientación: \" + str(self.orientacion))\n",
    "        print(\"Color:       \" + str(self.color))\n",
    "        print(\"Pluma abajo: \" + str(self.pluma_abajo))\n",
    "\n",
    "    def __str__(self):\n",
    "        \"\"\"\n",
    "        Devuelve una representación de tipo string del objeto. \n",
    "        Es usada en particular por las funciones print() y chr()\n",
    "        \"\"\"\n",
    "        s = \"P=%s, V=%s, C=%s, p=%s\" % (self.posicion, self.orientacion, self.color, self.pluma_abajo)\n",
    "        return s\n",
    "    \n",
    "    def avanza(self, d):\n",
    "        \"\"\"Avanza una distancia d\"\"\"\n",
    "        self.posicion += d*self.orientacion\n",
    "        \n",
    "    def izquierda(self, a):\n",
    "        \"\"\"Gira un águlo a (en radianes) en sentido positivo\"\"\"\n",
    "        R = array( [[cos(a), -sin(a)],\n",
    "                    [sin(a),  cos(a)] ])\n",
    "        self.orientacion = dot(R, self.orientacion)\n",
    "\n",
    "    def derecha(self, a):\n",
    "        \"\"\"Gira un águlo a (en radianes) en sentido negativo\"\"\"\n",
    "        R = array( [[ cos(a), sin(a)],\n",
    "                    [-sin(a), cos(a)] ])\n",
    "        self.orientacion = dot(R, self.orientacion)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P=[ 0.  0.], V=[ 1.  0.], C=Negro, p=True\n",
      "P=[ 5.  0.], V=[ 1.  0.], C=Negro, p=True\n",
      "P=[ 5.  0.], V=[  6.12323400e-17   1.00000000e+00], C=Negro, p=True\n",
      "P=[ 5.  0.], V=[ 1.  0.], C=Negro, p=True\n"
     ]
    }
   ],
   "source": [
    "casiopea = Tortuga()\n",
    "print(casiopea)\n",
    "\n",
    "casiopea.avanza(5)\n",
    "print(casiopea)\n",
    "\n",
    "casiopea.izquierda(pi/2)\n",
    "print(casiopea)\n",
    "\n",
    "casiopea.derecha(pi/2)\n",
    "print(casiopea)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Herencia: Una tortuga que almacena la ruta\n",
    "\n",
    "Como ejemplo de herencia, vamos a definir una clase derivada de ``Tortuga`` en la que los objetos tienen memoria en el siguiente sentido: se almacena la ruta seguida por la tortuga (en forma de lista de puntos).\n",
    "\n",
    "Se definirá una clase llamada ``TortugaConMemoria`` derivada de la clase ``Tortuga``. En términos de orientación a objetos, de dice también que ``Tortuga`` es una super-clase de (la sub-clase) ``TortugaConMemoria``."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import allclose\n",
    "import matplotlib.pylab as plt\n",
    "from matplotlib.colors import to_rgba_array\n",
    "\n",
    "class TortugaConMemoria(Tortuga):\n",
    "    def __init__(self, posicion=[0,0], orientacion=[1,0], color=\"Negro\"):\n",
    "        super().__init__(posicion, orientacion, color)  # Inicializar la super-clase tortuga\n",
    "        self.ruta = [self.posicion.copy()]\n",
    "    \n",
    "    def guarda_posicion(self):\n",
    "        # Sólo guardamos la nueva posición si ésta es diferente a la posición anteior.\n",
    "        # Si, por ejemplo, escribimos avanza(0) no tiene sentido guardar de nuevo\n",
    "        # la posición en la ruta. Para evitar la igualdad en coma flotante, usamos la función\n",
    "        # \"allclose\" que comprueba que todos los elementos del array están a distancia < epsilon\n",
    "        if not allclose( self.posicion, self.ruta[-1]):\n",
    "            self.ruta.append(self.posicion.copy())\n",
    "        \n",
    "    def avanza(self,d):\n",
    "        super(TortugaConMemoria, self).avanza(d)\n",
    "        self.guarda_posicion()\n",
    "        \n",
    "    def info(self):\n",
    "        super(TortugaConMemoria, self).info()\n",
    "        print(\"Ruta: \" + str(self.ruta))    \n",
    "        \n",
    "    def plot(self, figsize=(6,6), ticks=False):\n",
    "        # 1. Cosméticca\n",
    "        plt.figure(figsize=figsize) # Tamaño de la gráfica (en pulgadas)\n",
    "        if not ticks: # ¿Dibujar marcas en los ejes?\n",
    "            ax = plt.gca() # Get current axis\n",
    "            ax.set_xticks([])\n",
    "            ax.set_yticks([])\n",
    "\n",
    "        x = [P[0] for P in self.ruta] # Usamos \"list comprehension\"\n",
    "        y = [P[1] for P in self.ruta] # Usamos \"list comprehension\"\n",
    "        try: \n",
    "            # Intentamos dibujar con color\n",
    "            to_rgba_array(self.color) # self.color, ¿se puede convertir en color Red/Green/Blue?\n",
    "            plt.plot(x, y, color=self.color)\n",
    "        except:\n",
    "            # Si el código anterior arroja una excepción porque no conoce el color:\n",
    "            plt.plot(x, y, color=\"black\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora creamos y usamos una tortuga. Se puede comprobar que las clases derivadas heredan los atributos y funciones miembro de la superclase, por ejemplo la función ``derecha()``:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Posición:    [ 0.  0.]\n",
      "Orientación: [ 1.  0.]\n",
      "Color:       Verde\n",
      "Pluma abajo: True\n",
      "Ruta: [array([ 0.,  0.])]\n",
      "\n",
      "Posición:    [ 10.   0.]\n",
      "Orientación: [ 1.  0.]\n",
      "Color:       Verde\n",
      "Pluma abajo: True\n",
      "Ruta: [array([ 0.,  0.]), array([ 10.,   0.])]\n",
      "\n",
      "Posición:    [ 10.   0.]\n",
      "Orientación: [  6.12323400e-17  -1.00000000e+00]\n",
      "Color:       Verde\n",
      "Pluma abajo: True\n",
      "Ruta: [array([ 0.,  0.]), array([ 10.,   0.])]\n"
     ]
    }
   ],
   "source": [
    "t = TortugaConMemoria(color=\"Verde\")\n",
    "t.info(); print()\n",
    "t.avanza(10)\n",
    "t.info(); print()\n",
    "t.derecha(pi/2)  # Ésta es una función de la super-clase Tortuga\n",
    "t.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f5865cab6d8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def dibuja_cuadrado(lado):\n",
    "    \"Función que dibuja un cuadrado usando 'geometría de tortuga'\"\n",
    "    t = TortugaConMemoria(color=\"red\")\n",
    "    for i in range(4):\n",
    "        t.avanza(lado)\n",
    "        t.izquierda(pi/2)\n",
    "    t.plot()\n",
    "    \n",
    "dibuja_cuadrado(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def espiro(ángulo, máximo, lado=1, color=\"blue\", infinito=20):\n",
    "    \"\"\"\n",
    "    Gráfico de una 'curva epirolateral'\n",
    "    Un patrón se repite \"infinitas veces\" (un número de veces sifuciente para cerrar la curva)\n",
    "    \"\"\"\n",
    "    tortuga = TortugaConMemoria(color=color)\n",
    "    for veces in range(infinito):\n",
    "        contador = 1\n",
    "        while contador <= máximo:\n",
    "            tortuga.avanza(contador*lado)\n",
    "            tortuga.derecha(ángulo)\n",
    "            contador += 1\n",
    "    tortuga.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f5863c91198>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "espiro(ángulo=pi/2, máximo=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f5863c91630>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "espiro(ángulo=4*pi/5, máximo=8, color=\"green\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dibujar_lado_copo(tortuga, tamaño, nivel):\n",
    "    if nivel==0:\n",
    "        tortuga.avanza(tamaño)\n",
    "    else:\n",
    "        dibujar_lado_copo(tortuga, tamaño/3, nivel-1)\n",
    "        tortuga.izquierda(pi/3)\n",
    "        dibujar_lado_copo(tortuga, tamaño/3, nivel-1)\n",
    "        tortuga.derecha(2*pi/3)\n",
    "        dibujar_lado_copo(tortuga, tamaño/3, nivel-1)\n",
    "        tortuga.izquierda(pi/3)\n",
    "        dibujar_lado_copo(tortuga, tamaño/3, nivel-1)\n",
    "        \n",
    "def copo_nieve(nivel, color=\"cyan\"):\n",
    "    tortuga = TortugaConMemoria(color=color)\n",
    "    tamaño=1\n",
    "    for veces in range(3):\n",
    "        dibujar_lado_copo(tortuga, tamaño, nivel)\n",
    "        tortuga.derecha(2*pi/3)\n",
    "    tortuga.plot(figsize=(9,9))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f5863c3e278>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "copo_nieve(nivel=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Podemos usar `ipywidgets` para interaccionar con la tortuga \n",
    "\n",
    "---\n",
    "\n",
    "**Atención**: esta sección debe ejecutarse en un *notebook* local, pues no es posible intereaccionar con los *widgets* de Ipython (deslizadores, selectores de valores, etc) a través de internet.\n",
    "\n",
    "Para interaccionar con los *widgets*, se puede [descargar de internet](https://nbviewer.jupyter.org) el *notebook* (a un fichero ``.ipynb`` local) y luego abrirlo con *Jupyter*. También se pueden [descargar todos los *notebooks* desde Github](https://github.com/rrgalvan/IntroPythonMasterMatemat) (pulsar \"Clone or download\").\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1454f53df69340bebd13a6185f0ae85a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=2, description='nivel', max=5), Dropdown(description='color', index=3, o…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.copo_nieve>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from ipywidgets import *\n",
    "\n",
    "# Manejamos la función copo_nieve de forma interactiva\n",
    "interact(copo_nieve, \n",
    "         nivel = (0,5), \n",
    "         color = [\"orange\",\"green\",\"blue\",\"cyan\"] )\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### También usamos *widgets* para dibujar espirolaterales de forma interactiva"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "558a9103e97447c9b523b251f77113d5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(BoundedIntText(value=170, description='Grados', max=360, step=5), BoundedIntText(value=4…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.espiro_grados>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Es más intuitivo si defino la espirolateral con ángulos dados en grados\n",
    "def espiro_grados(grados, máximo, color):\n",
    "    \"Curva espirolateral en la que los ángulos se definen en grados\"\n",
    "    radianes = grados*pi/180\n",
    "    espiro(ángulo=radianes, máximo=máximo, color=color)\n",
    "\n",
    "interact(espiro_grados, \n",
    "         grados = BoundedIntText(description=\"Grados\", min=0, max=360, value=170, step=5),\n",
    "         máximo = BoundedIntText(description=\"Máximo\", min=0,max=60, value=40),\n",
    "         color  = ColorPicker(description='Escoge color', value='slateblue' ) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}