MOD6.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Fundamentos de POO**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El enfoque orientado a objetos sugiere una forma de pensar completamente diferente. Los datos y el código están encapsulados juntos en el mismo mundo, divididos en clases.\n",
    "\n",
    "Cada clase es como una receta que se puede usar cuando quieres crear un objeto útil. Puedes producir tantos objetos como necesites para resolver tu problema.\n",
    "\n",
    "Cada objeto tiene un conjunto de rasgos (se denominan propiedades o atributos; usaremos ambas palabras como sinónimos) y es capaz de realizar un conjunto de actividades (que se denominan métodos). \n",
    "\n",
    "Las recetas pueden modificarse si son inadecuadas para fines específicos y, en efecto, pueden crearse nuevas clases. Estas nuevas clases heredan propiedades y métodos de los originales, y generalmente agregan algunos nuevos, creando nuevas herramientas más específicas.\n",
    "\n",
    "Los objetos interactúan entre sí, intercambian datos o activan sus métodos. Una clase construida adecuadamente (y, por lo tanto, sus objetos) puede proteger los datos sensibles y ocultarlos de modificaciones no autorizadas.\n",
    "\n",
    "No existe un límite claro entre los datos y el código: viven como uno solo dentro de los objetos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Jerarquías de clase***\n",
    "\n",
    "La clase es como una categoría, como resultado de similitudes definidas con precisión.\n",
    "\n",
    "Intentaremos señalar algunas clases que son buenos ejemplos de este concepto.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src =\"Clases.PNG\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si, la clase vehículos es muy amplia. Tenemos que definir clases especializadas. Las clases especializadas son las subclases. La clase vehículos será una superclase para todas ellas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nota: la jerarquía crece de arriba hacia abajo, como raíces de árboles, no ramas. La clase más general y más amplia siempre está en la parte superior (la superclase) mientras que sus descendientes se encuentran abajo (las subclases). La dirección de las flechas siempre apunta a la superclase. La clase de nivel superior es una excepción: no tiene su propia superclase."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se pueden señalar muchas subclases potenciales para la superclase Vehículos. Hay muchas clasificaciones posibles. En este caso, se eligieron subclases basadas en el medio ambiente. Luego, cada subclase podría dividirse aún más. Por ejemplo, los vehículos terrestres pueden dividirse según el método con el que impactan el suelo (vease la figura adjunta). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otro ejemplo es la jerarquía del reino taxonómico de los animales."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"Clases2.PNG\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***¿Qué es un objeto?***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una clase (entre otras definiciones) es un conjunto de objetos. Un objeto es un ser perteneciente a una clase.\n",
    "\n",
    "Un objeto es una encarnación de los requisitos, rasgos y cualidades asignados a una clase específica. \n",
    "\n",
    "Las clases forman una jerarquía. Esto puede significar que un objeto que pertenece a una clase específica pertenece a todas las superclases al mismo tiempo. También puede significar que cualquier objeto perteneciente a una superclase puede no pertenecer a ninguna de sus subclases."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Herencia***\n",
    "\n",
    "Definamos uno de los conceptos fundamentales de la programación de objetos, llamado herencia. Cualquier objeto vinculado a un nivel específico de una jerarquía de clases hereda todos los rasgos (así como los requisitos y cualidades) definidos dentro de cualquiera de las superclases."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***¿Qué contiene un objeto?***\n",
    "\n",
    "La programación orientada a objetos supone que cada objeto existente puede estar equipado con tres grupos de atributos:\n",
    "\n",
    "- Un objeto tiene un nombre que lo identifica de forma exclusiva dentro de su namespace (aunque también puede haber algunos objetos anónimos).\n",
    "- Un objeto tiene un conjunto de propiedades individuales que lo hacen original, único o sobresaliente (aunque es posible que algunos objetos no tengan propiedades).\n",
    "- Un objeto tiene un conjunto de habilidades para realizar actividades específicas, capaz de cambiar el objeto en sí, o algunos de los otros objetos.\n",
    "\n",
    "Hay una pista (aunque esto no siempre funciona) que te puede ayudar a identificar cualquiera de las tres esferas anteriores. Cada vez que se describe un objeto y se usa:\n",
    "\n",
    "* Un sustantivo: probablemente se este definiendo el nombre del objeto.\n",
    "* Un adjetivo: probablemente se este definiendo una propiedad del objeto.\n",
    "* Un verbo: probablemente se este definiendo una actividad del objeto.\n",
    "\n",
    "Por ejemplo, Max es un gato grande que duerme todo el día.\n",
    "\n",
    "* Nombre del objeto = Max\n",
    "* Clase de inicio = Gato\n",
    "* Propiedad = Tamaño (grande)\n",
    "* Actividad = Dormir (todo el día)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"ContenidoObj..PNG\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Creando nuestra primera clase y nuestro primer objeto !***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es hora de definir la clase más simple y crear un objeto. Echa un vistazo al siguiente ejemplo:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ClaseSimple:\n",
    "    pass #llena la clase con nada. No contiene ningún método ni propiedades.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La definición comienza con la palabra clave reservada class. La palabra clave reservada es seguida por un identificador que nombrará la clase (nota: no lo confundas con el nombre del objeto: estas son dos cosas diferentes).\n",
    "\n",
    "A continuación, se agregan dos puntos:), como clases, como funciones, forman su propio bloque anidado. El contenido dentro del bloque define todas las propiedades y actividades de la clase."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nota: La clase que se define no tiene nada que ver con el objeto: la existencia de una clase no significa que ninguno de los objetos compatibles se creará automáticamente. La clase en sí misma no puede crear un objeto: debes crearlo tu mismo y Python te permite hacerlo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora imagina que deseas crear un objeto (exactamente uno) de la clase ClaseSimple. Para hacer esto, debes asignar una variable para almacenar el objeto recién creado de esa clase y crear un objeto al mismo tiempo.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "miPrimerObjeto = ClaseSimple()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dos cosas:\n",
    "- El nombre de la clase intenta fingir que es una función, ¿puedes ver esto? Lo discutiremos pronto.\n",
    "- El objeto recién creado está equipado con todo lo que trae la clase; Como esta clase está completamente vacía, el objeto también está vacío.\n",
    "\n",
    "El acto de crear un objeto de la clase seleccionada también se llama instanciación (ya que el objeto se convierte en una instancia de la clase)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Implementación de una pila en Python***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una pila es un objeto con dos operaciones elementales, denominadas convencionalmente push (cuando un nuevo elemento se coloca en la parte superior) y pop (cuando un elemento existente se retira de la parte superior)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"Pila.PNG\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* ***Enfoque procedimental***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "pila = []\n",
    "\n",
    "def push(val):\n",
    "    pila.append(val)\n",
    "\n",
    "\n",
    "def pop():\n",
    "    val = pila[-1]\n",
    "    del pila[-1]\n",
    "    return val\n",
    "\n",
    "push(3)\n",
    "push(2)\n",
    "push(1)\n",
    "\n",
    "print(pop())\n",
    "print(pop())\n",
    "print(pop())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* ***Enfoque orientado a objetos***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comencemos desde el principio: así es como comienza la pila de orientada a objetos:\n"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "class Pila:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora, esperamos dos cosas de la clase:\n",
    "\n",
    "- Queremos que la clase tenga una propiedad como el almacenamiento de la pila - tenemos que \"instalar\" una lista dentro de cada objeto de la clase (nota: cada objeto debe tener su propia lista; la lista no debe compartirse entre diferentes pilas).\n",
    "- Despues, queremos que la lista esté oculta de la vista de los usuarios de la clase para que no la modifiquen por error. \n",
    "¿Cómo se hace esto?\n",
    "\n",
    "A diferencia de otros lenguajes de programación, Python no tiene medios para permitirte declarar una propiedad como esa. Hay una manera simple de hacerlo - tienes que equipar a la clase con una función específica: tiene que ser nombrada de forma estricta e invocada implícitamente cuando se crea el nuevo objeto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "¡Hola!\n"
     ]
    }
   ],
   "source": [
    "class Pila:    # define la clase Pila\n",
    "    def __init__         (self):    # define la función del constructor (su propósito general es construir un nuevo objeto)\n",
    "        #constructor     #parámetro se usa para representar el objeto recién creado ----> ambos obligatorios\n",
    "        print(\"¡Hola!\")\n",
    "\n",
    "objetoPila = Pila()    # instanciando el objeto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cualquier cambio que realices dentro del constructor que modifique el estado del parámetro self se verá reflejado en el objeto recien creado.\n",
    "\n",
    "Esto significa que puedes agregar cualquier propiedad al objeto y la propiedad permanecerá allí hasta que el objeto termine su vida o la propiedad se elimine explícitamente.\n",
    "\n",
    "agreguemos solo una propiedad al nuevo objeto - una lista para la pila. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "class Pila:\n",
    "    def __init__(self):\n",
    "        self.listaPila = []  \n",
    "objetoPila = Pila()\n",
    "print(len(objetoPila.listaPila)) #acceder a la propiedad, que no es igual a invocar un método (se utiliza paréntisis)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nota: Si estableces el valor de una propiedad por primera vez (como en el constructor), lo estás creando; a partir de ese momento, el objeto tiene la propiedad y está listo para usar su valor.\n",
    "\n",
    "Ahora, nosotros queremos que listaPila este escondida del mundo exterior. ¿Es eso posible?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Pila' object has no attribute '__listaPila'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32mc:\\Users\\USUARIO\\Documents\\TI\\Python\\Cisco\\MOD6.ipynb Celda 36\u001b[0m in \u001b[0;36m<cell line: 6>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/USUARIO/Documents/TI/Python/Cisco/MOD6.ipynb#ch0000035?line=2'>3</a>\u001b[0m         \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mlistaPila \u001b[39m=\u001b[39m []\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/USUARIO/Documents/TI/Python/Cisco/MOD6.ipynb#ch0000035?line=4'>5</a>\u001b[0m objetoPila \u001b[39m=\u001b[39m Pila()\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/USUARIO/Documents/TI/Python/Cisco/MOD6.ipynb#ch0000035?line=5'>6</a>\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39mlen\u001b[39m(objetoPila\u001b[39m.\u001b[39;49m__listaPila))\n",
      "\u001b[1;31mAttributeError\u001b[0m: 'Pila' object has no attribute '__listaPila'"
     ]
    }
   ],
   "source": [
    "class Pila:\n",
    "    def __init__(self):\n",
    "        self.listaPila = []\n",
    "\n",
    "objetoPila = Pila()\n",
    "print(len(objetoPila.__listaPila))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El cambio invalida el programa ¿Por qué? Cuando cualquier componente de la clase tiene un nombre que comienza con dos guiones bajos (__), se vuelve privado - esto significa que solo se puede acceder desde la clase. No puedes verlo desde el mundo exterior. Así es como Python implementa el concepto de encapsulación.\n",
    "\n",
    "Ahora es el momento de que las dos funciones (métodos) implementen las operaciones push y pop. Python supone que una función de este tipo debería estar inmersa dentro del cuerpo de la clase - como el constructor. Ambos deben ser accesibles para el usuario de la clase (en contraste con la lista previamente construida, que está oculta para los usuarios de la clase ordinaria), es decir, ambos deben ser componentes públicos de la clase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "class Pila:\n",
    "    def __init__(self):\n",
    "        self.__listaPila = []  # Componente privado\n",
    "\n",
    "    def push(self, val):\n",
    "        self.__listaPila.append(val) #  invocar un método desde la variable __listaPila.\n",
    "\n",
    "    def pop(self):\n",
    "        val = self.__listaPila[-1]\n",
    "        del self.__listaPila[-1]\n",
    "        return val\n",
    "\n",
    "\n",
    "objetoPila = Pila()\n",
    "\n",
    "objetoPila.push(3)  # Componente público: \n",
    "objetoPila.push(2)\n",
    "objetoPila.push(1)\n",
    "\n",
    "print(objetoPila.pop()) \n",
    "print(objetoPila.pop())\n",
    "print(objetoPila.pop())\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nota: un componente público no puede comenzar su nombre con dos (o más) guiones bajos. Hay un requisito más - el nombre no debe tener más de un guión bajo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Por qué ambas funciones tienen un parámetro llamado self en la primera posición de la lista de parámetros? ¿Es necesario? Si, lo es. Todos los métodos deben tener este parámetro. Desempeña el mismo papel que el primer parámetro constructor. Permite que el método acceda a entidades (propiedades y actividades / métodos) del objeto.\n",
    "\n",
    "Cada vez que Python invoca un método, envía implícitamente el objeto actual como el primer argumento. Esto significa que el método está obligado a tener al menos un parámetro, que Python mismo utiliza - no tienes ninguna influencia sobre el."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora puedes hacer que más de una pila se comporte de la misma manera. Cada pila tendrá su propia copia de datos privados, pero utilizará el mismo conjunto de métodos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    },
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32mc:\\Users\\USUARIO\\Documents\\TI\\Python\\Cisco\\MOD6.ipynb Celda 42\u001b[0m in \u001b[0;36m<cell line: 23>\u001b[1;34m()\u001b[0m\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/Users/USUARIO/Documents/TI/Python/Cisco/MOD6.ipynb#ch0000041?line=19'>20</a>\u001b[0m objetoPila2\u001b[39m.\u001b[39mpush(objetoPila1\u001b[39m.\u001b[39mpop())\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/Users/USUARIO/Documents/TI/Python/Cisco/MOD6.ipynb#ch0000041?line=21'>22</a>\u001b[0m \u001b[39mprint\u001b[39m(objetoPila2\u001b[39m.\u001b[39mpop())\n\u001b[1;32m---> <a href='vscode-notebook-cell:/c%3A/Users/USUARIO/Documents/TI/Python/Cisco/MOD6.ipynb#ch0000041?line=22'>23</a>\u001b[0m \u001b[39mprint\u001b[39m(objetoPila1\u001b[39m.\u001b[39;49mpop())\n",
      "\u001b[1;32mc:\\Users\\USUARIO\\Documents\\TI\\Python\\Cisco\\MOD6.ipynb Celda 42\u001b[0m in \u001b[0;36mPila.pop\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/USUARIO/Documents/TI/Python/Cisco/MOD6.ipynb#ch0000041?line=7'>8</a>\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mpop\u001b[39m(\u001b[39mself\u001b[39m):\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/USUARIO/Documents/TI/Python/Cisco/MOD6.ipynb#ch0000041?line=8'>9</a>\u001b[0m     val \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m__listaPila[\u001b[39m-\u001b[39;49m\u001b[39m1\u001b[39;49m]\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/Users/USUARIO/Documents/TI/Python/Cisco/MOD6.ipynb#ch0000041?line=9'>10</a>\u001b[0m     \u001b[39mdel\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m__listaPila[\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m]\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/Users/USUARIO/Documents/TI/Python/Cisco/MOD6.ipynb#ch0000041?line=10'>11</a>\u001b[0m     \u001b[39mreturn\u001b[39;00m val\n",
      "\u001b[1;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "class Pila:\n",
    "    def __init__(self):\n",
    "        self.__listaPila = []\n",
    "\n",
    "    def push(self, val):\n",
    "        self.__listaPila.append(val)\n",
    "\n",
    "    def pop(self):\n",
    "        val = self.__listaPila[-1]\n",
    "        del self.__listaPila[-1]\n",
    "        return val\n",
    "\n",
    "\n",
    "objetoPila1 = Pila()\n",
    "objetoPila2 = Pila()\n",
    "\n",
    "# dos pilas creadas a partir de la misma clase base. Trabajan independientemente.\n",
    "\n",
    "objetoPila1.push(3)\n",
    "objetoPila2.push(objetoPila1.pop())\n",
    "\n",
    "print(objetoPila2.pop())\n",
    "print(objetoPila1.pop())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    },
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32mc:\\Users\\USUARIO\\Documents\\TI\\Python\\Cisco\\MOD6.ipynb Celda 43\u001b[0m in \u001b[0;36m<cell line: 22>\u001b[1;34m()\u001b[0m\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/Users/USUARIO/Documents/TI/Python/Cisco/MOD6.ipynb#ch0000042?line=18'>19</a>\u001b[0m graciosaPila\u001b[39m.\u001b[39mpush(otraPila\u001b[39m.\u001b[39mpop() \u001b[39m-\u001b[39m \u001b[39m2\u001b[39m)\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/Users/USUARIO/Documents/TI/Python/Cisco/MOD6.ipynb#ch0000042?line=20'>21</a>\u001b[0m \u001b[39mprint\u001b[39m(graciosaPila\u001b[39m.\u001b[39mpop())\n\u001b[1;32m---> <a href='vscode-notebook-cell:/c%3A/Users/USUARIO/Documents/TI/Python/Cisco/MOD6.ipynb#ch0000042?line=21'>22</a>\u001b[0m \u001b[39mprint\u001b[39m(otraPila\u001b[39m.\u001b[39;49mpop())\n",
      "\u001b[1;32mc:\\Users\\USUARIO\\Documents\\TI\\Python\\Cisco\\MOD6.ipynb Celda 43\u001b[0m in \u001b[0;36mPila.pop\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/USUARIO/Documents/TI/Python/Cisco/MOD6.ipynb#ch0000042?line=7'>8</a>\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mpop\u001b[39m(\u001b[39mself\u001b[39m):\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/USUARIO/Documents/TI/Python/Cisco/MOD6.ipynb#ch0000042?line=8'>9</a>\u001b[0m     val \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m__listaPila[\u001b[39m-\u001b[39;49m\u001b[39m1\u001b[39;49m]\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/Users/USUARIO/Documents/TI/Python/Cisco/MOD6.ipynb#ch0000042?line=9'>10</a>\u001b[0m     \u001b[39mdel\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m__listaPila[\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m]\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/Users/USUARIO/Documents/TI/Python/Cisco/MOD6.ipynb#ch0000042?line=10'>11</a>\u001b[0m     \u001b[39mreturn\u001b[39;00m val\n",
      "\u001b[1;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "class Pila:\n",
    "    def __init__(self):\n",
    "        self.__listaPila = []\n",
    "\n",
    "    def push(self, val):\n",
    "        self.__listaPila.append(val)\n",
    "\n",
    "    def pop(self):\n",
    "        val = self.__listaPila[-1]\n",
    "        del self.__listaPila[-1]\n",
    "        return val \n",
    "\n",
    "pequeñaPila = Pila()\n",
    "otraPila = Pila()\n",
    "graciosaPila = Pila()\n",
    "\n",
    "pequeñaPila.push(1)\n",
    "otraPila.push(pequeñaPila.pop() + 1)\n",
    "graciosaPila.push(otraPila.pop() - 2)\n",
    "\n",
    "print(graciosaPila.pop())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora vamos un poco más lejos. Vamos a agregar una nueva clase para manejar pilas.\n",
    "\n",
    "La nueva clase debería poder evaluar la suma de todos los elementos almacenados actualmente en la pila.\n",
    "\n",
    "No queremos modificar la pila previamente definida. Ya es lo suficientemente buena en sus aplicaciones, y no queremos que cambie de ninguna manera. Queremos una nueva pila con nuevas capacidades. En otras palabras, queremos construir una subclase de la ya existente clase Pila.\n",
    "\n",
    "El primer paso es fácil: solo define una nueva subclase que apunte a la clase que se usará como superclase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SumarPila(Pila):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La clase aún no define ningún componente nuevo, pero eso no significa que esté vacía. Obtiene (hereda) todos los componentes definidos por su superclase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Pila:\n",
    "    def __init__(self):\n",
    "        self.__listaPila = []\n",
    "\n",
    "    def push(self, val):\n",
    "        self.__listaPila.append(val)\n",
    "\n",
    "    def pop(self):\n",
    "        val = self.__listaPila[-1]\n",
    "        del self.__listaPila[-1]\n",
    "        return val  \n",
    "\n",
    "class SumarPila(Pila):\n",
    "    def __init__(self):\n",
    "        Pila.__init__(self)\n",
    "        self.__sum = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La segunda línea del cuerpo del constructor crea una propiedad llamada __sum - almacenará el total de todos los valores de la pila.\n",
    "\n",
    "Pero la línea anterior se ve diferente. ¿Qué hace? ¿Es realmente necesaria? Sí lo es.\n",
    "\n",
    "Al contrario de muchos otros lenguajes, Python te obliga a invocar explícitamente el constructor de una superclase. Omitir este punto tendrá efectos nocivos: el objeto se verá privado de la lista __listaPila. Tal pila no funcionará correctamente.\n",
    "\n",
    "Ten en cuenta la sintaxis:\n",
    "\n",
    "* Se especifica el nombre de la superclase (esta es la clase cuyo constructor se desea ejecutar).\n",
    "* Se pone un punto (.) después del nombre.\n",
    "* Se especifica el nombre del constructor.\n",
    "* Se debe señalar al objeto (la instancia de la clase) que debe ser inicializado por el constructor; es por eso que se debe especificar el argumento y utilizar la variable self aquí; recuerda: invocar cualquier método (incluidos los constructores) desde fuera de la clase nunca requiere colocar el argumento self en la lista de argumentos - invocar un método desde dentro de la clase exige el uso explícito del argumento self, y tiene que ser el primero en la lista.\n",
    "\n",
    "Nota: generalmente es una práctica recomendada invocar al constructor de la superclase antes de cualquier otra inicialización que desees realizar dentro de la subclase. Esta es la regla que hemos seguido en el código.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tengamos en cuenta los siguientes requerimientos para la nueva pila:\n",
    "\n",
    "- Queremos que el método push no solo inserte el valor en la pila, sino que también sume el valor a la variable sum.\n",
    "- Queremos que la función pop no solo extraiga el valor de la pila, sino que también reste el valor de la variable sum."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lo anterior implica que debemos agregar dos nuevos métodos a la subclase ¿Realmente estamos agregándolos? Ya tenemos estos métodos en la superclase. ¿Podemos hacer algo así?\n",
    "\n",
    "Si podemos. Significa que vamos a cambiar la funcionalidad de los métodos, no sus nombres. Podemos decir con mayor precisión que la interfaz (la forma en que se manejan los objetos) de la clase permanece igual al cambiar la implementación al mismo tiempo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comencemos por ejemplo con la implementación de la función push. Esto es lo que esperamos de la función y en el siguiente orden:\n",
    "\n",
    "- Agregar el valor a la variable __sum.\n",
    "- Agregar el valor a la pila.\n",
    "\n",
    "Nota: la segunda actividad ya se implementó dentro de la superclase, por lo que podemos usarla. Además, tenemos que usarla, ya que no hay otra forma de acceder a la variable __listaPila. Para ello es necesario invocar la implementación anterior (en la superclase) del método push, dentro del método push de la clase. \n",
    "\n",
    "Así es como se mira el método push y pop dentro de la subclase:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import Y\n",
    "\n",
    "\n",
    "class Pila:\n",
    "    def __init__(self):\n",
    "        self.__listaPila = []\n",
    "\n",
    "    def push(self, val):\n",
    "        self.__listaPila.append(val)\n",
    "\n",
    "    def pop(self):\n",
    "        val = self.__listaPila[-1]\n",
    "        del self.__listaPila[-1]\n",
    "        return val  \n",
    "\n",
    "class SumarPila(Pila):\n",
    "    def __init__(self):\n",
    "        Pila.__init__(self)\n",
    "        self.__sum = 0\n",
    "        \n",
    "    def push(self, val):\n",
    "      self.__sum += val\n",
    "      Pila.push(self, val) #invocar implementación anterior del método push\n",
    "                #especificar el objeto de destino (self) y pasarlo como primer argumento \n",
    "                #No se agrega implícitamente a la invocación en este contexto).\n",
    "    \n",
    "    def pop(self):\n",
    "      val = Pila.pop(self) #invocar implementación anterior del método pop, de tal forma \n",
    "                           #que se pueda obtener el número que se encuentra en la parte superior de la pila y\n",
    "                           #asignarselo a la variable val. \n",
    "      self.__sum -= val\n",
    "      return val"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se dice que los método push y pop han sido anulados - los mismos nombres que en la superclase ahora representan una funcionalidad diferente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hasta ahora, hemos definido la variable __sum, pero no hemos proporcionado un método para obtener su valor. Parece estar escondido. ¿Cómo podemos mostrarlo y que al mismo tiempo se proteja de modificaciones?\n",
    "\n",
    "Tenemos que definir un nuevo método. Lo nombraremos getSuma. Su única tarea será devolver el valor de __sum."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "4\n",
      "3\n",
      "2\n",
      "1\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "class Pila:\n",
    "    def __init__(self):\n",
    "        self.__listaPila = []\n",
    "\n",
    "    def push(self, val):\n",
    "        self.__listaPila.append(val)\n",
    "\n",
    "    def pop(self):\n",
    "        val = self.__listaPila[-1]\n",
    "        del self.__listaPila[-1]\n",
    "        return val  \n",
    "\n",
    "class SumarPila(Pila):\n",
    "    def __init__(self):\n",
    "        Pila.__init__(self)\n",
    "        self.__sum = 0\n",
    "        \n",
    "    def push(self, val):\n",
    "      self.__sum += val\n",
    "      Pila.push(self, val) \n",
    "    \n",
    "    def pop(self):\n",
    "      val = Pila.pop(self)\n",
    "      self.__sum -= val\n",
    "      return val\n",
    "  \n",
    "    def getSuma(self):   #devolver el valor de __sum.\n",
    "        return self.__sum\n",
    "\n",
    "\n",
    "#agregamos cinco valores subsiguientes en la pila, imprimimos su suma y los sacamos todos de la pila.\n",
    "objetoPila = SumarPila()\n",
    "\n",
    "for i in range(5):\n",
    "    objetoPila.push(i)\n",
    "    \n",
    "print(objetoPila.getSuma())\n",
    "\n",
    "for i in range(5):\n",
    "    print(objetoPila.pop())\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Variables de instancia***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En general, una clase puede equiparse con dos tipos diferentes de datos para formar las propiedades de una clase. El primer tipo de propiedad existe solo cuando se crea explícitamente y se agrega a un objeto. Esto se puede hacer durante la inicialización del objeto, realizada por el constructor. Además, se puede hacer en cualquier momento de la vida del objeto. Si, también se pueden eliminar en cualquier momento. \n",
    "\n",
    "Cada objeto lleva su propio conjunto de propiedades - no interfieren entre sí de ninguna manera. Tales variables (propiedades) se llaman variables de instancia. La palabra instancia sugiere que están estrechamente conectadas a los objetos (que son instancias de clase), no a las clases mismas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'primera': 1}\n",
      "{'primera': 1, 'segunda': 3}\n",
      "{'primera': 1, 'tercera': 5}\n"
     ]
    }
   ],
   "source": [
    "class ClaseEjemplo:\n",
    "    def __init__(self, val = 1):\n",
    "        self.primera = val\n",
    "\n",
    "    def setSegunda(self, val):\n",
    "        self.segunda = val\n",
    "\n",
    "\n",
    "objetoEjemplo1 = ClaseEjemplo()\n",
    "objetoEjemplo2 = ClaseEjemplo()\n",
    "objetoEjemplo2.setSegunda(3)\n",
    "\n",
    "objetoEjemplo3 = ClaseEjemplo()\n",
    "objetoEjemplo3.tercera = 5\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "print(objetoEjemplo1.__dict__)\n",
    "print(objetoEjemplo2.__dict__)\n",
    "print(objetoEjemplo3.__dict__)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nota: Los objetos de Python, cuando se crean, están dotados de un pequeño conjunto de propiedades y métodos predefinidos. Cada objeto los tiene, los quieras o no. Uno de ellos es una variable llamada __ dict __ (es un diccionario).\n",
    "\n",
    "Nota 2: el modificar una variable de instancia de cualquier objeto no tiene impacto en todos los objetos restantes. Las variables de instancia están perfectamente aisladas unas de otras.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'_ClaseEjemplo__primera': 1}\n",
      "{'_ClaseEjemplo__primera': 2, '_ClaseEjemplo__segunda': 3}\n",
      "{'_ClaseEjemplo__primera': 4, '__tercera': 5}\n"
     ]
    }
   ],
   "source": [
    "class ClaseEjemplo:\n",
    "    # \"métodos\" de los objetos\n",
    "    def __init__(self, val = 1):\n",
    "        self.__primera = val #variable de instancia privada\n",
    "\n",
    "    def setSegunda(self, val):\n",
    "        self.__segunda = val #variable de instancia privada\n",
    "\n",
    "\n",
    "objetoEjemplo1 = ClaseEjemplo()\n",
    "objetoEjemplo2 = ClaseEjemplo(2)\n",
    "\n",
    "objetoEjemplo2.setSegunda(3)\n",
    "\n",
    "objetoEjemplo3 = ClaseEjemplo(4)\n",
    "objetoEjemplo3.__tercera = 5 #variable de instancia privada\n",
    "\n",
    "\n",
    "print(objetoEjemplo1.__dict__)\n",
    "print(objetoEjemplo2.__dict__)\n",
    "print(objetoEjemplo3.__dict__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Qué ha ocurrido acá? Cuando Python ve que deseas agregar una variable de instancia a un objeto y lo vas a hacer dentro de cualquiera de los métodos del objeto, maneja la operación de la siguiente manera:\n",
    "\n",
    "- Coloca un nombre de clase antes de su nombre.\n",
    "- Coloca un guión bajo adicional al principio.\n",
    "\n",
    "Es por ello que __primera se convierte en _ClaseEjemplo__primera. El nombre ahora es completamente accesible desde fuera de la clase. Puedes ejecutar un código como este:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(objetoEjemplo1._ClaseEjemplo__primera)\n",
    "                    #agregar var. de instancia"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como puedes ver, hacer que una propiedad sea privada es limitado. No funcionará si agregas una variable de instancia fuera del código de clase. En este caso, se comportará como cualquier otra propiedad ordinaria.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***variables de clase***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una variable de clase es una propiedad que existe en una sola copia y se almacena fuera de cualquier objeto.\n",
    "\n",
    "Nota: no existe una variable de instancia si no hay ningún objeto en la clase; existe una variable de clase en una copia, incluso si no hay objetos en la clase.\n",
    "\n",
    "Las variables de clase se crean de manera diferente. El ejemplo te dirá más:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'_ClaseEjemplo__primera': 1} 3\n",
      "{'_ClaseEjemplo__primera': 2} 3\n",
      "{'_ClaseEjemplo__primera': 4} 3\n"
     ]
    }
   ],
   "source": [
    "class ClaseEjemplo:\n",
    "    contador = 0 #variable de clase: esta dentro de la clase pero fuera de cualquiera de sus métodos\n",
    "    def __init__(self, val = 1):\n",
    "        self.__primera = val\n",
    "        ClaseEjemplo.contador += 1 #acceder a la variable de clase: cuenta todos los objetos creados (3).\n",
    "\n",
    "objetoEjemplo1 = ClaseEjemplo()\n",
    "objetoEjemplo2 = ClaseEjemplo(2)\n",
    "objetoEjemplo3 = ClaseEjemplo(4)\n",
    "\n",
    "print(objetoEjemplo1.__dict__, objetoEjemplo1.contador)\n",
    "print(objetoEjemplo2.__dict__, objetoEjemplo2.contador)\n",
    "print(objetoEjemplo3.__dict__, objetoEjemplo3.contador)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dos conclusiones importantes provienen del ejemplo:\n",
    "\n",
    "- Una variable de clase siempre presenta el mismo valor en todas las instancias de clase (objetos).\n",
    "- Las variables de clase no se muestran en el diccionario de un objeto ___ dict ___ (esto es natural ya que las variables de clase no son partes de un objeto), pero siempre puedes intentar buscar en la variable del mismo nombre, pero a nivel de clase, te mostraremos esto muy pronto.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'_ClaseEjemplo__primera': 1} 3\n",
      "{'_ClaseEjemplo__primera': 2} 3\n",
      "{'_ClaseEjemplo__primera': 4} 3\n"
     ]
    }
   ],
   "source": [
    "class ClaseEjemplo:\n",
    "    __contador = 0\n",
    "    def __init__(self, val = 1):\n",
    "        self.__primera = val\n",
    "        ClaseEjemplo.__contador += 1\n",
    "\n",
    "objetoEjemplo1 = ClaseEjemplo()\n",
    "objetoEjemplo2 = ClaseEjemplo(2)\n",
    "objetoEjemplo3 = ClaseEjemplo(4)\n",
    "    \n",
    "print(objetoEjemplo1.__dict__, objetoEjemplo1._ClaseEjemplo__contador)\n",
    "print(objetoEjemplo2.__dict__, objetoEjemplo2._ClaseEjemplo__contador)\n",
    "print(objetoEjemplo3.__dict__, objetoEjemplo3._ClaseEjemplo__contador)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hemos dicho antes que las variables de clase existen incluso cuando no se creó ninguna instancia de clase (objeto).\n",
    "\n",
    "Ahora aprovecharemos la oportunidad para mostrarte la diferencia entre estas dos variables __ dict __, la de la clase y la del objeto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'__module__': '__main__', 'varia': 1, '__init__': <function ClaseEjemplo.__init__ at 0x00000154EC11F010>, '__dict__': <attribute '__dict__' of 'ClaseEjemplo' objects>, '__weakref__': <attribute '__weakref__' of 'ClaseEjemplo' objects>, '__doc__': None}\n",
      "\n",
      "{'__module__': '__main__', 'varia': 8, '__init__': <function ClaseEjemplo.__init__ at 0x00000154EC11F010>, '__dict__': <attribute '__dict__' of 'ClaseEjemplo' objects>, '__weakref__': <attribute '__weakref__' of 'ClaseEjemplo' objects>, '__doc__': None}\n",
      "\n",
      "{}\n"
     ]
    }
   ],
   "source": [
    "class ClaseEjemplo:\n",
    "    varia = 1\n",
    "    def __init__(self, val):\n",
    "        #self.varia=val\n",
    "        varia = val\n",
    "        ClaseEjemplo.varia = val\n",
    "\n",
    "print(ClaseEjemplo.__dict__)\n",
    "print()\n",
    "objetoEjemplo = ClaseEjemplo(8)\n",
    "\n",
    "print(ClaseEjemplo.__dict__)\n",
    "print()\n",
    "print(objetoEjemplo.__dict__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La actitud de Python hacia la instanciación de objetos plantea una cuestión importante: en contraste con otros lenguajes de programación, es posible que no esperes que todos los objetos de la misma clase tengan los mismos conjuntos de propiedades."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'ClaseEjemplo' object has no attribute 'b'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32mc:\\Users\\USUARIO\\Documents\\TI\\Python\\Cisco\\MOD6.ipynb Celda 72\u001b[0m in \u001b[0;36m<cell line: 11>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/USUARIO/Documents/TI/Python/Cisco/MOD6.ipynb#ch0000071?line=7'>8</a>\u001b[0m objetoEjemplo \u001b[39m=\u001b[39m ClaseEjemplo(\u001b[39m1\u001b[39m)\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/Users/USUARIO/Documents/TI/Python/Cisco/MOD6.ipynb#ch0000071?line=9'>10</a>\u001b[0m \u001b[39mprint\u001b[39m(objetoEjemplo\u001b[39m.\u001b[39ma)\n\u001b[1;32m---> <a href='vscode-notebook-cell:/c%3A/Users/USUARIO/Documents/TI/Python/Cisco/MOD6.ipynb#ch0000071?line=10'>11</a>\u001b[0m \u001b[39mprint\u001b[39m(objetoEjemplo\u001b[39m.\u001b[39;49mb)\n",
      "\u001b[1;31mAttributeError\u001b[0m: 'ClaseEjemplo' object has no attribute 'b'"
     ]
    }
   ],
   "source": [
    "class ClaseEjemplo:\n",
    "    def __init__(self, val):\n",
    "        if val % 2 != 0:\n",
    "            self.a = 1\n",
    "        else:\n",
    "            self.b = 1\n",
    "\n",
    "objetoEjemplo = ClaseEjemplo(1)\n",
    "\n",
    "print(objetoEjemplo.a)\n",
    "print(objetoEjemplo.b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El objeto creado por el constructor solo puede tener uno de los dos atributos posibles: a o b."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "class ClaseEjemplo:\n",
    "    def __init__(self, val):\n",
    "        if val % 2 != 0:\n",
    "            self.a = 1\n",
    "        else:\n",
    "            self.b = 1\n",
    "\n",
    "objetoEjemplo = ClaseEjemplo(1)\n",
    "print(objetoEjemplo.a)\n",
    "\n",
    "try:\n",
    "    print(objetoEjemplo.b)\n",
    "except AttributeError:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python proporciona una función que puede verificar con seguridad si algún objeto / clase contiene una propiedad específica. La función se llama hasattr, y espera que le pasen dos argumentos:\n",
    "\n",
    "- La clase o el objeto que se verifica.\n",
    "- El nombre de la propiedad cuya existencia se debe informar (Nota: debe ser una cadena que contenga el nombre del atributo).\n",
    "\n",
    "La función retorna True o False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "class ClaseEjemplo:\n",
    "    def __init__(self, val):\n",
    "        if val % 2 != 0:\n",
    "            self.a = 1\n",
    "        else:\n",
    "            self.b = 1\n",
    "\n",
    "objetoEjemplo = ClaseEjemplo(1)\n",
    "print(objetoEjemplo.a)\n",
    "\n",
    "if hasattr(objetoEjemplo, 'b'):\n",
    "    print(objetoEjemplo.b)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No olvides que la función hasattr() también puede operar en clases."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "class ClaseEjemplo:\n",
    "    attr = 1\n",
    "\n",
    "print(hasattr(ClaseEjemplo, 'attr'))\n",
    "print(hasattr(ClaseEjemplo, 'prop'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "class ClaseEjemplo:\n",
    "    a = 1\n",
    "    def __init__(self):\n",
    "        self.b = 2\n",
    "\n",
    "objetoEjemplo = ClaseEjemplo()\n",
    "\n",
    "print(hasattr(objetoEjemplo, 'b'))\n",
    "print(hasattr(objetoEjemplo, 'a'))\n",
    "print(hasattr(ClaseEjemplo, 'b'))\n",
    "print(hasattr(ClaseEjemplo, 'a'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***POO: Métodos***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "un método está obligado a tener al menos un parámetro (no existen métodos sin parámetros; un método puede invocarse sin un argumento, pero no puede declararse sin parámetros).\n",
    "\n",
    "El primer (o único) parámetro generalmente se denomina self. Te sugerimos que lo sigas nombrando de esta manera, darle otros nombres puede causar sorpresas inesperadas.\n",
    "\n",
    "El nombre self sugiere el propósito del parámetro - identifica el objeto para el cual se invoca el método."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "método\n"
     ]
    }
   ],
   "source": [
    "class conClase:\n",
    "    def metodo(self):\n",
    "        print(\"método\")\n",
    "\n",
    "obj = conClase()\n",
    "obj.metodo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "método: 1\n",
      "método: 2\n",
      "método: 3\n"
     ]
    }
   ],
   "source": [
    "class conClase:\n",
    "    def metodo(self, par):\n",
    "        print(\"método:\", par)\n",
    "\n",
    "obj = conClase()\n",
    "obj.metodo(1)\n",
    "obj.metodo(2)\n",
    "obj.metodo(3)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El parámetro self no solo es usado para obtener acceso a la instancia del objeto, si no también a las variables de clase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 3\n"
     ]
    }
   ],
   "source": [
    "class conClase:\n",
    "    varia = 2\n",
    "    def metodo(self):\n",
    "        print(self.varia, self.var)\n",
    "\n",
    "obj = conClase()\n",
    "obj.var = 3\n",
    "obj.metodo()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El parámetro self también se usa para invocar otros métodos desde dentro de la clase. Justo como aquí\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "class conClase():\n",
    "    def otro(self):\n",
    "        print(\"otro\")\n",
    "\n",
    "    def metodo(self):\n",
    "        print(\"método\")\n",
    "        self.otro()\n",
    "\n",
    "obj = conClase()\n",
    "obj.metodo()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si se nombra un método de esta manera: __ init __, no será un método regular, será un constructor.\n",
    "\n",
    "Si una clase tiene un constructor, este se invoca automática e implícitamente cuando se instancia el objeto de la clase.\n",
    "\n",
    "El constructor:\n",
    "\n",
    "- Esta obligado a tener el parámetro self (se configura automáticamente).\n",
    "- Pudiera (pero no necesariamente) tener mas parámetros que solo self; si esto sucede, la forma en que se usa el nombre de la clase para crear el objeto debe tener la definición __ init __.\n",
    "- Se puede utilizar para configurar el objeto, es decir, inicializa adecuadamente su estado interno, crea variables de instancia, crea instancias de cualquier otro objeto si es necesario, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "objeto\n"
     ]
    }
   ],
   "source": [
    "class conClase:\n",
    "    def __init__(self, valor):\n",
    "        self.var = valor\n",
    "\n",
    "obj1 = conClase(\"objeto\")\n",
    "\n",
    "print(obj1.var)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "objeto\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "class conClase:\n",
    "    def __init__(self, valor = None):\n",
    "        self.var = valor\n",
    "\n",
    "obj1 = conClase(\"objeto\")\n",
    "obj2 = conClase()\n",
    "\n",
    "print(obj1.var)\n",
    "print(obj2.var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ten en cuenta que el constructor:\n",
    "\n",
    "- No puede retornar un valor, ya que está diseñado para devolver un objeto recién creado y nada más.\n",
    "- No se puede invocar directamente desde el objeto o desde dentro de la clase (puedes invocar un constructor desde cualquiera de las superclases del objeto, pero discutiremos esto más adelante)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Todo lo que hemos dicho sobre el manejo de los nombres también se aplica a los nombres de métodos, un método cuyo nombre comienza con __ está (parcialmente) oculto.\n",
    "\n",
    "El ejemplo muestra este efecto:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "visible\n",
      "fallido\n",
      "oculto\n"
     ]
    }
   ],
   "source": [
    "class conClase:\n",
    "    def visible(self):\n",
    "        print(\"visible\")\n",
    "    \n",
    "    def __oculto(self):\n",
    "        print(\"oculto\")\n",
    "\n",
    "obj = conClase()\n",
    "obj.visible()\n",
    "\n",
    "try:\n",
    "    obj.__oculto()\n",
    "except:\n",
    "    print(\"fallido\")\n",
    "\n",
    "obj._conClase__oculto()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***La vida interna de clases y objetos***\n",
    "\n",
    "Cada clase de Python y cada objeto de Python está pre-equipado con un conjunto de atributos útiles que pueden usarse para examinar sus capacidades.\n",
    "\n",
    "Ya conoces uno de estos: es la propiedad __ dict __."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'var': 2}\n",
      "{'__module__': '__main__', 'varia': 1, '__init__': <function conClase.__init__ at 0x00000154EC11EB90>, 'metodo': <function conClase.metodo at 0x00000154EC1C0550>, '_conClase__oculto': <function conClase.__oculto at 0x00000154EC1C0EE0>, '__dict__': <attribute '__dict__' of 'conClase' objects>, '__weakref__': <attribute '__weakref__' of 'conClase' objects>, '__doc__': None}\n"
     ]
    }
   ],
   "source": [
    "class conClase:\n",
    "    varia = 1\n",
    "    def __init__(self):\n",
    "        self.var = 2\n",
    "\n",
    "    def metodo(self):\n",
    "        pass\n",
    "\n",
    "    def __oculto(self):\n",
    "        pass\n",
    "\n",
    "obj = conClase()\n",
    "\n",
    "print(obj.__dict__)\n",
    "print(conClase.__dict__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otra propiedad incorporada que vale la pena mencionar es una cadena llamada __ name __.\n",
    "\n",
    "La propiedad contiene el nombre de la clase. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "conClase\n",
      "conClase\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'conClase' object has no attribute '__name__'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32mc:\\Users\\USUARIO\\Documents\\TI\\Python\\Cisco\\MOD6.ipynb Celda 97\u001b[0m in \u001b[0;36m<cell line: 8>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/USUARIO/Documents/TI/Python/Cisco/MOD6.ipynb#ch0000095?line=4'>5</a>\u001b[0m obj \u001b[39m=\u001b[39m conClase()\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/USUARIO/Documents/TI/Python/Cisco/MOD6.ipynb#ch0000095?line=5'>6</a>\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39mtype\u001b[39m(obj)\u001b[39m.\u001b[39m\u001b[39m__name__\u001b[39m) \u001b[39m#-->encontrar la clase de un objeto en particular\u001b[39;00m\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/USUARIO/Documents/TI/Python/Cisco/MOD6.ipynb#ch0000095?line=7'>8</a>\u001b[0m \u001b[39mprint\u001b[39m(obj\u001b[39m.\u001b[39;49m\u001b[39m__name__\u001b[39;49m)\n",
      "\u001b[1;31mAttributeError\u001b[0m: 'conClase' object has no attribute '__name__'"
     ]
    }
   ],
   "source": [
    "class conClase:\n",
    "    pass\n",
    "\n",
    "print(conClase.__name__)\n",
    "obj = conClase()\n",
    "print(type(obj).__name__) #-->encontrar la clase de un objeto en particular\n",
    "\n",
    "print(obj.__name__) # Error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__ module __ es una cadena, también almacena el nombre del módulo que contiene la definición de la clase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "__main__\n",
      "__main__\n"
     ]
    }
   ],
   "source": [
    "class conClase:\n",
    "    pass\n",
    "\n",
    "print(conClase.__module__)\n",
    "obj = conClase()\n",
    "print(obj.__module__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cualquier módulo llamado __ main __ en realidad no es un módulo, sino es el archivo actualmente en ejecución."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__ bases __ es una tupla. La tupla contiene clases (no nombres de clases) que son superclases directas para la clase."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nota: solo las clases tienen este atributo - los objetos no."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(<class 'object'>,)\n",
      "( object )\n",
      "(<class 'object'>,)\n",
      "( object )\n",
      "(<class '__main__.SuperUno'>, <class '__main__.SuperDos'>)\n",
      "( SuperUno SuperDos )\n"
     ]
    }
   ],
   "source": [
    "class SuperUno:\n",
    "    pass\n",
    "\n",
    "class SuperDos:\n",
    "    pass\n",
    "\n",
    "class Sub(SuperUno, SuperDos):\n",
    "    pass\n",
    "\n",
    "\n",
    "def printBases(cls):\n",
    "    print(cls.__bases__)\n",
    "    print('( ', end='')\n",
    "\n",
    "    for x in cls.__bases__:\n",
    "        print(x.__name__, end=' ')\n",
    "    print(')')\n",
    "\n",
    "\n",
    "printBases(SuperUno)\n",
    "printBases(SuperDos)\n",
    "printBases(Sub)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nota: una clase sin superclases explícitas apunta al objeto (una clase de Python predefinida) como su antecesor directo.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 1, 'b': 2, 'i': 3, 'ireal': 3.5, 'entero': 4, 'z': 5}\n",
      "{'a': 1, 'b': 2, 'i': 4, 'ireal': 3.5, 'entero': 4, 'z': 5}\n"
     ]
    }
   ],
   "source": [
    "class MiClase:\n",
    "    pass\n",
    "\n",
    "obj = MiClase()\n",
    "obj.a = 1\n",
    "obj.b = 2\n",
    "obj.i = 3\n",
    "obj.ireal = 3.5\n",
    "obj.entero = 4\n",
    "obj.z = 5\n",
    "\n",
    "def incIntsI(obj):\n",
    "    for name in obj.__dict__.keys():\n",
    "        if name.startswith('i'):\n",
    "            val = getattr(obj, name)\n",
    "            if isinstance(val, int):\n",
    "                setattr(obj, name, val + 1)\n",
    "\n",
    "print(obj.__dict__)\n",
    "incIntsI(obj)\n",
    "print(obj.__dict__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Así es como funciona:\n",
    "\n",
    "- La línea 1: define una clase simple...\n",
    "- Líneas 3 a la 10: ... la llenan con algunos atributos.\n",
    "- Línea 12: ¡esta es nuestra función!\n",
    "- Línea 13: escanea el atributo __ dict __, buscando todos los nombres de atributos.\n",
    "- Línea 14: si un nombre comienza con i...\n",
    "- Línea 15: ... utiliza la función getattr() para obtener su valor actual; nota: getattr() toma dos argumentos: un objeto y su nombre de propiedad (como una cadena) y devuelve el valor del atributo actual.\n",
    "- Línea 16: comprueba si el valor es de tipo entero, emplea la función isinstance() para este propósito (discutiremos esto más adelante).\n",
    "- Línea 17: si la comprobación sale bien, incrementa el valor de la propiedad haciendo uso de la función setattr(); la función toma tres argumentos: un objeto, el nombre de la propiedad (como una cadena) y el nuevo valor de la propiedad."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Herencia***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Cómo se presenta un objeto a sí mismo?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Estrella object at 0x0000025076EF7B20>\n"
     ]
    }
   ],
   "source": [
    "class Estrella:\n",
    "    def __init__(self, nombre, galaxia):\n",
    "        self.nombre = nombre\n",
    "        self.galaxia = galaxia\n",
    "\n",
    "sol = Estrella(\"Sol\", \"Vía Láctea\")\n",
    "print(sol)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cuando Python necesita que alguna clase u objeto deba ser presentado como una cadena (es recomendable colocar el objeto como argumento en la invocación de la función print()), intenta invocar un método llamado __ str __() del objeto y emplear la cadena que devuelve.\n",
    "\n",
    "El método por default __ str __() devuelve la cadena anterior: fea y poco informativa. Puedes cambiarlo definiendo tu propio método del nombre.\n",
    "\n",
    "Lo acabamos de hacer: observa el código en el editor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sol en la Vía Láctea\n"
     ]
    }
   ],
   "source": [
    "class Estrella:\n",
    "    def __init__(self, nombre, galaxia):\n",
    "        self.nombre = nombre\n",
    "        self.galaxia = galaxia\n",
    "\n",
    "    def __str__(self):\n",
    "        return self.nombre + ' en la ' + self.galaxia\n",
    "\n",
    "sol = Estrella(\"Sol\", \"Vía Láctea\")\n",
    "print(sol)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La herencia es una práctica común (en la programación de objetos) de pasar atributos y métodos de la superclase (definida y existente) a una clase recién creada, llamada subclase.\n",
    "\n",
    "En otras palabras, la herencia es una forma de construir una nueva clase, no desde cero, sino utilizando un repertorio de rasgos ya definido. La nueva clase hereda (y esta es la clave) todo el equipamiento ya existente, pero puedes agregar algo nuevo si es necesario.\n",
    "\n",
    "Gracias a eso, es posible construir clases más especializadas (más concretas) utilizando algunos conjuntos de reglas y comportamientos generales predefinidos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Vehiculo: #A\n",
    "    pass\n",
    "\n",
    "class VehiculoTerrestre(Vehiculo):#B\n",
    "    pass\n",
    "\n",
    "class VehiculoOruga(VehiculoTerrestre): #C\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nota: si B es una subclase de A y C es una subclase de B, esto también significa que C es una subclase de A, ya que la relación es totalmente transitiva"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python ofrece una función que es capaz de identificar una relación entre dos clases, y aunque su diagnóstico no es complejo, puede verificar si una clase particular es una subclase de cualquier otra clase.\n",
    "\n",
    "Así es como se ve:\n"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "issubclass(ClaseUno, ClaseDos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función devuelve True si ClaseUno es una subclase de ClaseDos, y False de lo contrario."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\tFalse\tFalse\t\n",
      "True\tTrue\tFalse\t\n",
      "True\tTrue\tTrue\t\n"
     ]
    }
   ],
   "source": [
    "class Vehiculo:\n",
    "    pass\n",
    "\n",
    "class VehiculoTerrestre(Vehiculo):\n",
    "    pass\n",
    "\n",
    "class VehiculoOruga(VehiculoTerrestre):\n",
    "    pass\n",
    "\n",
    "\n",
    "for cls1 in [Vehiculo, VehiculoTerrestre, VehiculoOruga]:\n",
    "    for cls2 in [Vehiculo, VehiculoTerrestre, VehiculoOruga]:\n",
    "        print(issubclass(cls1, cls2), end=\"\\t\")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Existe una observación importante que hacer: cada clase se considera una subclase de sí misma."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En general, es crucial saber si un objeto tiene (o no tiene) ciertas características. En otras palabras, si es un objeto de cierta clase o no."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tal hecho podría ser detectado por la función llamada isinstance():\n",
    "\n"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "isinstance(nombreObjeto, nombreClase)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función devuelve True si el objeto es una instancia de la clase, o False de lo contrario."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\tFalse\tFalse\t\n",
      "True\tTrue\tFalse\t\n",
      "True\tTrue\tTrue\t\n"
     ]
    }
   ],
   "source": [
    "class Vehiculo:\n",
    "    pass\n",
    "\n",
    "class VehiculoTerrestre(Vehiculo):\n",
    "    pass\n",
    "\n",
    "class VehiculoOruga(VehiculoTerrestre):\n",
    "    pass\n",
    "\n",
    "\n",
    "miVehiculo = Vehiculo()\n",
    "miVehiculoTerrestre = VehiculoTerrestre()\n",
    "miVehiculoOruga = VehiculoOruga()\n",
    "\n",
    "for obj in [miVehiculo, miVehiculoTerrestre, miVehiculoOruga]:\n",
    "    for cls in [Vehiculo, VehiculoTerrestre, VehiculoOruga]:\n",
    "        print(isinstance(obj, cls), end=\"\\t\")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No lo olvides: si una subclase contiene al menos las mismas caracteristicas que cualquiera de sus superclases, significa que los objetos de la subclase pueden hacer lo mismo que los objetos derivados de la superclase, por lo tanto, es una instancia de su clase de inicio y cualquiera de sus superclases."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También existe un operador de Python que vale la pena mencionar, ya que se refiere directamente a los objetos: aquí está:\n",
    "\n"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "objetoUno is objetoDos\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El operador is verifica si dos variables (en este caso objetoUno y objetoDos) se refieren al mismo objeto.\n",
    "\n",
    "No olvides que las variables no almacenan los objetos en sí, sino solo los identificadores que apuntan a la memoria interna de Python.\n",
    "\n",
    "Asignar un valor de una variable de objeto a otra variable no copia el objeto, sino solo su identificador. Es por ello que un operador como is puede ser muy útil en ciertas circunstancias."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n",
      "True\n",
      "1 2 1\n",
      "True False\n"
     ]
    }
   ],
   "source": [
    "class ClaseMuestra:\n",
    "    def __init__(self, val):\n",
    "        self.val = val\n",
    "\n",
    "ob1 = ClaseMuestra(0)\n",
    "ob2 = ClaseMuestra(2)\n",
    "ob3 = ob1\n",
    "ob3.val += 1\n",
    "\n",
    "print(ob1 is ob2)\n",
    "print(ob2 is ob3)\n",
    "print(ob3 is ob1)\n",
    "print(ob1.val, ob2.val, ob3.val)\n",
    "\n",
    "str1 = \"Mary tenía un \"\n",
    "str2 = \"Mary tenía un corderito\"\n",
    "str1 += \"corderito\"\n",
    "\n",
    "\n",
    "print(str1 == str2, str1 is str2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Como python accede a los métodos y propiedades***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora, observemos el código que se muestra a continuación:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mi nombre es Andy.\n"
     ]
    }
   ],
   "source": [
    "class Super:\n",
    "    def __init__(self, nombre):\n",
    "        self.nombre = nombre\n",
    "\n",
    "    def __str__(self):\n",
    "        return \"Mi nombre es \" + self.nombre + \".\"\n",
    "    \n",
    "\n",
    "\n",
    "class Sub(Super): \n",
    "    def __init__(self, nombre):\n",
    "        Super.__init__(self, nombre)\n",
    "\n",
    "\n",
    "obj = Sub(\"Andy\")\n",
    "\n",
    "print(obj)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Qué ha ocurrido? Como no existe el método __ str __ () dentro de la clase Sub, la cadena a imprimir se producirá dentro de la clase Super. Esto significa que el método __ str __() ha sido **heredado** por la clase Sub."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mi nombre es Andy.\n"
     ]
    }
   ],
   "source": [
    "class Super:\n",
    "    def __init__(self, nombre):\n",
    "        self.nombre = nombre\n",
    "\n",
    "    def __str__(self):\n",
    "        return \"Mi nombre es \" + self.nombre + \".\"\n",
    "\n",
    "class Sub(Super):\n",
    "    def __init__(self, nombre):\n",
    "        super().__init__(nombre)\n",
    "\n",
    "\n",
    "obj = Sub(\"Andy\")\n",
    "\n",
    "print(obj)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el ejemplo anterior, nombramos explícitamente la superclase. En este ejemplo, hacemos uso de la función super(), la cual accede a la superclase sin necesidad de conocer su nombre. La función super() crea un contexto en el que no tiene que (además, no debe) pasar el argumento propio al método que se invoca; es por eso que es posible activar el constructor de la superclase utilizando solo un argumento.\n",
    "\n",
    "Nota: puedes usar este mecanismo no solo para invocar al constructor de la superclase, pero también para obtener acceso a cualquiera de los recursos disponibles dentro de la superclase."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Intentemos hacer algo similar, pero con propiedades (más precisamente con: variables de clase)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "# Probando propiedades: variables de clase\n",
    "class Super:\n",
    "    supVar = 1\n",
    "\n",
    "class Sub(Super):\n",
    "    subVar = 2\n",
    "\n",
    "obj = Sub()\n",
    "\n",
    "print(obj.subVar)\n",
    "print(obj.supVar)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El mismo efecto se puede observar con variables de instancia - observa el siguiente ejemplo en el editor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n",
      "11\n"
     ]
    }
   ],
   "source": [
    "# Probando propiedades: variables de instancia\n",
    "class Super:\n",
    "    def __init__(self):\n",
    "        self.supVar = 11\n",
    "\n",
    "class Sub(Super):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.subVar = 12\n",
    "\n",
    "obj = Sub()\n",
    "\n",
    "print(obj.subVar)\n",
    "print(obj.supVar)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nota: La existencia de la variable supVar obviamente está condicionada por la invocación del constructor de la clase Super. Omitirlo daría como resultado la ausencia de la variable en el objeto creado (pruébalo tu mismo).\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora es posible formular una declaración general que describa el comportamiento de Python.\n",
    "\n",
    "Cuando intentes acceder a una entidad de cualquier objeto, Python intentará (en este orden):\n",
    "\n",
    "- Encontrarla dentro del objeto mismo.\n",
    "- Encontrarla en todas las clases involucradas en la línea de herencia del objeto de abajo hacia arriba.\n",
    "\n",
    "Si ambos intentos fallan, una excepción (AttributeError) será lanzada."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 101 102\n",
      "200 201 202\n",
      "300 301 302\n"
     ]
    }
   ],
   "source": [
    "class Nivel1:\n",
    "    varia1 = 100\n",
    "    def __init__(self):\n",
    "        self.var1 = 101\n",
    "\n",
    "    def fun1(self):\n",
    "        return 102\n",
    "\n",
    "class Nivel2(Nivel1):\n",
    "    varia2 = 200\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.var2 = 201\n",
    "    \n",
    "    def fun2(self):\n",
    "        return 202\n",
    "\n",
    "class Nivel3(Nivel2):\n",
    "    varia3 = 300\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.var3 = 301\n",
    "\n",
    "    def fun3(self):\n",
    "        return 302\n",
    "\n",
    "obj = Nivel3()\n",
    "\n",
    "print(obj.varia1, obj.var1, obj.fun1())\n",
    "print(obj.varia2, obj.var2, obj.fun2())\n",
    "print(obj.varia3, obj.var3, obj.fun3())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Todos los comentarios que hemos hecho hasta ahora están relacionados con casos de **herencia única**, cuando una subclase tiene exactamente una superclase. Esta es la situación más común (y también la recomendada).\n",
    "\n",
    "La **herencia múltiple** ocurre cuando una clase tiene más de una superclase.\n",
    "\n",
    "Sintácticamente, dicha herencia se presenta como una lista de superclases separadas por comas entre paréntesis después del nombre de la nueva clase, al igual que aquí:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 11\n",
      "20 21\n"
     ]
    }
   ],
   "source": [
    "class SuperA:\n",
    "    varA = 10\n",
    "    def funA(self):\n",
    "        return 11\n",
    "\n",
    "class SuperB:\n",
    "    varB = 20\n",
    "    def funB(self):\n",
    "        return 21\n",
    "\n",
    "class Sub(SuperA, SuperB):\n",
    "    pass\n",
    "\n",
    "obj = Sub()\n",
    "\n",
    "print(obj.varA, obj.funA())\n",
    "print(obj.varB, obj.funB())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La clase Sub tiene dos superclases: SuperA y SuperB. Esto significa que la clase Sub hereda todos los bienes ofrecidos por ambas clases SuperA y SuperB.\n",
    "\n",
    "Ahora es el momento de introducir un nuevo término - overriding (anulación).\n",
    "\n",
    "¿Qué crees que sucederá si más de una de las superclases define una entidad con un nombre en particular?\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200 201\n"
     ]
    }
   ],
   "source": [
    "class Nivel1:\n",
    "    var = 100\n",
    "    def fun(self):\n",
    "        return 101\n",
    "\n",
    "class Nivel2:\n",
    "    var = 200\n",
    "    def fun(self):\n",
    "        return 201\n",
    "\n",
    "class Nivel3(Nivel2):\n",
    "    pass\n",
    "\n",
    "obj = Nivel3()\n",
    "\n",
    "print(obj.var, obj.fun())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La entidad definida después (en el sentido de herencia) anula la misma entidad definida anteriormente. Es por eso que el código produce el resultado esperado. La variable de clase var y el método fun() de la clase Nivel2 anula las entidades de los mismos nombres derivados de la clase Nivel1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esta característica se puede usar intencionalmente para modificar el comportamiento predeterminado de las clases (o definido previamente) cuando cualquiera de tus clases necesite actuar de manera diferente a su ancestro.\n",
    "\n",
    "También podemos decir que Python busca una entidad de abajo hacia arriba, y está completamente satisfecho con la primera entidad del nombre deseado que encuentre.\n",
    "\n",
    "¿Qué ocurre cuando una clase tiene dos ancestros que ofrecen la misma entidad y se encuentran en el mismo nivel? En otras palabras, ¿Qué se debe esperar cuando surge una clase usando herencia múltiple? Miremos lo siguiente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I II DD Izquierda\n"
     ]
    }
   ],
   "source": [
    "class Izquierda:\n",
    "    var = \"I\"\n",
    "    varIzquierda = \"II\"\n",
    "    def fun(self):\n",
    "        return \"Izquierda\"\n",
    "\n",
    "\n",
    "class Derecha:\n",
    "    var = \"D\"\n",
    "    varDerecha = \"DD\"\n",
    "    def fun(self):\n",
    "        return \"Derecha\"\n",
    "\n",
    "class Sub(Izquierda, Derecha):\n",
    "    pass\n",
    "\n",
    "# class Sub(Derecha, Izquierda):\n",
    "#     pass\n",
    "\n",
    "\n",
    "obj = Sub()\n",
    "\n",
    "print(obj.var, obj.varIzquierda, obj.varDerecha, obj.fun())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos decir que Python busca componentes de objetos en el siguiente orden:\n",
    "\n",
    "- Dentro del objeto mismo.\n",
    "- En sus superclases, de abajo hacia arriba.\n",
    "- Si hay más de una clase en una ruta de herencia, Python las escanea de izquierda a derecha."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Cómo construir una jerarquía de clases***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Echa un vistazo al código en el editor. Analicémoslo: \n",
    "\n",
    "El método doit() está definido dos veces: originalmente dentro de Uno y posteriormente dentro de Dos. La esencia del ejemplo radica en el hecho de que es invocado solo una vez - dentro de Uno.\n",
    "\n",
    "La pregunta es: ¿cuál de los dos métodos será invocado por las dos últimas líneas del código?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hazlo de Uno\n",
      "hazlo de Dos\n"
     ]
    }
   ],
   "source": [
    "class Uno:\n",
    "    def hazlo(self):\n",
    "        print(\"hazlo de Uno\")\n",
    "\n",
    "    def haz_algo(self):\n",
    "        self.hazlo()\n",
    "\n",
    "class Dos(Uno):\n",
    "    def hazlo(self):\n",
    "        print(\"hazlo de Dos\")\n",
    "\n",
    "uno = Uno()\n",
    "dos = Dos()\n",
    "\n",
    "uno.haz_algo()\n",
    "dos.haz_algo()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La segunda invocación lanzará el método hazlo() en la forma existente dentro de la clase Dos, independientemente del hecho de que la invocación se lleva a cabo dentro de la clase Uno."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La situación en la cual la subclase puede modificar el comportamiento de su superclase (como en el ejemplo) se llama polimorfismo. La palabra proviene del griego (polys: \"muchos, mucho\" y morphe, \"forma, forma\"), lo que significa que una misma clase puede tomar varias formas dependiendo de las redefiniciones realizadas por cualquiera de sus subclases.\n",
    "\n",
    "El método, redefinido en cualquiera de las superclases, que cambia el comportamiento de la superclase, se llama virtual.\n",
    "\n",
    "En otras palabras, ninguna clase se da por hecho. El comportamiento de cada clase puede ser modificado en cualquier momento por cualquiera de sus subclases.\n",
    "\n",
    "Te mostraremos cómo usar el polimorfismo para extender la flexibilidad de la clase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "class VehiculoOruga:\n",
    "    def control_de_pista(izquierda, alto):\n",
    "        pass\n",
    "\n",
    "    def girar(izquierda):\n",
    "        control_de_pista(izquierda, True)\n",
    "        time.sleep(0.25)\n",
    "        control_de_pista(izquierda, False)\n",
    "\n",
    "\n",
    "class VehiculoTerrestre:\n",
    "    def girar_ruedas_delanteras(izquierda, on):\n",
    "        pass\n",
    "\n",
    "    def girar(izquierda):\n",
    "        girar_ruedas_delanteras(izquierda, True)\n",
    "        time.sleep(0.25)\n",
    "        girar_ruedas_delanteras(izquierda, False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Puede parecer extraño, pero no utilizamos herencia en este ejemplo, solo queríamos mostrarte que no nos limita."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Puedes detectar el error del código?\n",
    "\n",
    "Los métodos girar()son muy similares como para dejarlos en esta forma.\n",
    "\n",
    "Vamos a reconstruir el código: vamos a presentar una superclase para reunir todos los aspectos similares de los vehículos, trasladando todos los detalles a las subclases.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "class Vehiculo:\n",
    "    def cambiardireccion(izquierda, on):\n",
    "        pass\n",
    "\n",
    "    def girar(izquierda):\n",
    "        cambiardireccion(izquierda, True)\n",
    "        time.sleep(0.25)\n",
    "        cambiardireccion(izquierda, False)\n",
    "\n",
    "class VehiculoOruga(Vehiculo):\n",
    "    def control_de_pista(izquierda, alto):\n",
    "        pass\n",
    "\n",
    "    def cambiardireccion(izquierda, on):\n",
    "        control_de_pista(izquierda, on)\n",
    "\n",
    "class VehiculoTerrestre(Vehiculo):\n",
    "    def girar_ruedas_delanteras(izquierda, on):\n",
    "        pass\n",
    "\n",
    "    def cambiardireccion(izquierda, on):\n",
    "        girar_ruedas_delanteras(izquierda, on)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La herencia no es la única forma de construir clases adaptables. Puedes lograr los mismos objetivos (no siempre, pero muy a menudo) utilizando una técnica llamada composición.\n",
    "\n",
    "La **composición** es el proceso de componer un objeto usando otros objetos diferentes. Los objetos utilizados en la composición entregan un conjunto de rasgos deseados (propiedades y / o métodos), podemos decir que actúan como bloques utilizados para construir una estructura más complicada."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ruedas:  True True\n",
      "ruedas:  True False\n",
      "pistas:  False True\n",
      "pistas:  False False\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "class Pistas:\n",
    "    def cambiardireccion(self, izquierda, on):\n",
    "        print(\"pistas: \", izquierda, on)\n",
    "\n",
    "class Ruedas:\n",
    "    def cambiardireccion(self, izquierda, on):\n",
    "        print(\"ruedas: \", izquierda, on)\n",
    "\n",
    "class Vehiculo:\n",
    "    def __init__(self, controlador):\n",
    "        self.controlador = controlador\n",
    "\n",
    "    def girar(self, izquierda):\n",
    "        self.controlador.cambiardireccion(izquierda, True)\n",
    "        time.sleep(0.25)\n",
    "        self.controlador.cambiardireccion(izquierda, False)\n",
    "\n",
    "conRuedas = Vehiculo(Ruedas())\n",
    "conPistas = Vehiculo(Pistas())\n",
    "\n",
    "conRuedas.girar(True)\n",
    "conPistas.girar(False)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.4 64-bit",
   "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"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "110fe3fb9777db4ce1f884af3cc527a40b2c98427ad17781c021ef692bd3d28d"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}