clase_2_python/cuadernos/py_03_intro_clases.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "<figure>\n",
    "<img src=\"../imagenes/logo-final-ap.png\"  width=\"80\" height=\"80\" align=\"left\"/> \n",
    "</figure>\n",
    "\n",
    "# <span style=\"color:blue\"><left>Aprendizaje Profundo</left></span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <span style=\"color:red\"><center>Introducción a Clases en Python </center></span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##   <span style=\"color:blue\">Autores</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Alvaro Mauricio Montenegro Díaz, ammontenegrod@unal.edu.co\n",
    "2. Daniel Mauricio Montenegro Reyes, dextronomo@gmail.com "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##   <span style=\"color:blue\">Asesora Medios y Marketing digital</span>\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. Maria del Pilar Montenegro, pmontenegro88@gmail.com "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:blue\">Asistentes</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. Oleg Jarma, ojarmam@unal.edu.co \n",
    "6. Laura Lizarazo, ljlizarazore@unal.edu.co "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:blue\">Contenido</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* [Introducción](#Introducción)\n",
    "* [Clases](#Clases)\n",
    "* [La función \\_\\_init\\_\\_()](#La-función-\\_\\_init\\_\\_())\n",
    "* [Documentación de una clase](#Documentación-de-una-clase)\n",
    "* [Agregando métodos a una clase](#Agregando-métodos-a-una-clase)\n",
    "* [Imprimiendo contenidos de una clase por defecto](#Imprimiendo-contenidos-de-una-clase-por-defecto)\n",
    "* [Ejecución de una tarea por defecto en una instancia de clase: call](#Ejecución-de-una-tarea-por-defecto-en-una-instancia-de-clase:-call)\n",
    "* [Referencias y copia de objetos](#Referencias-y-copia-de-objetos)\n",
    "* [Eliminación de objetos: del](#Eliminación-de-objetos:-del)\n",
    "* [Atributos Intrínsicos de clases y objetos](#Atributos-Intrínsicos-de-clases-y-objetos)\n",
    "* [Herencia de clases](#Herencia-de-clases)\n",
    "* [Referencia a la clase base:  super()](#Referencia-a-la-clase-base:-super())\n",
    "\n",
    "\n",
    "* [Función super()](#Función-super())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## <span style=\"color:blue\">Introducción</span> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python es un lenguaje de programación orientado a objetos.\n",
    "\n",
    "**Todo** en Python es un objeto, con sus propiedades y métodos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## <span style=\"color:blue\">Clases</span> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos imaginarnos **una clase** como una plantilla o un plano para construir objetos.\n",
    "\n",
    "Para crear una clase, usa el la palabra clave```class:```\n",
    "\n",
    "Supongamos, por ejemplo, que queremos crear una plataforma para recolectar toda la información personal que podamos de nuestros usuarios (nada parecido con la realidad) porque... sí.\n",
    "\n",
    "Creemos una clase que no haga nada."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Usuario:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.Usuario"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Usuario"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La razón de ```pass``` es debido a que una clase necesita al menos una línea para poder existir.\n",
    "\n",
    "**Consejo:** Para crear los nombres de las clases, comience con mayúsculas.\n",
    "\n",
    "Ok. Ahora creemos un usuario:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "u1=Usuario()\n",
    "u2=Usuario()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.Usuario at 0x7fe7c4092400>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como podemos ver, parece que estuvieramos llamando un método (o función), y en efecto es algo parecido\n",
    "\n",
    "```u1``` es una **instancia** de la clase Usuario.\n",
    "\n",
    "También podemos llamar a ```u1``` un objeto.\n",
    "\n",
    "Podemos adjuntar datos a este objeto, usamos la notación punto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Aprendizaje\n",
      "Profundo\n",
      "15\n"
     ]
    }
   ],
   "source": [
    "#Adjuntando datos a el objeto u1 de la clase Usuario\n",
    "\n",
    "u1.nombre=\"Aprendizaje\"\n",
    "u1.apellido=\"Profundo\"\n",
    "u2.edad =15\n",
    "\n",
    "print(u1.nombre)\n",
    "print(u1.apellido)\n",
    "print(u2.edad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'nombre' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_10308/301446466.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnombre\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'nombre' is not defined"
     ]
    }
   ],
   "source": [
    "nombre"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los datos adjuntados a un objeto se les llaman **atributos**\n",
    "\n",
    "**OJO:** nombre y apellido no son variables existentes en el ambiente de trabajo.\n",
    "\n",
    "**Consejo:** Se recomienda usar minúsculas para los nombres de los campo (Tradición Pythonica).\n",
    "\n",
    "Es común diferenciar entre atributos de clase y atributos de instancia de clase. Por lo pronto nos referimos a los atributos de instancia de clase qu refieren a la información incluida en una instancia de clase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Aprendizaje'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u1.nombre"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una bonita consecuencia, es que podemos crear muchos objetos con campos del mismo nombre sin tener que defiinir una variable diferente para cada dato adjuntado del objeto.\n",
    "\n",
    "Hagamos otro objeto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "u2=Usuario()\n",
    "u2.nombre=\"Francisco\"\n",
    "u2.apellido=\"Talavera\"\n",
    "u2.edad=34"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "34"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#edad de u2\n",
    "u2.edad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Usuario object at 0x7fe7c4092790>\n"
     ]
    }
   ],
   "source": [
    "print(u2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Usuario' object has no attribute 'edad'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_10308/456201229.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# u1 no tiene edad asginada\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mu1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0medad\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'Usuario' object has no attribute 'edad'"
     ]
    }
   ],
   "source": [
    "# u1 no tiene edad asginada\n",
    "u1.edad"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se estarán preguntando...\n",
    "\n",
    "**¿Para qué tomarnos la molestia si pudimos hacer todo con un diccionario?**\n",
    "\n",
    "La respuesta la encontraremos en características adicionales de las clases. Estas contienen:\n",
    "\n",
    "-  Métodos\n",
    "- Inicialización"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[[Volver al inicio]](#Contenido)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##   <span style=\"color:blue\">La función \\_\\_init\\_\\_()</span> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una función dentro de una clase de llama **método**.\n",
    "\n",
    "\\_\\_init\\_\\_ es el abreviado de **initialization** (inicialización).\n",
    "\n",
    "También se le conoce como el **constructor**.\n",
    "\n",
    "**Note los dos guiones bajos antes y despues de init**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thomas Anderson\n",
      "19620311\n"
     ]
    }
   ],
   "source": [
    "class Usuario:\n",
    "    def __init__(self, nombre_completo, cumple):\n",
    "        self.nombre = nombre_completo\n",
    "        self.cumple = cumple\n",
    "        \n",
    "u3 = Usuario(\"Thomas Anderson\", '19620311')\n",
    "\n",
    "print(u3.nombre)\n",
    "print(u3.cumple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Nota:** _self_ es el parámetro que referencia la instancia actual de la clase y se usa para acceder a los atributos de dicha clase. No tiene que llamarse self."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thomas Anderson\n",
      "19620311\n"
     ]
    }
   ],
   "source": [
    "class Usuario:\n",
    "    def __init__(mi_objeto, nombre_completo, cumple):\n",
    "        mi_objeto.nombre = nombre_completo\n",
    "        mi_objeto.cumple = cumple\n",
    "\n",
    "u3 = Usuario(\"Thomas Anderson\", '19620311')\n",
    "\n",
    "print(u3.nombre)\n",
    "print(u3.cumple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agreguemos otra característica más.\n",
    "\n",
    "Por ejemplo, extraer nombre y apellido:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thomas Alex Anderson\n",
      "Thomas\n",
      "Anderson\n",
      "19620311\n"
     ]
    }
   ],
   "source": [
    "class Usuario:\n",
    "    def __init__(self, nombre_completo, cumple):\n",
    "        self.nombre_c = nombre_completo\n",
    "        self.cumple = cumple\n",
    "        \n",
    "        #Extraer partes\n",
    "        piezas_nombre=nombre_completo.split(\" \")\n",
    "        self.nombre=piezas_nombre[0]\n",
    "        self.apellido=piezas_nombre[-1]\n",
    "        \n",
    "u = Usuario(\"Thomas Alex Anderson\", '19620311')\n",
    "\n",
    "print(u.nombre_c)\n",
    "print(u.nombre)\n",
    "print(u.apellido)\n",
    "print(u.cumple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thomas Anderson\n",
      "Thomas\n",
      "Anderson\n",
      "19620311\n"
     ]
    }
   ],
   "source": [
    "class Usuario:\n",
    "    def __init__(self, nombre_completo, cumple):\n",
    "        self.nombre_c = nombre_completo\n",
    "        self.cumple = cumple\n",
    "        \n",
    "        #Extraer partes\n",
    "        piezas_nombre=nombre_completo.split(\" \")\n",
    "        self.nombre=piezas_nombre[0]\n",
    "        self.apellido=piezas_nombre[-1]\n",
    "        \n",
    "Neo = Usuario(\"Thomas Anderson\", '19620311')\n",
    "\n",
    "print(Neo.nombre_c)\n",
    "print(Neo.nombre)\n",
    "print(Neo.apellido)\n",
    "print(Neo.cumple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[[Volver al inicio]](#Contenido)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##   <span style=\"color:blue\">Documentación de una clase</span> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos documentar la clase de la siguiente manera:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class Usuario in module __main__:\n",
      "\n",
      "class Usuario(builtins.object)\n",
      " |  Usuario(nombre_completo, cumple)\n",
      " |  \n",
      " |  Un usuario de nuestra plataforma. Por ahora\n",
      " |  sólo recolectamos nombre y cumpleaños.\n",
      " |  Pero pronto tendremos mucho más que eso.\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __init__(self, nombre_completo, cumple)\n",
      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
      " |  \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": [
    "class Usuario:\n",
    "    \"\"\"\n",
    "    Un usuario de nuestra plataforma. Por ahora\n",
    "    sólo recolectamos nombre y cumpleaños.\n",
    "    Pero pronto tendremos mucho más que eso.\n",
    "    \"\"\"\n",
    "    def __init__(self, nombre_completo, cumple):\n",
    "        self.nombre_c = nombre_completo\n",
    "        self.cumple = cumple\n",
    "        \n",
    "        #Extraer partes\n",
    "        piezas_nombre=nombre_completo.split(\" \")\n",
    "        self.nombre=piezas_nombre[0]\n",
    "        self.apellido=piezas_nombre[-1]\n",
    "        \n",
    "help(Usuario)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'nombre_c': 'Thomas Anderson', 'cumple': '19620311', 'nombre': 'Thomas', 'apellido': 'Anderson'}\n"
     ]
    }
   ],
   "source": [
    "print(Neo.__dict__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[[Volver al inicio]](#Contenido)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##   <span style=\"color:blue\"> Agregando métodos a una clase</span> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible crear métodos propios a una clase.\n",
    "\n",
    "Creemos por ejemplo un método que extraiga la edad de nuestro usuario."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Neo tiene 59 años\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "\n",
    "class Usuario:\n",
    "    \"\"\"Un usuario de nuestra plataforma. Por ahora\n",
    "    sólo recolectamos nombre y cumpleaños.\n",
    "    Pero pronto tendremos mucho más que eso.\"\"\"\n",
    "    def __init__(self, nombre_completo, cumple):\n",
    "        self.nombre_c = nombre_completo\n",
    "        self.cumple = cumple\n",
    "        \n",
    "        #Extraer partes\n",
    "        piezas_nombre=nombre_completo.split(\" \")\n",
    "        self.nombre=piezas_nombre[0]\n",
    "        self.apellido=piezas_nombre[-1]\n",
    "        \n",
    "    def edad(self):\n",
    "        \"\"\"Regresa la edad de nuestro usuario en años.\"\"\"\n",
    "        hoy=datetime.date.today()\n",
    "        año=int(self.cumple[0:4])\n",
    "        mes=int(self.cumple[4:6])\n",
    "        dia=int(self.cumple[6:8])\n",
    "        fecha_cumple=datetime.date(año,mes,dia)\n",
    "        edad_dias=(hoy-fecha_cumple).days\n",
    "        edad_años=edad_dias/365\n",
    "        return int(edad_años)\n",
    "    \n",
    "Neo=Usuario(\"Thomas Anderson\",\"19620311\")\n",
    "\n",
    "print(\"Neo tiene\",Neo.edad(),\"años\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Usuario object at 0x7fe7b4f83220>\n"
     ]
    }
   ],
   "source": [
    "print(Neo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(Usuario)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[[Volver al inicio]](#Contenido)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##   <span style=\"color:blue\"> Imprimiendo contenidos de una clase por defecto</span> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para establecer una forma de print por defecto en una clase, puede agregar el método reservado ```__str__```. Vamos a redefinir nuestra clase para incluirlo.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime\n",
    "\n",
    "class Usuario:\n",
    "    \"\"\"Un usuario de nuestra plataforma. Por ahora\n",
    "    sólo recolectamos nombre y cumpleaños.\n",
    "    Pero pronto tendremos mucho más que eso.\"\"\"\n",
    "    def __init__(self, nombre_completo, cumple):\n",
    "        self.nombre_c = nombre_completo\n",
    "        self.cumple = cumple\n",
    "        \n",
    "        #Extraer partes\n",
    "        piezas_nombre=nombre_completo.split(\" \")\n",
    "        self.nombre=piezas_nombre[0]\n",
    "        self.apellido=piezas_nombre[-1]\n",
    "        \n",
    "    def edad(self):\n",
    "        \"\"\"Regresa la edad de nuestro usuario en años.\"\"\"\n",
    "        hoy=datetime.date.today()\n",
    "        año=int(self.cumple[0:4])\n",
    "        mes=int(self.cumple[4:6])\n",
    "        dia=int(self.cumple[6:8])\n",
    "        fecha_cumple=datetime.date(año,mes,dia)\n",
    "        edad_dias=(hoy-fecha_cumple).days\n",
    "        edad_años=edad_dias/365\n",
    "        return int(edad_años)\n",
    "     \n",
    "    def __str__(self):\n",
    "        return self.nombre_c + '  tiene ' + str(self.edad()) + ' años'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thomas Anderson  tiene 59 años\n"
     ]
    }
   ],
   "source": [
    "Neo=Usuario(\"Thomas Anderson\",\"19620311\")\n",
    "print(Neo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##   <span style=\"color:blue\"> Ejecución de una tarea por defecto en una instancia de clase: call</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Puede usar el método reservado ```__call__``` para ejecutar uan tarea por defecto cuando se llama a un objeto. \n",
    "\n",
    "Por ejemplo supongamos que deseamos ver cuantas veces ha sido llamado un objeto.\n",
    "\n",
    "Agrandamos una vez más nuestra clase *Usuario*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime\n",
    "\n",
    "class Usuario:\n",
    "    \"\"\"Un usuario de nuestra plataforma. Por ahora\n",
    "    sólo recolectamos nombre y cumpleaños.\n",
    "    Pero pronto tendremos mucho más que eso.\"\"\"\n",
    "    def __init__(self, nombre_completo, cumple):\n",
    "        self.nombre_c = nombre_completo\n",
    "        self.cumple = cumple\n",
    "        \n",
    "        self.llamadas = 0\n",
    "        \n",
    "        #Extraer partes\n",
    "        piezas_nombre=nombre_completo.split(\" \")\n",
    "        self.nombre=piezas_nombre[0]\n",
    "        self.apellido=piezas_nombre[-1]\n",
    "        \n",
    "    def edad(self):\n",
    "        \"\"\"Regresa la edad de nuestro usuario en años.\"\"\"\n",
    "        hoy=datetime.date.today()\n",
    "        año=int(self.cumple[0:4])\n",
    "        mes=int(self.cumple[4:6])\n",
    "        dia=int(self.cumple[6:8])\n",
    "        fecha_cumple=datetime.date(año,mes,dia)\n",
    "        edad_dias=(hoy-fecha_cumple).days\n",
    "        edad_años=edad_dias/365\n",
    "        return int(edad_años)\n",
    "     \n",
    "    def __str__(self):\n",
    "        return self.nombre_c + '  tiene ' + str(self.edad()) + ' años'\n",
    "    \n",
    "    def __call__(self):\n",
    "        self.llamadas +=1\n",
    "        return(self.llamadas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thomas Anderson  tiene 59 años\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "Neo=Usuario(\"Thomas Anderson\",\"19620311\")\n",
    "print(Neo)\n",
    "print(Neo())\n",
    "print(Neo())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thomas Anderson  tiene 59 años\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "#Neo=Usuario(\"Thomas Anderson\",\"19620311\")\n",
    "print(Neo)\n",
    "print(Neo())\n",
    "print(Neo())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##   <span style=\"color:blue\"> Referencias y copia de objetos</span>"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Es importante que hagamos la diferencia entre referenciar un objeto y realmente copiarlo.\n",
    "\n",
    "Vamos a crear un segundo objeto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Agente Smith  tiene 11 años\n"
     ]
    }
   ],
   "source": [
    "Smith=Usuario(\"Agente Smith\",\"20100515\")\n",
    "print(Smith)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thomas Anderson  tiene 59 años\n"
     ]
    }
   ],
   "source": [
    "print(Neo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ahora una referencia a Neo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thomas Anderson  tiene 59 años\n",
      "Thomas Anderson  tiene 59 años\n"
     ]
    }
   ],
   "source": [
    "px = Neo\n",
    "print(px)\n",
    "print(Neo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pero ahora observe lo que pasa si modifica *px*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thomas Anderson  tiene 71 años\n",
      "Thomas Anderson  tiene 71 años\n"
     ]
    }
   ],
   "source": [
    "px.cumple ='19500319'\n",
    "print(Neo)\n",
    "print(px)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esto ocurre porque en realidad px es una referencia al objeto Neo. Si desea una copia física puede por ejemplo usar la función *copy* del módulo estándar *copy*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thomas Anderson  tiene 71 años\n",
      "Thomas Anderson  tiene 61 años\n"
     ]
    }
   ],
   "source": [
    "from copy import copy\n",
    "\n",
    "px = copy(Neo)\n",
    "Neo.cumple = \"19600311\"\n",
    "print(px)\n",
    "print(Neo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##   <span style=\"color:blue\">Eliminación de objetos: del</span> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se usa para eliminar un objeto. Por ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'px' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_10308/4051950743.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0mpx\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpx\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 'px' is not defined"
     ]
    }
   ],
   "source": [
    "del px\n",
    "print(px)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##   <span style=\"color:blue\">Atributos Intrínsicos de clases y objetos</span> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cada clase y objeto de Python tiene una conjunto de atributos intrínsicos que pueden ser llamados.\n",
    "\n",
    "Los atributos intrínsicos de clase son:\n",
    "\n",
    "+  ```__name__```: nombre de la clase\n",
    "+  ```__module__```: módulo al cual pertenece la clase\n",
    "+  ```__bases__```: clases base de ésta clase\n",
    "+  ```__dict__```: diccionario conteniendo un conjunto *clave/valor* con todos los atributos de la clase incluídos los métodos.\n",
    "\n",
    "Los atributos intrínsicos de los objetos son:\n",
    "\n",
    "+ ```__class__```: nombre de la clase del objeto \n",
    "+ ```__dict__```: diccionario conteniendo un conjunto *clave/valor* con todos los atributos\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Atributos de clase\n",
      "\n",
      "Nombre de la clase:  Usuario\n",
      "\n",
      " Módulo:  __main__\n",
      "\n",
      " Documentación:\n",
      " Un usuario de nuestra plataforma. Por ahora\n",
      "    sólo recolectamos nombre y cumpleaños.\n",
      "    Pero pronto tendremos mucho más que eso.\n",
      "\n",
      "Diccionario de la clase: \n",
      " {'__module__': '__main__', '__doc__': 'Un usuario de nuestra plataforma. Por ahora\\n    sólo recolectamos nombre y cumpleaños.\\n    Pero pronto tendremos mucho más que eso.', '__init__': <function Usuario.__init__ at 0x7fe7b4f7b670>, 'edad': <function Usuario.edad at 0x7fe7b4f7b280>, '__str__': <function Usuario.__str__ at 0x7fe7b4f7b700>, '__call__': <function Usuario.__call__ at 0x7fe7b4f7b790>, '__dict__': <attribute '__dict__' of 'Usuario' objects>, '__weakref__': <attribute '__weakref__' of 'Usuario' objects>, '__slotnames__': []}\n",
      "\n",
      "Clases Base:  (<class 'object'>,)\n",
      "\n",
      "Atributos del objeto Neo\n",
      "\n",
      "Clase:  <class '__main__.Usuario'>\n",
      "\n",
      " Diccionario:  {'nombre_c': 'Thomas Anderson', 'cumple': '19600311', 'llamadas': 4, 'nombre': 'Thomas', 'apellido': 'Anderson'}\n"
     ]
    }
   ],
   "source": [
    "print('Atributos de clase\\n')\n",
    "print('Nombre de la clase: ',Usuario.__name__)\n",
    "print('\\n Módulo: ', Usuario.__module__)\n",
    "print('\\n Documentación:\\n',Usuario.__doc__)\n",
    "print('\\nDiccionario de la clase: \\n',Usuario.__dict__)\n",
    "print('\\nClases Base: ',Usuario.__bases__)\n",
    "print('\\nAtributos del objeto Neo\\n')\n",
    "print('Clase: ',Neo.__class__)\n",
    "print('\\n Diccionario: ', Neo.__dict__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:blue\">Herencia de clases</span>  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una de las grandes ventajas de usar clases en programación es poder generar clases más especializadas a partir de una o más clases base.\n",
    "\n",
    "Esto característica permite re-utilizar código y también permite escribir un código más limpio y legible.\n",
    "\n",
    "Supongamos que a la clase Usuario le queremos dar un tipo de publicidad en específico.\n",
    "\n",
    "Creemos entonces una clase que hable sobre los gustos del usuario, pero referenciando a la clase ya creada."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Lector(Usuario):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class Lector in module __main__:\n",
      "\n",
      "class Lector(Usuario)\n",
      " |  Lector(nombre_completo, cumple)\n",
      " |  \n",
      " |  Un usuario de nuestra plataforma. Por ahora\n",
      " |  sólo recolectamos nombre y cumpleaños.\n",
      " |  Pero pronto tendremos mucho más que eso.\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      Lector\n",
      " |      Usuario\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods inherited from Usuario:\n",
      " |  \n",
      " |  __call__(self)\n",
      " |      Call self as a function.\n",
      " |  \n",
      " |  __init__(self, nombre_completo, cumple)\n",
      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
      " |  \n",
      " |  __str__(self)\n",
      " |      Return str(self).\n",
      " |  \n",
      " |  edad(self)\n",
      " |      Regresa la edad de nuestro usuario en años.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from Usuario:\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",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from Usuario:\n",
      " |  \n",
      " |  __slotnames__ = []\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(Lector)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Daniel Montenegro\n",
      "Daniel\n",
      "31\n",
      "Daniel Montenegro  tiene 31 años\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "l=Lector(\"Daniel Montenegro\",\"19901026\")\n",
    "print(l.nombre_c)\n",
    "print(l.nombre)\n",
    "print(l.edad())\n",
    "print(l)\n",
    "print(l())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Al intentar colocar un constructor sobre la clase heredada, se perderá la función constructora heredada de Usuario:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Lector(Usuario):\n",
    "    def __init__(self, nombre_completo, cumple):\n",
    "        self.nombre_c = nombre_completo\n",
    "        self.cumple = cumple\n",
    "        # Agregar cositas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Daniel Montenegro\n",
      "31\n"
     ]
    }
   ],
   "source": [
    "l=Lector(\"Daniel Montenegro\",\"19901026\")\n",
    "print(l.nombre_c)\n",
    "print(l.edad())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[[Volver al inicio]](#Contenido)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:blue\"> Referencia a la clase base: super() </span> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dado que al heredear una clase de otra, estamos pensando en conservar la funcionalidad de la clase base, es importante poder usar el constructor de la clase base junto con el constructor extendido en la clase heredada. Para hacer esta característica posible se utiliza  `super()` como se muestra a continuación. *super()* es un enlace o referecia a la clase base. Entonces, si deseamos usar el constructor de la clase base se puede escribir \n",
    "\n",
    "super().\\_\\_init\\_\\_(...)\n",
    "\n",
    "\n",
    "Veamos el uso de *super()* en nuestra clase Lector, la cual heredamos de la clase Usuario."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Lector(Usuario):\n",
    "    def __init__(self, nombre_completo, cumple, gustos):\n",
    "        super().__init__(nombre_completo, cumple)\n",
    "        self.gustos=gustos\n",
    "        # Agregar otras cosas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Daniel Montenegro\n",
      "31\n",
      "Jack Kerouac\n",
      "Daniel Montenegro  tiene 31 años\n"
     ]
    }
   ],
   "source": [
    "l=Lector(\"Daniel Montenegro\",\"19901026\",\"Jack Kerouac\")\n",
    "print(l.nombre_c)\n",
    "print(l.edad())\n",
    "print(l.gustos)\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finalmente, agreguemos un método a la clase Lector para extender su funcionalidad:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Lector(Usuario):\n",
    "    def __init__(self, nombre_completo, cumple, gustos):\n",
    "        super().__init__(nombre_completo, cumple)\n",
    "        self.gustos=gustos\n",
    "        año=int(self.cumple[0:4])\n",
    "        mes=int(self.cumple[4:6])\n",
    "        dia=int(self.cumple[6:8])\n",
    "        self.fecha_cumple=datetime.date(año,mes,dia)\n",
    "        \n",
    "    def info(self):\n",
    "        print(\" El Usuario\",self.nombre_c,\", nacido en\",self.fecha_cumple, \", tiene\",self.edad(),\"años\", \"y le gustan las obras de\",self.gustos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " El Usuario Daniel Montenegro , nacido en 1990-10-26 , tiene 31 años y le gustan las obras de Jack Kerouac\n"
     ]
    }
   ],
   "source": [
    "l=Lector(\"Daniel Montenegro\",\"19901026\",\"Jack Kerouac\")\n",
    "l.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[[Volver al inicio]](#Contenido)"
   ]
  }
 ],
 "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.9.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}