Programación-Python/Cuadernos/py_0120_Decoradores.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <span style=\"color:#F72585\"><center>Decoradores</center></span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<figure>\n",
    "<center>\n",
    "<img src=\"https://raw.githubusercontent.com/AprendizajeProfundo/Alejandria/main/Archivos_Generales/Imagenes/Rey_Ajedrez.jpg\" width=\"600\" height=\"400\" align=\"center\" /> \n",
    "</center>   \n",
    "</figure>\n",
    "<center>\n",
    "\n",
    "Fuente: [Pexels](https://www.pexels.com/es-es/foto/pieza-de-ajedrez-260024/)\n",
    "\n",
    "</center>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:blue\">Introducción</span> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los decoradores (decorators) constituyen un patrón de programación que se utiliza cuando es necesario incluir un comportamiento adicional a objetos específicos. Una forma de agregar tal comportamiento adicional es decorar los objetos creados con tipos que aportan la funcionalidad extra.\n",
    "\n",
    "Estos decoradores envuelven el objeto original pero presentan exactamente la misma interfaz para\n",
    "el usuario de ese objeto. Por lo tanto, el patrón de diseño del decorador extiende el comportamiento\n",
    "de un objeto sin utilizar subclassing. La decoración de un objeto es transparente a los clientes de los decoradores.\n",
    "\n",
    "En Python, los decoradores son funciones que toman otra función (u otro objeto invocable\n",
    "como un método) y devuelve una tercera función que representa el \n",
    "comportamiento decorado."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:blue\">Decoradores</span> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:#4CC9F0\">Definición de un decorador</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para definir un decorador, debe definir un objeto invocable, como una función que\n",
    "toma otra función como parámetro y devuelve una nueva función. A continuación se da un ejemplo de la definición de una función decoradora de registro (logger) muy simple\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def logger(func):\n",
    "    def inner():\n",
    "        print('llamando ', func.__name__)\n",
    "        func()\n",
    "        print('llamada', func.__name__)\n",
    "        \n",
    "    return inner"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe que la función *logger* retorna una función, *inner*, la cual a su vez llamará a una tercera función *func*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:#4CC9F0\">Usando el decorador</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veamos ahora el efecto del decorador en acción. Usaremos la función *target* como la función que vamos a decorar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def target(): \n",
    "    print('Dentro de la función target')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "llamando  target\n",
      "Dentro de la función target\n",
      "llamada target\n"
     ]
    }
   ],
   "source": [
    "t1 = logger(target)\n",
    "\n",
    "t1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:#4CC9F0\">Suavizando el trabajo de definición de un decorador</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python proporciona algo de azúcar sintáctico que permite decorar directamente la función desde su definición. Este es el uso más practico de los decoradores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "llamando  target\n",
      "Dentro de la función target\n",
      "llamada target\n"
     ]
    }
   ],
   "source": [
    "@logger\n",
    "def target():\n",
    "    print('Dentro de la función target')\n",
    "\n",
    "target()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:#4CC9F0\">Funciones con parámetros</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este caso la función decoradora debe incluir los parámetros. Veamos el ejemplo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def logger(func):\n",
    "    def inner(x, y):\n",
    "        print('llamando ', func.__name__, 'con ',x , 'y',y)\n",
    "        func(x, y)\n",
    "        print('regresando de ',func.__name__)\n",
    "    return inner"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "llamando  mi_funcion con  5 y 6\n",
      "x + y =  11\n",
      "regresando de  mi_funcion\n"
     ]
    }
   ],
   "source": [
    "@logger\n",
    "def mi_funcion(x, y):\n",
    "    print('x + y = ', x+y)\n",
    "\n",
    "mi_funcion(5,6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:#4CC9F0\">Decoradores apilados (stacked decorators)</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible apilar decoradores. Veamos el ejemplo. Vamos a imprimir un texto. Los decoradores agregaran negrilla (bold) e itálica (italic) al texto impreso."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<b><i>hola mundo</i></b>\n"
     ]
    }
   ],
   "source": [
    "# decoradores\n",
    "def make_bold(fn):\n",
    "    def makebold_wrapper():\n",
    "        return \"<b>\" + fn() + \"</b>\"\n",
    "    return makebold_wrapper\n",
    "\n",
    "def make_italic(fn):\n",
    "    def makeitalic_wrapper():\n",
    "        return \"<i>\" + fn() + \"</i>\"\n",
    "    return makeitalic_wrapper\n",
    "\n",
    "# aplica los decoradores\n",
    "\n",
    "@make_bold\n",
    "@make_italic\n",
    "def hello():\n",
    "    return 'hola mundo'\n",
    "\n",
    "print(hello())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:#4CC9F0\">Decoradores para métodos de clases</span> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este caso,  es importante recordar que los métodos toman el \n",
    "parámetro especial *self* como el primer parámetro que se utiliza para hacer referencia al objeto del que\n",
    "se está aplicando el método. Por lo tanto, es necesario que el decorador tome este parámetro en cuenta; es decir, la función envuelta interna debe tomar al menos un parámetro que representa a *self*. Veamos el ejemplo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pretty_print(method):\n",
    "    def method_wrapper(self):\n",
    "        return \"<p>{0}</p>\".format(method(self))\n",
    "    return method_wrapper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Persona:\n",
    "    def __init__(self, nombre, apellido, edad):\n",
    "        self.nombre = nombre\n",
    "        self.apellido = apellido\n",
    "        self.edad = edad\n",
    "        \n",
    "    def print_self(self):\n",
    "        print('Persona - ', self.nombre, ', ', self.edad)\n",
    "        \n",
    "    @pretty_print\n",
    "    def get_nombre_completo(self):\n",
    "        return self.nombre + \" \" + self.apellido"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Comenzamos\n",
      "Persona -  Alvaro ,  61\n",
      "<p>Alvaro Montenegro</p>\n",
      "Hecho!\n"
     ]
    }
   ],
   "source": [
    "print('Comenzamos')\n",
    "p = Persona('Alvaro', 'Montenegro', 61)\n",
    "p.print_self()\n",
    "print(p.get_nombre_completo())\n",
    "print('Hecho!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:#4CC9F0\">Decoradores para métodos de clases con parámetros</span> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aquí combinamos lo hecho en las dos subsecciones anteriores. Veamos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def trace(method): \n",
    "    def method_wrapper(self, x, y):\n",
    "        print('Llamando', method.__name__, 'con', x, y)\n",
    "        method(self, x, y)\n",
    "        print('Se llamó', method.__name__, 'con', x, y)\n",
    "    return method_wrapper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Point:\n",
    "    def __init__(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "\n",
    "    @trace\n",
    "    def move_to(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "\n",
    "    def __str__(self):\n",
    "        return 'Point - ' + str(self.x) + ',' + str(self.y)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Point - 1,1\n",
      "Llamando move_to con 5 5\n",
      "Se llamó move_to con 5 5\n",
      "Point - 5,5\n"
     ]
    }
   ],
   "source": [
    "p = Point(1, 1)\n",
    "print(p)\n",
    "p.move_to(5,5)\n",
    "print(p)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}