POO con Python II.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "KB0GIS4acQJ2"
   },
   "source": [
    "# <img src=\"uni-logo.png\" alt=\"Logo UNI\" width=100 hight=200 align=\"right\">\n",
    "\n",
    "\n",
    "<br><br><br>\n",
    "<h1><font color=\"#1D65DD\" size=5>Python desde cero</font></h1>\n",
    "\n",
    "\n",
    "\n",
    "<h1><font color=\"#1D65DD\" size=6>POO con Python II</font></h1>\n",
    "\n",
    "<br>\n",
    "<div style=\"text-align: right\">\n",
    "<font color=\"#1D65DD\" size=3>Yuri Coicca, M.Sc.</font><br>\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"indice\"></a>\n",
    "<h2><font color=\"#004D7F\" size=5>Índice</font></h2>\n",
    "\n",
    "\n",
    "* [3.1. Clase](#section10)\n",
    "* [3.2. Instancia de una clase: Objeto](#section11)\n",
    "* [3.3. Atributos y Métodos](#section12)\n",
    "   * [Atributos](#section121)\n",
    "   * [Composición](#section122)\n",
    "   * [Atributos especiales](#section123)\n",
    "   * [Métodos](#section124)   \n",
    "   * [Creando clases mediante un constructor](#section125) \n",
    "   * [Otros métodos propios de las clases](#section126)    \n",
    "* [3.4. Propiedades de la POO](#section13)\n",
    "   * [Modularización](#section131)\n",
    "   * [Built-in modules](#section132)\n",
    "   * [Herencia](#section133)\n",
    "   * [Herencia simple](#section134)   \n",
    "   * [Herencia de clase con constructor](#section135)     \n",
    "   * [Polimorfismo](#section136)\n",
    "   * [Encapsulamiento](#section137)   \n",
    "* [3.5. Modificadores de acceso: private, public](#section14)   \n",
    "   * [Funciones que accedan a las propiedades](#section141)   \n",
    "* [3.6. Constructor](#section15)\n",
    "* [3.7. Destructor](#section16)\n",
    "* [3.8. Variables y métodos estáticos](#section17)   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "4jhvcgbbcQJ3"
   },
   "source": [
    "La programación orientada a objetos es un paradigma de programación que busca representar entidades u objetos agrupando datos y métodos que puedan describir sus características y comportamiento."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "VwIVzf8KcQJ4"
   },
   "source": [
    "\n",
    "**_¿Qué es un Paradigma?_**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "kIZDuVxBcQJ5"
   },
   "source": [
    "Un paradigma es el resultado de un proceso social en el cual un grupo de personas desarrolla nuevas ideas y crea principios y prácticas alrededor de estas ideas. (Metodología de trabajo). Forma de entender y representar la realidad (abstracción). Conjunto de teorías, estándares y métodos que, juntos, representan un modo de organizar el pensamiento."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "foewUIBkcQJ6"
   },
   "source": [
    "![title](img/Paradigmas.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "mY52-hIjcQJ7"
   },
   "source": [
    "## Programación Orientada a Procedimientos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "P5LvqM0QcQJ7"
   },
   "source": [
    "También conocido como el paradigma imperativo. Consiste en una secuencia de instrucciones que el computador debe ejecutar. \n",
    "\n",
    "\n",
    "* Variables, zonas de memoria donde guardamos información.\n",
    "* Tipos de datos, son los valores que se pueden almacenar.\n",
    "* Expresiones, corresponde a operaciones entre variables (del mismo o distinto tipo)\n",
    "* Estructuras de control, que permiten ejecutar un conjunto de instrucciones varias veces, ejecutar una parte del código u otra en función de que se cumpla una condición o abortar la ejecución del programa."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "82ZMVQq_cQJ8"
   },
   "source": [
    "### <img src=\"img/codigo.png\" alt=\"Python\" width=800 hight=600 align=\"center\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "HUDlgp99cQJ9"
   },
   "source": [
    "**Desventajas:**\n",
    "* Pocas personas lo manejan\n",
    "* Unidades de código muy grandes en aplicaciones complejas.\n",
    "* Poco reutilizable\n",
    "* Si existe un fallo en alguna línea de código, es muy probable que el programa caiga.\n",
    "* Difícil de depurar (mantenimiento)\n",
    "* Ejemplos: Fortran, Basic, C, Pascal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "xZgP6T4mcQJ-"
   },
   "source": [
    "## Programación Orientada a Objetos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "fI7B1951cQJ_"
   },
   "source": [
    "La programación orientada a objetos es un enfoque de programación que combina **datos** y acciones asociadas (**métodos**) en estructuras lógicas (**objetos**). Este enfoque aumenta la capacidad para administrar la complejidad del software, lo cual resulta especialmente importante cuando se desarrollan y mantienen aplicaciones y estructuras de datos de gran tamaño. (MATLAB, 2018)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "JoJMI4BXcQJ_"
   },
   "source": [
    "**Ventajas:**\n",
    "* Los componentes se pueden reutilizar\n",
    "* Facilidad de mantenimiento y modificación de los objetos existentes.\n",
    "* Estructura modular\n",
    "* Facilita la creación de aplicaciones de interfaz con el usuario (GUI).\n",
    "* Excelente para el analisis de grandes bases de datos\n",
    "* Ejemplos: C++, C#, VB.NET, Java, **Python**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "v2gm-ORmcQKA"
   },
   "source": [
    "Metodología de desarrollo de aplicaciones en la cual éstas se organizan como colecciones cooperativas de objetos, cada uno de los cuales representan una instancia de alguna clase, y cuyas clases son miembros de jerarquías de clases unidas mediante relaciones de herencia. (Grady Booch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "kdXPyw8heBm7"
   },
   "source": [
    "### <img src=\"img/lego.png\" alt=\"Python\" width=300 hight=200 align=\"center\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7CLeFBlTcQKB"
   },
   "source": [
    "<a id=\"section10\"></a> \n",
    "# <font color=\"#004D7F\"> 3.1 Clase</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "2hi90peocQKC"
   },
   "source": [
    "La clase es un modelo o prototipo que define las variables (características compartidas) y métodos comunes a todos los objetos de cierta clase. También se puede decir que una clase es una plantilla genérica para un conjunto de objetos de similares características. **Por convención las clases empiezan en Mayúscula y en singular.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "sutmRcRVeBm9"
   },
   "source": [
    "### <img src=\"img/caja.png\" alt=\"Python\" width=290 hight=130 align=\"center\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "WuRPfCb8cQKD"
   },
   "source": [
    "Ejemplo:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "zf3V_dJZcQKE"
   },
   "source": [
    "Clase Vehículo\n",
    "*\tRuedas\n",
    "*\tTipo de Motor\n",
    "*\tCapacidad del Tanque de Gasolina\n",
    "*\tNumero de Velocidades de la Caja de Cambios\n",
    "*\tColor\n",
    "*   Arranca\n",
    "*   Frena\n",
    "*   Gira\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "vA7NeNMDcQKF"
   },
   "source": [
    "Una clase es un nuevo tipo de dato, contiene: \n",
    "*\tOtros datos (que pueden ser de cualquier tipo, se le conocen como atributos)\n",
    "*\tFunciones, que operan sobre esos datos. (También conocidas como métodos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <img src=\"img/carro.png\" alt=\"Python\" width=600 hight=400 align=\"center\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "xmkHKm8qcQKG"
   },
   "source": [
    "Por lo tanto, **una clase es un generador de objetos**. Es una estructura que **se usa como plantilla para crear objetos (dentro de una clase)**. Esta plantilla describe tanto el estado como el comportamiento de los objetos que se crean a partir de ella. El estado es mantenido vía los atributos y el comportamiento vía los métodos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img\\figura.jpg\" alt=\"Python\" width=\"300\"/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "4KUySaSocQKH"
   },
   "outputs": [],
   "source": [
    "# En Python, las clases se definen mediante la palabra reservada class.\n",
    "\n",
    "class Nueva_clase (object):\n",
    "    #Código dentro de la clase (métodos y atributos)\n",
    "    pass\n",
    "  \n",
    "# Debido a que se trata de una clase vacia, es necesario colocar la palabra reservada \"pass\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La declaración `pass` es una declaración nula. Pero la diferencia entre **pass** y **comment** es que el intérprete ignora el comentario, mientras que pass no es ignorado. Esta declaración se usa generalmente como un marcador de posición (placeholder), es decir, cuando el usuario no sabe qué código escribir. Por lo tanto, el usuario simplemente coloca un pass en esa línea. A veces, se usa cuando el usuario no quiere que se ejecute ningún código. Por lo tanto, el usuario simplemente lo coloca, ya que el código vacío no está permitido en bucles, definiciones de funciones, definiciones de clases o en declaraciones if. Por lo tanto, el uso del usuario de la declaración pass evita este error."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "nNXEnKR8cQKK"
   },
   "source": [
    "Donde:\n",
    "\n",
    "* *Código_de_ la_ clase* incluye la declaración de métodos y atributos\n",
    "* *objetc* es la clase base para cualquier objeto creado en Python\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "5dxzop6SeK9A"
   },
   "source": [
    "Esta sintaxis funciona incluso si no se utiliza la clase base *object*, o si no se colocan los parentesis():"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "3I-AHFpseU0B"
   },
   "outputs": [],
   "source": [
    "class Persona:\n",
    "    pass\n",
    "\n",
    "class Objeto:\n",
    "    pass\n",
    "\n",
    "class Antena:\n",
    "    pass\n",
    "\n",
    "class Pelo:\n",
    "    pass\n",
    "\n",
    "class Ojo:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "                **     class Persona     =     class Persona()     =     class Persona(object)     **"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cuando ejecutamos el método type, nos indicará el tipo de objeto con el que se está trabajando. Para el caso de la clases, la respuesta es type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "type"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(Persona)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1460,
     "status": "ok",
     "timestamp": 1567520008702,
     "user": {
      "displayName": "Edgar Avalos Gauna",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mBlAgNUstu0sLee83F6yPWlOeuhkSOIQBP1BMW9=s64",
      "userId": "15081544959551912541"
     },
     "user_tz": 300
    },
    "id": "H7XluTHDg0AZ",
    "outputId": "89f5a7f1-4b1c-428b-d2fd-be9c66bae0f7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'type'>\n"
     ]
    }
   ],
   "source": [
    "print(type(Persona))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1453,
     "status": "ok",
     "timestamp": 1567520008703,
     "user": {
      "displayName": "Edgar Avalos Gauna",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mBlAgNUstu0sLee83F6yPWlOeuhkSOIQBP1BMW9=s64",
      "userId": "15081544959551912541"
     },
     "user_tz": 300
    },
    "id": "tCAIoQ7jeBnK",
    "outputId": "40328c32-2de1-4ee2-a256-fa7482d25e70"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'type'>\n"
     ]
    }
   ],
   "source": [
    "print(type(Objeto))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "aunrbH1-cQKL"
   },
   "source": [
    "<a id=\"section11\"></a> \n",
    "# <font color=\"#004D7F\"> 3.2 Instancia de una clase: Objeto</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "czpX65TfcQKM"
   },
   "source": [
    "Una **instancia** u **objeto** es la implementación particular de una clase. Si tenemos la clase orca, una instancia puede ser Willy. Es posible crear varias instancias independientes una de otra (como Shamu que es independiente de Willy).\n",
    "Un objeto es una unidad que engloba en sí mismo características y comportamiento necesarias para procesar información. Cada objeto contiene datos y funciones. Y un programa se construye como un conjunto de objetos, o como un único objeto.\n",
    "Python está completamente orientado a objetos: puede definir sus propias clases, heredar de las que usted defina o de las incorporadas en el lenguaje, e instanciar las clases que haya definido. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "GVViKJADcQKM"
   },
   "source": [
    "Siguiendo con el ejemplo de la clase Vehículo, si nosotros quisieramos describir un Vehículo en particular, podemos hacer referncia a la clase ya mencionada previamente, y adecuandola a nuestro caso particular."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "NawHq9vzcQKN"
   },
   "source": [
    "Carro BMW Características:\n",
    "*\t4 Ruedas Micheline\n",
    "*\tMotor BMW\n",
    "*\tCaja de cambios de 7 Velocidades\n",
    "*\tColor Azul\n",
    "*\t2 Espejos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "kwf0kIVDcQKO"
   },
   "source": [
    "Para entender mejor los conceptos hasta ahora vistos, usemos la clase Persona que se creo con anterioridad para crear una instancia de la misma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "J5EiAJW0gOzO"
   },
   "outputs": [],
   "source": [
    "Edgar=Persona() #El objeto Edgar es una instancia de la clase Persona"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "                **     Edgar=Persona()     es diferente a     Edgar=Persona     **\n",
    "                          <Objeto>                           <Copia de clase>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1439,
     "status": "ok",
     "timestamp": 1567520008704,
     "user": {
      "displayName": "Edgar Avalos Gauna",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mBlAgNUstu0sLee83F6yPWlOeuhkSOIQBP1BMW9=s64",
      "userId": "15081544959551912541"
     },
     "user_tz": 300
    },
    "id": "qXgOOGA9gb26",
    "outputId": "07c16a96-0c85-4778-a339-bd39c078c024"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.Persona'>\n"
     ]
    }
   ],
   "source": [
    "print(type(Edgar))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(Edgar,Persona)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'type'>\n"
     ]
    }
   ],
   "source": [
    "Edgar2=Persona\n",
    "print(type(Edgar2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(Edgar2,Persona)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "1qINHGzHhm5o"
   },
   "source": [
    "Debido a que la clase se encuentra vacia no es posible obtener mayor información. Es por ello que será necesario modificarla para entonces poder trabajar con esa clase. Esto se hace simplemente al agregar las lineas de código que se consideren pertinentes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "oBDw9f3QcQKY"
   },
   "source": [
    "<a id=\"section12\"></a> \n",
    "# <font color=\"#004D7F\"> 3.3 Atributos y Métodos</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "qqJzZKx0cQKY"
   },
   "source": [
    "<a id=\"section121\"></a> \n",
    "### Atributos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "577BjYeXjUaV"
   },
   "source": [
    "Las variables incluidas en una clase se denominan atributos. Cada objeto tiene sus atributos, como por ejemplo peso. **Willy** tendrá un peso distinto de **Shamu**. Aunque ambas instancias pertenecen a la misma clase (**orca**). Comparten el tipo de atributo. Podríamos tener la **clase perro** con instancias **Lassie y Laika** con el atributo color_de_pelo que no será compartido con las instancias de la clase orca"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "tQZ6ZZ2LeBnX"
   },
   "source": [
    "### <img src=\"img/propieades.png\" alt=\"Python\" width=480 hight=190 align=\"center\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python **no permite el uso de variables vacias**, es por ello que es necesario inicializar los atributos asignando un valor arbitrario para poder ser utilizados."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Persona:\n",
    "    nombre=\"\" # Variable inicializada"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "YkxEy9gJcQKZ"
   },
   "outputs": [],
   "source": [
    "# El siguiente paso será modificar dicha clase y agregar más atributos.\n",
    "class Persona:\n",
    "    #Clase que representa una Persona\n",
    "    edad = 53\n",
    "    nombre = \"Philip\"\n",
    "    apellido = \"Butters\"\n",
    "    sexo = \"M\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1430,
     "status": "ok",
     "timestamp": 1567520008704,
     "user": {
      "displayName": "Edgar Avalos Gauna",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mBlAgNUstu0sLee83F6yPWlOeuhkSOIQBP1BMW9=s64",
      "userId": "15081544959551912541"
     },
     "user_tz": 300
    },
    "id": "QU-rII2pcQKc",
    "outputId": "8e5dcae0-45b5-4edc-d787-761c4fe03551"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Butters'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Persona.apellido"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Zj12ANVAeBnc"
   },
   "outputs": [],
   "source": [
    "class Antena():\n",
    "    color = \"Negro\"\n",
    "    longitud = \"2 cm\"\n",
    "    \n",
    "class Pelo():\n",
    "    color = \"Gris\"\n",
    "    textura = \"Aspero\"\n",
    "    \n",
    "class Ojo():\n",
    "    forma = \"Redondo\"\n",
    "    color = \"Verde\"\n",
    "    tamanio = \"Chico\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 387,
     "status": "ok",
     "timestamp": 1567520542981,
     "user": {
      "displayName": "Edgar Avalos Gauna",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mBlAgNUstu0sLee83F6yPWlOeuhkSOIQBP1BMW9=s64",
      "userId": "15081544959551912541"
     },
     "user_tz": 300
    },
    "id": "Iz2fZHLXeBnf",
    "outputId": "8ace1d08-3047-4c8e-e803-1327434a5f3e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Negro'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Antena.color"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**dir()** es una poderosa función incorporada (`inbuilt function`) en Python 3, que devuelve una lista de los atributos y métodos de cualquier objeto (por ejemplo, funciones, módulos, cadenas, listas, diccionarios, etc.). Esta función intenta retornar una lista válida de atributos del objeto al que se llama. Además, se comporta de manera bastante diferente con diferentes tipos de objetos, ya que tiene como objetivo producir el más relevante, en lugar de la información completa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 55
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 303,
     "status": "ok",
     "timestamp": 1567520556648,
     "user": {
      "displayName": "Edgar Avalos Gauna",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mBlAgNUstu0sLee83F6yPWlOeuhkSOIQBP1BMW9=s64",
      "userId": "15081544959551912541"
     },
     "user_tz": 300
    },
    "id": "musxsADIgPNi",
    "outputId": "563c314b-5ab7-4085-e92b-9e90e6c0fa0f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'color', 'longitud']\n"
     ]
    }
   ],
   "source": [
    "print(dir(Antena))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para modificar el valor de un atributo, simplemente hay que hacer el llamado del objeto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1 cm'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Antena.longitud=\"1 cm\"\n",
    "Antena.longitud"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**vars()** es una función incorporada (`inbuilt function`) en Python. El método `vars ()` toma solo un parámetro y ese también es opcional. Toma un objeto como parámetro que puede ser un módulo, una clase, una instancia o cualquier objeto que tenga el atributo __dict__.\n",
    "\n",
    "El método devuelve el atributo __dict__ para un módulo, clase, instancia o cualquier otro objeto si el mismo tiene un atributo __dict__. Si el objeto no coincide con el atributo, genera una excepción TypeError. Los objetos como módulos e instancias tienen un atributo __dict__ actualizable; sin embargo, otros objetos pueden tener restricciones escritas en sus atributos __dict__. vars () actúa como el método locals () cuando se pasa un argumento vacío, lo que implica que el diccionario local solo es útil para lecturas, ya que se ignoran las actualizaciones del diccionario local."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "mappingproxy({'__module__': '__main__',\n",
       "              'color': 'Negro',\n",
       "              'longitud': '1 cm',\n",
       "              '__dict__': <attribute '__dict__' of 'Antena' objects>,\n",
       "              '__weakref__': <attribute '__weakref__' of 'Antena' objects>,\n",
       "              '__doc__': None})"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Al modificar un atributo, los otros se mantienen igual:\n",
    "vars(Antena)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Actividad\n",
    "\n",
    "* Crear 5 clases vacias relacionadas al concepto de universidad\n",
    "* Reescribir las 5 clases, asignando un atributo diferente a cada una de ellas.\n",
    "* Ya creadas las clases, asignar 1 atribuo mas a cada una, sin la necesidad de reescribir el código"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"section122\"></a> \n",
    "## Composición:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible, que una clase herede los atributos de otra clase por medio de la instanciación:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "B4Pc9vzmeBnk"
   },
   "outputs": [],
   "source": [
    "# La clase Bicho adquirirá todos los atributos de las otras clases, por medio de la instanciación.\n",
    "\n",
    "class Bicho():\n",
    "    aspecto = \"Feo\"\n",
    "    antenas = Antena() # Instancia de Antena\n",
    "    ojos = Ojo() # Instancia de Ojo\n",
    "    pelos = Pelo() # Instancia de Pelo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Comprobamos que Bicho no sea una subclase:\n",
    "issubclass(Bicho,Antena)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1402,
     "status": "ok",
     "timestamp": 1567520008706,
     "user": {
      "displayName": "Edgar Avalos Gauna",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mBlAgNUstu0sLee83F6yPWlOeuhkSOIQBP1BMW9=s64",
      "userId": "15081544959551912541"
     },
     "user_tz": 300
    },
    "id": "3Np6y26aeBnq",
    "outputId": "9b21fe87-0260-4066-b6b8-46a7c0bb907c",
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Negro'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Bicho.antenas.color"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1392,
     "status": "ok",
     "timestamp": 1567520008707,
     "user": {
      "displayName": "Edgar Avalos Gauna",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mBlAgNUstu0sLee83F6yPWlOeuhkSOIQBP1BMW9=s64",
      "userId": "15081544959551912541"
     },
     "user_tz": 300
    },
    "id": "refqiokgeBnt",
    "outputId": "13dc559a-a1e4-4ffe-eabc-d2f1dede4ee1"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1 cm'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Bicho.antenas.longitud"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1382,
     "status": "ok",
     "timestamp": 1567520008707,
     "user": {
      "displayName": "Edgar Avalos Gauna",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mBlAgNUstu0sLee83F6yPWlOeuhkSOIQBP1BMW9=s64",
      "userId": "15081544959551912541"
     },
     "user_tz": 300
    },
    "id": "goeqV39PeBnv",
    "outputId": "7f2aafc2-e070-4d41-96a3-3f4e76a675c9"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Feo'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Bicho.aspecto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1373,
     "status": "ok",
     "timestamp": 1567520008707,
     "user": {
      "displayName": "Edgar Avalos Gauna",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mBlAgNUstu0sLee83F6yPWlOeuhkSOIQBP1BMW9=s64",
      "userId": "15081544959551912541"
     },
     "user_tz": 300
    },
    "id": "h1QOWuU9eBny",
    "outputId": "69b5b910-2949-405e-ca0b-64a0c6bab800"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'type'>\n"
     ]
    }
   ],
   "source": [
    "print(type(Bicho))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 563
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 390,
     "status": "ok",
     "timestamp": 1567520894220,
     "user": {
      "displayName": "Edgar Avalos Gauna",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mBlAgNUstu0sLee83F6yPWlOeuhkSOIQBP1BMW9=s64",
      "userId": "15081544959551912541"
     },
     "user_tz": 300
    },
    "id": "fk49azNohpmx",
    "outputId": "8b747e27-020d-460c-8a5a-639fd9a281cf"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'antenas', 'aspecto', 'ojos', 'pelos']\n"
     ]
    }
   ],
   "source": [
    "print(dir(Bicho))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "mappingproxy({'__module__': '__main__',\n",
       "              'aspecto': 'Feo',\n",
       "              'antenas': <__main__.Antena at 0x9eb27e59a0>,\n",
       "              'ojos': <__main__.Ojo at 0x9eb27e5be0>,\n",
       "              'pelos': <__main__.Pelo at 0x9eb27e5a00>,\n",
       "              '__dict__': <attribute '__dict__' of 'Bicho' objects>,\n",
       "              '__weakref__': <attribute '__weakref__' of 'Bicho' objects>,\n",
       "              '__doc__': None})"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vars(Bicho)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.5cm'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Bicho.antenas.longitud=\"1.5cm\"\n",
    "Bicho.antenas.longitud"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "_qVqHKUGpQf2"
   },
   "outputs": [],
   "source": [
    "class Mariposa:\n",
    "    antenas=Antena()\n",
    "    tipo=\"Monarca\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 360,
     "status": "ok",
     "timestamp": 1567523052424,
     "user": {
      "displayName": "Edgar Avalos Gauna",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mBlAgNUstu0sLee83F6yPWlOeuhkSOIQBP1BMW9=s64",
      "userId": "15081544959551912541"
     },
     "user_tz": 300
    },
    "id": "FbjKqYlqppfe",
    "outputId": "49037232-ff82-4487-ac6c-7b9471bd4827"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1 cm'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Mariposa.antenas.longitud"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 359,
     "status": "ok",
     "timestamp": 1567523078208,
     "user": {
      "displayName": "Edgar Avalos Gauna",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mBlAgNUstu0sLee83F6yPWlOeuhkSOIQBP1BMW9=s64",
      "userId": "15081544959551912541"
     },
     "user_tz": 300
    },
    "id": "895k6CAjp5nB",
    "outputId": "aba0a060-4791-469d-81e1-74d81c24dcfb"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Monarca'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Mariposa.tipo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Actividad\n",
    "\n",
    "Crear una nueva clase, la cuál reciba los atributos de las 5 clases anteriores por medio del método de instanciación."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "5-t6ujWLcQKe"
   },
   "outputs": [],
   "source": [
    "#Recordatorio:\n",
    "\n",
    "Edgar=Persona()     #Instancia de clase\n",
    "Prueba=Persona      #Copia de clase"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"section123\"></a> \n",
    "### Atributos especiales"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "QNQn_8G7cQKk"
   },
   "source": [
    "**Si el nombre de un atributo esta encerrado entre dobles guiones bajos son atributos especiales.** Los atributos generados de forma manual aparecerán al final de la lista únicamente entre comillas. Estos atributos se utilizan para definir comportamientos básicos de un objeto y **son comunes con otras clases**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1351,
     "status": "ok",
     "timestamp": 1567520008709,
     "user": {
      "displayName": "Edgar Avalos Gauna",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mBlAgNUstu0sLee83F6yPWlOeuhkSOIQBP1BMW9=s64",
      "userId": "15081544959551912541"
     },
     "user_tz": 300
    },
    "id": "grDDZFlfcQKk",
    "outputId": "cb1fe93b-3b34-4a01-ecc5-2617ce8e2564"
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'Prueba' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-33-54831d09ceba>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m#__name__, da el nombre de la clase asociada. Esto es similar al método __class__ que se genera en las instancias.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mPrueba\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'Prueba' is not defined"
     ]
    }
   ],
   "source": [
    "#__name__, da el nombre de la clase asociada. Esto es similar al método __class__ que se genera en las instancias.\n",
    "Prueba.__name__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.Persona"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Edgar.__class__  #El atributo especial __class__ nos indicará la clase generadora del objeto en cuestión"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Edgar.__name__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "type"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Prueba.__class__ #La respuesta type nos indica que Prueba es una copia de la clase y no una instancia."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(Prueba,Persona)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.Persona'>\n"
     ]
    }
   ],
   "source": [
    "print(type(Edgar))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(Edgar,Persona)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "FJdVUbTbcQKn"
   },
   "source": [
    "**Los atributos especiales están escondidos y están relacionados con la encapsulación**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para obtener ayuda con respecto a un objeto, es posible usar el método **help()**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on Persona in module __main__ object:\n",
      "\n",
      "class Persona(builtins.object)\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",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  apellido = 'Butters'\n",
      " |  \n",
      " |  edad = 53\n",
      " |  \n",
      " |  nombre = 'Philip'\n",
      " |  \n",
      " |  sexo = 'M'\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(Edgar)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.Persona at 0x9eb1c35250>"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Edgar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1331,
     "status": "ok",
     "timestamp": 1567520008712,
     "user": {
      "displayName": "Edgar Avalos Gauna",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mBlAgNUstu0sLee83F6yPWlOeuhkSOIQBP1BMW9=s64",
      "userId": "15081544959551912541"
     },
     "user_tz": 300
    },
    "id": "GWWNKNtzcQKu",
    "outputId": "2b9b3cae-752d-42ac-ba0a-719c039b0532"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Una instancia de la clase (Persona), es el objeto (Philip).\n"
     ]
    }
   ],
   "source": [
    "print (\"Una instancia de la clase (\" + Prueba.__name__ +\"), es el objeto (\"+ Edgar.nombre + \").\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1325,
     "status": "ok",
     "timestamp": 1567520008713,
     "user": {
      "displayName": "Edgar Avalos Gauna",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mBlAgNUstu0sLee83F6yPWlOeuhkSOIQBP1BMW9=s64",
      "userId": "15081544959551912541"
     },
     "user_tz": 300
    },
    "id": "buQ-IXYEcQKw",
    "outputId": "ebd3e88c-a43a-4ced-af70-58cef041d687"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola, mucho gusto, mi nombre es Philip Butters, tengo 53 años, y mi sexo es M.\n"
     ]
    }
   ],
   "source": [
    "print (\"Hola, mucho gusto, mi nombre es \"+ \\\n",
    "    Edgar.nombre +\" \"+ \\\n",
    "    Edgar.apellido +\", tengo \"+  \\\n",
    "    str(Edgar.edad) +\" años, y mi sexo es \"+  \\\n",
    "    Edgar.sexo +\".\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 54
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1317,
     "status": "ok",
     "timestamp": 1567520008713,
     "user": {
      "displayName": "Edgar Avalos Gauna",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mBlAgNUstu0sLee83F6yPWlOeuhkSOIQBP1BMW9=s64",
      "userId": "15081544959551912541"
     },
     "user_tz": 300
    },
    "id": "EOvDYeQfcQK0",
    "outputId": "ebf56b31-7a25-45c7-8562-c757d590a0f4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola, mucho gusto, mi nombre es Philip Butters,\n",
      "tengo 53 años, y mi sexo es M.\n"
     ]
    }
   ],
   "source": [
    "print (\"Hola, mucho gusto, mi nombre es \"+ \\\n",
    "    Edgar.nombre +\" \"+ \\\n",
    "    Edgar.apellido +\",\\ntengo \"+  \\\n",
    "    str(Edgar.edad) +\" años, y mi sexo es \"+  \\\n",
    "    Edgar.sexo +\".\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "zt9YKgX6cQK2"
   },
   "source": [
    "<a id=\"section124\"></a> \n",
    "### Métodos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "raw",
    "id": "0wg54d15eBoL"
   },
   "source": [
    "Los métodos son funciones definidas por el programador que darán los comportamientos del objeto. Representan acciones propias que solo puede llevar acabo el objeto (y no otro):"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "lN7IORRneBoM"
   },
   "source": [
    "### <img src=\"img/metodos.png\" alt=\"Python\" width=350 hight=200 align=\"center\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "OvpNDoo3eBoM"
   },
   "source": [
    "**A continuación se presenta una clase llamada Perro, en donde se enlistan una serie de sustantivos descriptores y de acciones que pueden ser llevadas a cabo por el perro.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "mfgQLK4SeBoN"
   },
   "source": [
    "### <img src=\"img/perro.png\" alt=\"Python\" width=450 hight=300 align=\"center\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "0IJEXLS5eBoN"
   },
   "source": [
    "Una vez creado una clase u objeto, es posible modificar sus atributos mediante una simple asignación. Inspeccionamos la clase Bicho para recordar los métodos y atributos que lo componen:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "eDmKh4fCeBoY"
   },
   "source": [
    "Es posible trabajar los objetos utilizando nuevas funciones. Crearemos una función para determinar el sexo de una persona si solamente se le indica la inicial del sexo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "YTrlZtlxyBww"
   },
   "outputs": [],
   "source": [
    "def Genero(sexo):\n",
    "        #Mostrar el genero de la Persona\n",
    "        genero = ('Masculino','Femenino') #Se crea una tupla\n",
    "        if sexo == \"M\":\n",
    "            return genero[0]\n",
    "        elif sexo == \"F\":\n",
    "            return genero[1]\n",
    "        else:\n",
    "            return \"Desconocido\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1531,
     "status": "ok",
     "timestamp": 1567520008980,
     "user": {
      "displayName": "Edgar Avalos Gauna",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mBlAgNUstu0sLee83F6yPWlOeuhkSOIQBP1BMW9=s64",
      "userId": "15081544959551912541"
     },
     "user_tz": 300
    },
    "id": "o1zoofR9yLiw",
    "outputId": "740b2a37-e390-4585-cd68-56d8e832885f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Masculino\n"
     ]
    }
   ],
   "source": [
    "a=Genero(\"M\")\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "iV-vZAMIc7dD"
   },
   "source": [
    "A un objeto (*receptor*) se le envían mensajes para que realice una determinada acción. El objeto selecciona un método (*selector*) apropiado para realizar dicha acción. A este proceso se le denomina Paso de mensajes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "PdyBS65fdCtf"
   },
   "source": [
    "          Sintáxis de un mensaje: \treceptor.selector(argumentos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1520,
     "status": "ok",
     "timestamp": 1567520008980,
     "user": {
      "displayName": "Edgar Avalos Gauna",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mBlAgNUstu0sLee83F6yPWlOeuhkSOIQBP1BMW9=s64",
      "userId": "15081544959551912541"
     },
     "user_tz": 300
    },
    "id": "DZMgRLQYeBoj",
    "outputId": "6168e566-c43d-4d50-bb3a-ffc9797c1124"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'M'"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Edgar.sexo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1513,
     "status": "ok",
     "timestamp": 1567520008981,
     "user": {
      "displayName": "Edgar Avalos Gauna",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mBlAgNUstu0sLee83F6yPWlOeuhkSOIQBP1BMW9=s64",
      "userId": "15081544959551912541"
     },
     "user_tz": 300
    },
    "id": "1wRH0rqJeBon",
    "outputId": "041e0347-6364-4f91-d955-6ad76721d055"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Masculino'"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Genero(Edgar.sexo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 334,
     "status": "ok",
     "timestamp": 1567524001832,
     "user": {
      "displayName": "Edgar Avalos Gauna",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mBlAgNUstu0sLee83F6yPWlOeuhkSOIQBP1BMW9=s64",
      "userId": "15081544959551912541"
     },
     "user_tz": 300
    },
    "id": "1BPboMbotZWi",
    "outputId": "2edfd961-0617-4fdc-bfa0-38c719331151"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Masculino'"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=Genero\n",
    "a(Edgar.sexo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "TNFYjoD8mPRU"
   },
   "source": [
    "Los métodos son funciones definidas dentro de una clase u objeto. Por ello para su creación es necesario utilizar la palabra reservada **def**, esto se hace mediante la siguiente sintaxis:\n",
    "\n",
    "------------------------------------------------------------------------------------------------------------------------\n",
    "\n",
    "                          def + nombre del método + (self, atributos del método):\n",
    "                          \n",
    "------------------------------------------------------------------------------------------------------------------------\n",
    "\n",
    "La palabra **self** es un argumento implicito indicando que el objeto hace referencia así mismo. Este método implicito nos permite asignar métodos y atributos a la clase u objeto. El atributo self no puede ser llamado solo y no producirá resultados."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Metodo1:\n",
    "    def iniciar(self):\n",
    "        return(\"Esta es mi primera clase con un método\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Esta es mi primera clase con un método'"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj1=Metodo1()\n",
    "obj1.iniciar()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Metodo2:\n",
    "    def suma(self,a,b):\n",
    "        return(a+b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "obj2=Metodo2()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Tip, recuerda presionar Shift+Tab dentro de los parentesis para obtener información del método\n",
    "obj2.suma(3,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Saludo:\n",
    "    def saludar(self,x):\n",
    "        if x==True:\n",
    "            print(\"Hola\")\n",
    "        else:\n",
    "            print(\"Adios\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "hello=Saludo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adios\n"
     ]
    }
   ],
   "source": [
    "hello.saludar(\"si\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adios\n"
     ]
    }
   ],
   "source": [
    "hello.saludar(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola\n"
     ]
    }
   ],
   "source": [
    "hello.saludar(True) #Por ser variable boleana, el valor de 1 daría la misma respuesta que con True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hello.saludar(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "FZRXmVqHcQK5"
   },
   "outputs": [],
   "source": [
    "class Lenguajes:\n",
    "    def tipo_de_lenguaje(self,x):\n",
    "        if x==1:\n",
    "            print(\"Python\")\n",
    "        elif x==2:\n",
    "            print(\"C#\")\n",
    "        elif x==3:\n",
    "            print(\"Visual\")\n",
    "        else:\n",
    "            print(\"No se\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "uXse5Kg3nSxo"
   },
   "outputs": [],
   "source": [
    "codigo=Lenguajes()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 363,
     "status": "ok",
     "timestamp": 1567524589245,
     "user": {
      "displayName": "Edgar Avalos Gauna",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mBlAgNUstu0sLee83F6yPWlOeuhkSOIQBP1BMW9=s64",
      "userId": "15081544959551912541"
     },
     "user_tz": 300
    },
    "id": "6WqBcURGvu94",
    "outputId": "8d9ea21f-2358-4d1d-99fa-c7df2f3143a4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.Lenguajes'>\n"
     ]
    }
   ],
   "source": [
    "print(type(codigo))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "QVBo3k0jeBot"
   },
   "source": [
    "                                     receptor.selector(argumentos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 364,
     "status": "ok",
     "timestamp": 1567524765696,
     "user": {
      "displayName": "Edgar Avalos Gauna",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mBlAgNUstu0sLee83F6yPWlOeuhkSOIQBP1BMW9=s64",
      "userId": "15081544959551912541"
     },
     "user_tz": 300
    },
    "id": "YTI6K0GFnpna",
    "outputId": "ce72c7c0-7d23-4f90-8df2-2819fc9bae44"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No se\n"
     ]
    }
   ],
   "source": [
    "codigo.tipo_de_lenguaje(\"letras\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "C5NEtdfxwocf"
   },
   "source": [
    "### Actividad\n",
    "\n",
    "Crea 3 clases que contengan un método diferente:\n",
    "* El método de la primer clase debe de realizar las 4 operaciones básicas con 2 números dados\n",
    "* El método de la segunda clase debe de escribir la frase \"Hola Mundo!\" el número de veces indicado\n",
    "* El tercer método debe de determinar el cuadrante de un punto en el espacio 2D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Mate:\n",
    "    def operaciones(self,x,y):\n",
    "        print(x+y)\n",
    "        print(x-y)\n",
    "        print(x*y)\n",
    "        print(x/y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "-1\n",
      "6\n",
      "0.6666666666666666\n"
     ]
    }
   ],
   "source": [
    "obj_mate=Mate()\n",
    "obj_mate.operaciones(2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Ciclo:\n",
    "    def repeticion(self,x):\n",
    "        for i in range(x):\n",
    "            print(\"Hola Mundo!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola Mundo!\n",
      "Hola Mundo!\n",
      "Hola Mundo!\n"
     ]
    }
   ],
   "source": [
    "obj_ciclo=Ciclo()\n",
    "obj_ciclo.repeticion(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Punto:\n",
    "    def cuadrante(self,x,y):\n",
    "        if x>0 and y>0:\n",
    "            print(\"Cuadrante I\")\n",
    "        elif x<0 and y>0:\n",
    "            print(\"Cuadrante II\")\n",
    "        elif x<0 and y<0:\n",
    "            print(\"Cuadrante III\")\n",
    "        elif x>0 and y<0:\n",
    "            print(\"Cuadrante IV\")\n",
    "        elif x!=0 and y==0:\n",
    "            print(\"Eje X\")\n",
    "        elif x==0 and y!=0:\n",
    "            print(\"Eje Y\")\n",
    "        else:\n",
    "            print(\"Origen\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Eje X\n"
     ]
    }
   ],
   "source": [
    "obj_punto=Punto()\n",
    "obj_punto.cuadrante(-6,0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"section125\"></a>\n",
    "## Creando clases mediante un constructor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "MOU4z3WnoxxZ"
   },
   "source": [
    "Para poder implementar tanto atributos como variables dentro de una clase, es recomendable utilizar un constructor. En el caso de python es la palabra reservada **__init__** y se utiliza como si se estuviera definiendo una función:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "xzlvCOI8mrA_"
   },
   "outputs": [],
   "source": [
    "class Persona:\n",
    "    def __init__(self, nombre, apellido, edad, sexo):\n",
    "        self.nombre = nombre\n",
    "        self.edad = edad\n",
    "        self.apellido = apellido\n",
    "        self.sexo = sexo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1409,
     "status": "ok",
     "timestamp": 1567525557001,
     "user": {
      "displayName": "Edgar Avalos Gauna",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mBlAgNUstu0sLee83F6yPWlOeuhkSOIQBP1BMW9=s64",
      "userId": "15081544959551912541"
     },
     "user_tz": 300
    },
    "id": "FiJv61aWy3y-",
    "outputId": "b4b59b17-4e04-46b9-a9e5-3b8dd849001e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'nombre': 'Edgar', 'edad': 32, 'apellido': 'Avalos', 'sexo': 'M'}\n"
     ]
    }
   ],
   "source": [
    "persona_1=Persona(\"Edgar\", \"Avalos\", 32, \"M\")\n",
    "print(vars(persona_1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 330,
     "status": "ok",
     "timestamp": 1567525678329,
     "user": {
      "displayName": "Edgar Avalos Gauna",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mBlAgNUstu0sLee83F6yPWlOeuhkSOIQBP1BMW9=s64",
      "userId": "15081544959551912541"
     },
     "user_tz": 300
    },
    "id": "0138YwQfzvKV",
    "outputId": "8e29a3b7-e901-4feb-8ce0-723e74ddcbcd"
   },
   "source": [
    "### Crearemos otra instancia de la clase Persona"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "persona_2=Persona(\"Edgar\", \"Avalos\", 32, \"M\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 55
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 331,
     "status": "ok",
     "timestamp": 1567525750892,
     "user": {
      "displayName": "Edgar Avalos Gauna",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mBlAgNUstu0sLee83F6yPWlOeuhkSOIQBP1BMW9=s64",
      "userId": "15081544959551912541"
     },
     "user_tz": 300
    },
    "id": "LXeOl_fR0JR-",
    "outputId": "e6739cd5-4927-4cc8-e423-966980f8e3c3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'__module__': '__main__', '__init__': <function Persona.__init__ at 0x0000009EB1C21430>, '__dict__': <attribute '__dict__' of 'Persona' objects>, '__weakref__': <attribute '__weakref__' of 'Persona' objects>, '__doc__': None}\n"
     ]
    }
   ],
   "source": [
    "print(vars(Persona))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']\n"
     ]
    }
   ],
   "source": [
    "print(dir(Persona))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "311IZKNw4X_F"
   },
   "source": [
    "**self** es un parámetro especial que siempre se utilizará como una referencia al objeto mismo. Debe ser siempre el primer parámetro formal; no obstante, nunca se le dará un valor de parámetro real en la invocación. En caso de que olvidemos poner el atributo self dentro de un método, Python nos indicará que existe un error en el que 1 argumento fue introducido:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "reset() takes 0 positional arguments but 1 was given",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-82-1fd543223077>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[0mp\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mPoint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m \u001b[1;31m#El error se hará presente cuando ejecutemos la linea de abajo ya que el atributo self no está presente\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 7\u001b[1;33m \u001b[0mp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mreset\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: reset() takes 0 positional arguments but 1 was given"
     ]
    }
   ],
   "source": [
    "class Point:\n",
    "    def reset():\n",
    "        pass\n",
    "\n",
    "p = Point()\n",
    "#El error se hará presente cuando ejecutemos la linea de abajo ya que el atributo self no está presente\n",
    "p.reset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejemplo de clase interactuando con sus atributos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ZL0GLU45lyPH"
   },
   "outputs": [],
   "source": [
    "class Perro:\n",
    "\n",
    "    def __init__(self, nombre):\n",
    "        self.nombre = nombre\n",
    "        self.trucos = []    # crea una nueva lista vacía para cada perro\n",
    "\n",
    "    def aprender_truco(self, truco):\n",
    "        self.trucos.append(truco)\n",
    "\n",
    "d = Perro('Fido')\n",
    "e = Perro('Buddy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1490,
     "status": "ok",
     "timestamp": 1567520008983,
     "user": {
      "displayName": "Edgar Avalos Gauna",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mBlAgNUstu0sLee83F6yPWlOeuhkSOIQBP1BMW9=s64",
      "userId": "15081544959551912541"
     },
     "user_tz": 300
    },
    "id": "czzAkQoq45_g",
    "outputId": "142c7027-e261-4714-fad0-22ebfda9b93c"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.trucos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1483,
     "status": "ok",
     "timestamp": 1567520008984,
     "user": {
      "displayName": "Edgar Avalos Gauna",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mBlAgNUstu0sLee83F6yPWlOeuhkSOIQBP1BMW9=s64",
      "userId": "15081544959551912541"
     },
     "user_tz": 300
    },
    "id": "2vLK4e0k48br",
    "outputId": "8753e99a-4a20-44f5-8eea-2c2da16c8623"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['girar']"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.aprender_truco('girar')\n",
    "e.aprender_truco('hacerse el muerto')\n",
    "d.trucos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1475,
     "status": "ok",
     "timestamp": 1567520008984,
     "user": {
      "displayName": "Edgar Avalos Gauna",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mBlAgNUstu0sLee83F6yPWlOeuhkSOIQBP1BMW9=s64",
      "userId": "15081544959551912541"
     },
     "user_tz": 300
    },
    "id": "k24s3CHI4_dc",
    "outputId": "9ed82b97-51ab-40a0-e28d-40e1f6e7978b"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['hacerse el muerto']"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e.trucos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1467,
     "status": "ok",
     "timestamp": 1567520008984,
     "user": {
      "displayName": "Edgar Avalos Gauna",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mBlAgNUstu0sLee83F6yPWlOeuhkSOIQBP1BMW9=s64",
      "userId": "15081544959551912541"
     },
     "user_tz": 300
    },
    "id": "3iJ3U37jpvbD",
    "outputId": "fce9e47c-c404-4d1e-d035-dddb66d28df7"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['hacerse el muerto', 'girar']"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e.aprender_truco('girar')\n",
    "e.trucos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otro ejemplo de una clase, haciendo interactuar sus métodos con sus atributos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Poligono_Irr:\n",
    "    def __init__(self, no_de_lados):\n",
    "        self.n = no_de_lados\n",
    "        self.lados = []\n",
    "    def Indicar_long_lados(self):\n",
    "        for i in range(self.n):\n",
    "            a= float(input(\"Indica la longitud del lado \"+str(i+1)+\" : \"))\n",
    "            self.lados.append(a)\n",
    "\n",
    "    def Mostrar_long_lados(self):\n",
    "        for i in range(self.n):\n",
    "            print(\"Lado\",i+1,\"es\",self.lados[i])\n",
    "    \n",
    "    def Calcular_perimetro(self): \n",
    "        print(sum(self.lados))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "cuadrado=Poligono_Irr(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Indica la longitud del lado 1 : 4\n",
      "Indica la longitud del lado 2 : 3\n",
      "Indica la longitud del lado 3 : 6\n",
      "Indica la longitud del lado 4 : 2\n"
     ]
    }
   ],
   "source": [
    "cuadrado.Indicar_long_lados()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lado 1 es 4.0\n",
      "Lado 2 es 3.0\n",
      "Lado 3 es 6.0\n",
      "Lado 4 es 2.0\n"
     ]
    }
   ],
   "source": [
    "cuadrado.Mostrar_long_lados()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15.0\n"
     ]
    }
   ],
   "source": [
    "cuadrado.Calcular_perimetro()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "BXyEXYcyeBo9"
   },
   "source": [
    "## Ejercicios"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "1iCTOp2TeBo9"
   },
   "source": [
    "1. Crea 1 clase vacia llamada Vector. \n",
    "2. Modifica la clase Vector para que asignarle coordenadas 3i-7j\n",
    "3. Modifica la clase Vector para que los valores de coordenadas sean variables y genera 3 instancias diferentes.\n",
    "4. Modifica la clase Vector para que a partir de las coordenadas, determine el cuadrante en el que se encuentra el vector.\n",
    "5. Modifica la clase para que determine la magnitud, dirección y sentido del vector dadas las coordenadas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UKESFevSeBo9"
   },
   "source": [
    "El código resultante del paso 5, deberá de ejecutarse en **Jupyter**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "5xN78PnGeBo-"
   },
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "class Vector:\n",
    "\n",
    "    def __init__(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "\n",
    "    def cuadrante(self):\n",
    "        if self.x > 0 and self.y > 0:\n",
    "            print(\"El vector pertenece al primer cuadrante\")\n",
    "        elif self.x < 0 and self.y > 0:\n",
    "            print(\"El vector pertenece al segundo cuadrante\")\n",
    "        elif self.x < 0 and self.y < 0:\n",
    "            print(\"El vector pertenece al tercer cuadrante\")\n",
    "        elif self.x > 0 and self.y < 0:\n",
    "            print(\"El vector pertenece al cuarto cuadrante\")\n",
    "        elif self.x != 0 and self.y == 0:\n",
    "            print(\"El vector se sitúa sobre el eje X\")\n",
    "        elif self.x == 0 and self.y != 0:\n",
    "            print(\"El vector se sitúa sobre el eje Y\")\n",
    "        else:\n",
    "            print(\"El vector se encuentra sobre el origen\")\n",
    "        d = math.sqrt( (self.x)**2 + (self.y)**2 )\n",
    "        d=round(d,3)\n",
    "        angulo=round(math.degrees(math.atan(abs(self.y/self.x))),3)\n",
    "        print(\"Su magnitud es de: \" + str(d))\n",
    "        print(\"Su ángulo es de: \" + str(angulo) + \"°\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 596
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 532536,
     "status": "error",
     "timestamp": 1567520540065,
     "user": {
      "displayName": "Edgar Avalos Gauna",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mBlAgNUstu0sLee83F6yPWlOeuhkSOIQBP1BMW9=s64",
      "userId": "15081544959551912541"
     },
     "user_tz": 300
    },
    "id": "4xRDKDsveBpC",
    "outputId": "f3392657-349c-4a5e-d004-2be79e8a66aa"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Indique las coordenadas (x) de su Vector\n",
      "3\n",
      "Indique las coordenadas (y) de su Vector\n",
      "7\n",
      "El vector pertenece al primer cuadrante\n",
      "Su magnitud es de: 7.616\n",
      "Su ángulo es de: 66.801°\n"
     ]
    }
   ],
   "source": [
    "print(\"Indique las coordenadas (x) de su Vector\")\n",
    "i=input()\n",
    "print(\"Indique las coordenadas (y) de su Vector\")\n",
    "j=input()\n",
    "obj_Vector=Vector(float(i),float(j))\n",
    "obj_Vector.cuadrante()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"section126\"></a>\n",
    "# Otros métodos propios de las clases"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De lo visto con el metodo Costructor, nos damos cuenta que al instanciar el objeto perrito, debemos pasarle los parámetros de su estado inicial, los cuales son los que definimos en el método constructor color y raza. Al ejecutar este código obtendremos lo siguiente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Este es un cachorro de la raza Golden retriever y es de color Marrón claro\n"
     ]
    }
   ],
   "source": [
    "class Cachorro():\n",
    "\n",
    "    def __init__(self, color, raza):\n",
    "        self.color = color\n",
    "        self.raza = raza\n",
    "\n",
    "\n",
    "perrito = Cachorro(\"Marrón claro\", \"Golden retriever\")\n",
    "\n",
    "print(\"Este es un cachorro de la raza {} y es de color {}\".format(perrito.raza, perrito.color))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Método string()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El método string es otro de los métodos propios de las clases de Python, utilizando el mismo ejemplo anterior veamos que pasa cuando ejecutamos una salida por pantalla de lo que se encuentra instanciado en el objeto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Cachorro object at 0x0000009EB27E5C40>\n"
     ]
    }
   ],
   "source": [
    "class Cachorro():\n",
    "\n",
    "    def __init__(self, color, raza):\n",
    "        self.color = color\n",
    "        self.raza = raza\n",
    "\n",
    "\n",
    "perrito = Cachorro(\"Marrón claro\", \"Golden retriever\")\n",
    "\n",
    "print(perrito)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python nos dice que obtenemos un objeto del tipo Cachorro, simplemente nos dice que es una instancia en la clase Cachorro pero no se cual son sus propiedades, es decir su color y su raza entonces es aquí donde entra el método string que vamos a definir. Al ejecutar nuevamente el código, se obtendrá lo que se encuentra instanciado dentro de ese objeto y todo gracias a que definimos el método __str__."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Raza: Golden retriever\n",
      "Color: Marrón claro\n"
     ]
    }
   ],
   "source": [
    "class Cachorro():\n",
    "\n",
    "    def __init__(self, color, raza):\n",
    "        self.color = color\n",
    "        self.raza = raza\n",
    "\n",
    "    def __str__(self):\n",
    "        return \"\"\"\\\n",
    "Raza: {}\n",
    "Color: {}\"\"\".format(self.raza, self.color)\n",
    "\n",
    "\n",
    "perrito = Cachorro(\"Marrón claro\", \"Golden retriever\")\n",
    "\n",
    "print(perrito)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Método repr()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este método es muy parecido al string, su única diferencia es que se utiliza para que el mismo Python identifique que hay dentro. Una vez dicho esto, se puede decir que las diferencias que tienen ambos es que el método string es usado para que un humano pueda saber lo que hay dentro del objeto mientras que el método repr() es usado para que el programador sepa que hay dentro del objeto, vamos a rehutilizar el código anterior, pero esta vez le agregaremos un atributo id. Al ejecutar el código se verá que la función nos retorna un string diciendonos que hay una instancia del tipo cachorro con el id número 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<Cachorro 1>\n"
     ]
    }
   ],
   "source": [
    "class Cachorro():\n",
    "\n",
    "    def __init__(self, color, raza, id):\n",
    "        self.color = color\n",
    "        self.raza = raza\n",
    "        self.id = id\n",
    "\n",
    "    def __str__(self):\n",
    "        return \"\"\"\\\n",
    "Raza: {}\n",
    "Color: {}\"\"\".format(self.raza, self.color)\n",
    "\n",
    "    def __repr__(self) -> str:\n",
    "        return \"<Cachorro {}>\".format(self.id)\n",
    "\n",
    "\n",
    "perrito = Cachorro(\"Marrón claro\", \"Golden retriever\", 1)\n",
    "print(repr(perrito))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si se fijan se obtiene el formato que se dió al reescribir el método repr(), pero cualquier persona al leer esto no sabrá porque se representa de la forma <Cachorro 1> solamente nosotros los programadores sabremos que es un objeto porque es así como el interprete de Python hace referencia a los objetos, aunque falten otras cosas como por ejemplo la dirección en memoria en la que se encuentra, pero para este caso remplazamos el método repr() para mostrar el tipo de objeto y el id que lleva asignado dicho objeto."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "nf6JlCp6cQK6"
   },
   "source": [
    "<a id=\"section13\"></a> \n",
    "# <font color=\"#004D7F\"> 3.4 Propiedades de la POO</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "r_R7PwgRcQK7"
   },
   "source": [
    "<a id=\"section131\"></a> \n",
    "### Modularización"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "xcNOubs2cQK8"
   },
   "source": [
    "Los programas pueden escribirse en módulos, los que permiten que un problema general pueda descomponerse en una serie de subproblemas independientes (Divide y vencerás). Se puede repartir la tarea entre varias personas, y concentrarse en la resolución de cada subproblema. Cuando una tarea debe realizarse más de una vez en un mismo programa, la modularización evita la programación redundante, ya que una vez definida la tarea como un módulo independiente, puede ser invocada desde cualquier parte del código; se aprecia también una menor longitud del programa."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ykVy6tm9eBpF"
   },
   "source": [
    "### <img src=\"img/casa.png\" alt=\"Python\" width=500 hight=300 align=\"center\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "DMzlOXvKqKWW"
   },
   "source": [
    "Las caracteristicas mas relevantes de la modularización son:\n",
    "\n",
    "1. Capacidad de descomponer un sistema complejo.\n",
    "\n",
    "2. Capacidad de componer a través de sus módulos.\n",
    "\n",
    "3. Comprensión de sistema en partes\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"section132\"></a> \n",
    "### Built-in modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python cuenta con una gran cantidad de modulos incoporados para poder usar de acuerdo a la actividad que se necesite, estos son algunos ejemplos:\n",
    "\n",
    "* altair\n",
    "* datetime\n",
    "* calendar\n",
    "* math\n",
    "* numpy\n",
    "* matplotlib\n",
    "* pandas\n",
    "* random\n",
    "* seaborn\n",
    "\n",
    "La palabra reservada para acceder a ellos es **import**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "import calendar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 0 = Lunes, ..., 6 = Domingo\n",
    "calendar.weekday(2021,7,31)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejercicios\n",
    "\n",
    "1. Crear una carpeta que se llame funciones, dicha carpeta debe estar en el mismo directorio que el presente documento.\n",
    "2. Dentro de la carpeta se deben crear 1 archivos de python(.py) con el nombre triangulo.\n",
    "3. Copiar el código que a continuación se presenta:\n",
    "\n",
    "\n",
    "\n",
    "                def triangulo(etapa):\n",
    "                    import matplotlib.pyplot as plt\n",
    "                    import matplotlib.patches as mpatches\n",
    "                    import numpy as np\n",
    "\n",
    "                    def get_triangle(P):\n",
    "                        m = P * 0.5\n",
    "                        n = P * 0.5 + np.array([0.5, 0])\n",
    "                        k = P * 0.5 + np.array([0.25, np.sqrt(3)/4])\n",
    "                        return np.array([m,n,k])\n",
    "\n",
    "                    # triangulo unitario inicial\n",
    "                    triangle = np.array([[0, 0],\n",
    "                                   [1, 0],\n",
    "                                   [0.5, np.sqrt(3)/2]])\n",
    "\n",
    "                    # Crea un array que representa el triangulo Sierpinski hasta la etapa deseada\n",
    "                    for e in range(etapa):\n",
    "                        triangle = get_triangle(triangle)\n",
    "\n",
    "                    # Se procede a graficar el triangulo\n",
    "                    fig1 = plt.figure()\n",
    "                    ax1 = fig1.add_subplot(111, aspect='equal')\n",
    "                    for t in triangle.reshape(3**etapa,3,2):\n",
    "                        ax1.add_patch(mpatches.Polygon(t, fc=\"y\"))\n",
    "\n",
    "                    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from Modulos import triangulo as sp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sp.triangulo(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "8RCvZOs2cQLA"
   },
   "source": [
    "<a id=\"section133\"></a> \n",
    "### Herencia"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "-YV1XBybcQLA"
   },
   "source": [
    "Es la propiedad de crear nuevos datos a partir de los ya existentes (progenitores). Heredamos sus atributos y métodos. Podemos sobrescribirlos para adaptarlos a la clase heredada (clase hija).\n",
    "\n",
    "                    class Subclase(Superclase):"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ywl4EYfueBpJ"
   },
   "source": [
    "### <img src=\"img/herencia.png\" alt=\"Python\" width=300 hight=120 align=\"center\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Jmiw32Pprif8"
   },
   "source": [
    "El nombre de la clase derivada, debe de estar contenido dentro de la clase base. Esto le sirve al programador al momento de estar trabajando con los diferentes objetos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <img src=\"img/futbol2.png\" alt=\"Python\" width=600 hight=400 align=\"center\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <img src=\"img/futbol1.png\" alt=\"Python\" width=600 hight=400 align=\"center\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"section134\"></a> \n",
    "## Herencia simple\n",
    "\n",
    "\n",
    "**Sintaxis:**\n",
    "\n",
    "                  class     subclase     (superclase):"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las siguientes 3 clases, son ejemplos de clases vacías. En los 3 casos el resultado es el mismo, todas van a heredar de la clase object (built-in class dentro de Python). Esto generará los métodos y atributos predefinidos en todas las clases:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Ejemplo1:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Ejemplo2():\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Ejemplo3(object):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esto se puede verificar por medio del método **issubclass()**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(issubclass(Ejemplo1,object))\n",
    "print(issubclass(Ejemplo2,object))\n",
    "print(issubclass(Ejemplo3,object))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "--------------------------------------------------------------------------------------------------------------------------\n",
    "            class Ejemplo:    \"es lo mismo que\"    class Ejemplo():    \"es lo mismo que\"    class Ejemplo(object):\n",
    "            \n",
    "--------------------------------------------------------------------------------------------------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejemplo de herencia sencilla:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Super clase\n",
    "class Superior:\n",
    "    x=3\n",
    "    y=0\n",
    "    \n",
    "#Sub clase\n",
    "class Inferior(Superior):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "ejemplo=Inferior()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# El objeto instanciado de la clase Inferior recíbe de forma automática los atributos de la clase Superior\n",
    "ejemplo.x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejercicio\n",
    "\n",
    "1. Crea una clase llamada **\"Vehículo\"** donde tenga un atributo **color**=\"rojo\" y **campeonato**=\"Copa pistón\"\n",
    "2. Crea una clase que se llame **\"Rayo\"** que herede de **\"Vehículo\"**\n",
    "3. Crea una instancia de **Rayo** e invoca uno de los atributos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Copa Pistón'"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Vehiculo:\n",
    "    color=\"Rojo\"\n",
    "    campeonato=\"Copa Pistón\"\n",
    "class Rayo(Vehiculo):\n",
    "    pass\n",
    "rayito=Rayo()\n",
    "rayito.campeonato"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nota para usar el método super():"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Al heredar métodos, el método **super()** nos sirve para inicializar el método de la clase superior. La sintaxis de **super()**:\n",
    "\n",
    "-------------------------------------------------------------------------------------------------------------------------\n",
    "\n",
    "                                       super().metodo a heredar([args])\n",
    "                  \n",
    "-------------------------------------------------------------------------------------------------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ¿Puedes explicar que va a ocurrir al crear una instancia de la claseC?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ClaseA:\n",
    "    def __init__(self):\n",
    "        print('Iniciando: clase A')\n",
    "\n",
    "    def sub_method(self, x):\n",
    "        print('Imprimiendo de clase A:', x)\n",
    "\n",
    "\n",
    "class ClaseB(ClaseA):\n",
    "    def __init__(self):\n",
    "        print('Iniciando: clase B')\n",
    "        super().__init__()\n",
    "\n",
    "    def sub_method(self, x):\n",
    "        print('Imprimiendo de clase B:', x)\n",
    "        super().sub_method(x + 1)\n",
    "\n",
    "\n",
    "class ClaseC(ClaseB):\n",
    "    def __init__(self):\n",
    "        print('Iniciando: clase C')\n",
    "        super().__init__()\n",
    "\n",
    "    def sub_method(self, x):\n",
    "        print('Imprimiendo de clase C:', x)\n",
    "        super().sub_method(x + 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <img src=\"img/dudaperro.jpg\" alt=\"Python\" width=150 hight=70 align=\"center\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iniciando: clase C\n",
      "Iniciando: clase B\n",
      "Iniciando: clase A\n",
      "Imprimiendo de clase C: 1\n",
      "Imprimiendo de clase B: 2\n",
      "Imprimiendo de clase A: 3\n"
     ]
    }
   ],
   "source": [
    "if __name__ == '__main__': #Linea de sintaxis para ocultar las pruebas en los módulos\n",
    "    objc = ClaseC()\n",
    "    objc.sub_method(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"section135\"></a> \n",
    "## Herencia de clase con constructor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el siguiente ejemplo, la subclase no tiene atributos nuevos, por lo que la sintaxis de herencia es muy similar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Herencia sencilla, todos los métodos y atributos pasan de forma automática.\n",
    "class Alumno(Persona):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "estudiante_ing=Alumno(\"Edgar\", \"Avalos\", 32, \"M\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'M'"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "estudiante_ing.sexo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Herencia por medio de constructor, los atributos de la clase superior se vuelven visibles a la clase inferior\n",
    "# solamente si se ejecuta el constructor superior.\n",
    "\n",
    "class Alumno(Persona):\n",
    "    def __init__(self, nombre_persona, apellido_persona, edad_persona,sexo):\n",
    "        super().__init__(nombre_persona, apellido_persona, edad_persona,sexo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [],
   "source": [
    "estudiante_ing=Alumno(\"Edgar\", \"Avalos\", 32,\"M\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El método **delattr()** se utiliza para eliminar el atributo nombrado del objeto, con el permiso previo del objeto.\n",
    "\n",
    "**Sintaxis:**\n",
    "\n",
    "**delattr (objeto, nombre)**\n",
    "\n",
    "La función toma solo dos parámetros:\n",
    "\n",
    "**objeto**: del cual se eliminará el atributo de nombre.\n",
    "<br>\n",
    "**nombre**: del atributo que se va a eliminar.\n",
    "\n",
    "La función no devuelve ningún valor, solo elimina el atributo, solo si el objeto lo permite. Hay otro operador en Python que realiza un trabajo similar al del método delattr (), es el operador **del**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "delattr(estudiante_ing,\"sexo\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'nombre': 'Edgar', 'edad': 32, 'apellido': 'Avalos'}"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vars(estudiante_ing)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cuando la subclase contiene su propio constructor, entonces la estructura es diferente:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ¿Cómo definir que atributos deben estar en mis superclases?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Supongamos que realizamos una clase para representar 3 productos que se venden en una tienda, adornos, alimentos y libros. Si consideramos los atributos mas representativos de cada uno de los productos, tendriamos una clase como la siguiente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'referencia': '000A',\n",
       " 'tipo': 'ADORNO',\n",
       " 'nombre': 'Vaso Adornado',\n",
       " 'precio': 15,\n",
       " 'descripcion': 'Vaso de porcelana con dibujos',\n",
       " 'productor': 'Garigolitos',\n",
       " 'distribuidor': None,\n",
       " 'isbn': None,\n",
       " 'autor': None}"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Producto:\n",
    "    def __init__(self, referencia, tipo, nombre, \n",
    "                 precio,  descripcion, productor=None, \n",
    "                 distribuidor=None, isbn=None, autor=None):\n",
    "        ###################################################\n",
    "        #     Aquellos atributos que no son compartidos,  #\n",
    "        #     se les asigna un valor de None dentro del   #\n",
    "        #  constructor, con el fin de hacerlos opcionales #\n",
    "        ###################################################\n",
    "        self.referencia = referencia\n",
    "        self.tipo = tipo\n",
    "        self.nombre = nombre\n",
    "        self.precio = precio\n",
    "        self.descripcion = descripcion\n",
    "        self.productor = productor\n",
    "        self.distribuidor = distribuidor\n",
    "        self.isbn = isbn\n",
    "        self.autor = autor\n",
    "\n",
    "\n",
    "adorno = Producto('000A','ADORNO','Vaso Adornado',15,\n",
    "                  'Vaso de porcelana con dibujos', productor=\"Garigolitos\") \n",
    "\n",
    "vars(adorno)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Producto:\n",
    "    def __init__(self,referencia,nombre,precio,descripcion):\n",
    "        self.referencia = referencia\n",
    "        self.nombre = nombre\n",
    "        self.precio = precio\n",
    "        self.descripcion = descripcion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'referencia': 2034,\n",
       " 'nombre': 'Vaso adornado',\n",
       " 'precio': 15,\n",
       " 'descripcion': 'Vaso de porcelana'}"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Adorno(Producto):\n",
    "    pass\n",
    "\n",
    "adorno = Adorno(2034, \"Vaso adornado\", 15, \"Vaso de porcelana\")\n",
    "vars(adorno)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Alimento(Producto):\n",
    "    def __init__(self, referencia, nombre, \n",
    "                 precio, descripcion, productor, distribuidor):\n",
    "        self.productor = productor\n",
    "        self.distribuidor = distribuidor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'productor': 'La Aceitera', 'distribuidor': 'Distribuciones SA'}"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alimento = Alimento(2035, \"Botella de Aceite de Oliva\", 5, \"250 ML\", \"La Aceitera\", \"Distribuciones SA\")\n",
    "vars(alimento)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para que las variables de la clase superior puedan ser funcionales en la subclase, es necesario llamarlas por medio del método **super()**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Alimento(Producto):\n",
    "    def __init__(self, referencia, nombre, \n",
    "                 precio, descripcion, productor, distribuidor):\n",
    "        \n",
    "        super().__init__(referencia, nombre, precio,  descripcion)\n",
    "        \n",
    "        self.productor = productor\n",
    "        self.distribuidor = distribuidor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'referencia': 2035,\n",
       " 'nombre': 'Botella de Aceite de Oliva',\n",
       " 'precio': 5,\n",
       " 'descripcion': '250 ML',\n",
       " 'productor': 'La Aceitera',\n",
       " 'distribuidor': 'Distribuciones SA'}"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alimento = Alimento(2035, \"Botella de Aceite de Oliva\", 5, \"250 ML\", \"La Aceitera\", \"Distribuciones SA\")\n",
    "vars(alimento)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Libro(Producto):\n",
    "    def __init__(self, referencia, nombre, \n",
    "                 precio,  descripcion, isbn, autor):\n",
    "        super().__init__(referencia, nombre, precio,  descripcion)\n",
    "        self.isbn = isbn\n",
    "        self.autor = autor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [],
   "source": [
    "libro = Libro(2036, \"Cocina Mediterránea\",9, \"Recetas sanas y buenas\", \"0-123456-78-9\", \"Doña Juana\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'referencia': 2036,\n",
       " 'nombre': 'Cocina Mediterránea',\n",
       " 'precio': 9,\n",
       " 'descripcion': 'Recetas sanas y buenas',\n",
       " 'isbn': '0-123456-78-9',\n",
       " 'autor': 'Doña Juana'}"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vars(libro)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejemplo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se crea una clase Persona, la cual tendra dos actividades, trabajar o estudiar. Dependiendo la actividad que se seleccione, entonces la variable **status** se actualizará para indicar la nueva situación de la persona."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Persona:\n",
    "    def __init__(self, nombre_persona, apellido_persona, edad_persona):\n",
    "        self.nombre_persona=nombre_persona\n",
    "        self.apellido_persona=apellido_persona\n",
    "        self.edad_persona=edad_persona\n",
    "        self.status=\"NiNi\"\n",
    "    def estudiar(self):\n",
    "        print(\"hola, mi nombre es \" + self.nombre_persona + \" y soy un estudiante\")\n",
    "        self.status=\"Estudiante\"\n",
    "    def trabajar(self):\n",
    "        print(\"hola, mi nombre es \" + self.nombre_persona + \" y estoy trabajando\")\n",
    "        self.status=\"Trabajar\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class Persona in module __main__:\n",
      "\n",
      "class Persona(builtins.object)\n",
      " |  Persona(nombre_persona, apellido_persona, edad_persona)\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __init__(self, nombre_persona, apellido_persona, edad_persona)\n",
      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
      " |  \n",
      " |  estudiar(self)\n",
      " |  \n",
      " |  trabajar(self)\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": [
    "help(Persona)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [],
   "source": [
    "individuo1=Persona(\"Tony\", \"Parker\", 37)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'NiNi'"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "individuo1.status"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hola, mi nombre es Tony y soy un estudiante\n"
     ]
    }
   ],
   "source": [
    "individuo1.estudiar()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Estudiante'"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "individuo1.status"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creamos una subclase de Persona, la cual solamente agrupará a los deportistas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "dxh3d182cQLB"
   },
   "outputs": [],
   "source": [
    "class Deportista(Persona):\n",
    "\n",
    "    def __init__(self, nombre_persona, apellido_persona, edad_persona, jersey):\n",
    "        self.jersey=jersey\n",
    "        self.liga = []\n",
    "    \n",
    "    def jugar(self, categoria):\n",
    "        '''Añade elementos a la lista de ligas.'''\n",
    "        self.liga.append(categoria)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "iMafT8Fjs1YK"
   },
   "outputs": [],
   "source": [
    "jugador1 = Deportista(\"Kobe\", \"Bryant\",41, \"LA-24\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Deportista' object has no attribute 'nombre_persona'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-150-b062cd746688>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mjugador1\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnombre_persona\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mjugador1\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mapellido_persona\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: 'Deportista' object has no attribute 'nombre_persona'"
     ]
    }
   ],
   "source": [
    "#print (jugador1.nombre_persona, jugador1.apellido_persona)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'jersey': 'LA-24', 'liga': []}"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vars(jugador1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por tratarse de una clase con métodos, la herencia forzosamente debe llevar el método **super()**. Al no hacerlo, los atributos de la clase superior no pueden ser accesados por el objeto instanciado:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Deportista(Persona):\n",
    "\n",
    "    def __init__(self, nombre_persona, apellido_persona, edad_persona, jersey):\n",
    "        super().__init__(nombre_persona, apellido_persona, edad_persona)\n",
    "        \"\"\"Solamente se indica la nueva variable\n",
    "        El resto de variables se definio en Persona\"\"\"\n",
    "        self.jersey=jersey\n",
    "        self.liga = []\n",
    "    \n",
    "    def jugar(self, categoria):\n",
    "        '''Añade elementos a la lista de ligas.'''\n",
    "        self.liga.append(categoria)\n",
    "        super().trabajar()\n",
    "        print(self.status,\"Jersey: \",self.jersey)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [],
   "source": [
    "jugador1 = Deportista(\"Kobe\", \"Bryant\",41, \"LA-24\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'nombre_persona': 'Kobe', 'apellido_persona': 'Bryant', 'edad_persona': 41, 'status': 'NiNi', 'jersey': 'LA-24', 'liga': []}\n"
     ]
    }
   ],
   "source": [
    "print(vars(jugador1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "jfj7vCSBuMZT"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kobe Bryant\n"
     ]
    }
   ],
   "source": [
    "print (jugador1.nombre_persona, jugador1.apellido_persona)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "9PbflsdJ78jJ"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hola, mi nombre es Kobe y estoy trabajando\n",
      "Trabajar Jersey:  LA-24\n"
     ]
    }
   ],
   "source": [
    "jugador1.jugar(\"NCAA\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "BQRLg0Am8pHx"
   },
   "outputs": [],
   "source": [
    "jugador1.liga"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "jugador1.status"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creamos una nueva clase, la cual al considerar que el jugador ha participado en mas de 3 ligas, entonces su status debe ser el de retirado:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Leyenda(Persona):\n",
    "\n",
    "    def __init__(self, nombre_persona, apellido_persona, edad_persona, jersey, sexo, grado):\n",
    "        super().__init__(nombre_persona, apellido_persona, edad_persona)\n",
    "        \"\"\"Solamente se indica la nueva variable\n",
    "        El resto de variables se definio en Persona\"\"\"\n",
    "        self.jersey=jersey\n",
    "        self.sexo=sexo\n",
    "        self.grado=grado\n",
    "        self.liga = []\n",
    "    \n",
    "    def jugar(self, categoria):\n",
    "        '''Añade elementos a lista de ligas.'''\n",
    "        self.liga.append(categoria)\n",
    "        if len(categoria)>2:\n",
    "            self.status=\"Retirado\"\n",
    "            print(self.status)\n",
    "        else:\n",
    "            self.status=\"Jugador\"\n",
    "            print(self.status,\"Jersey: \",self.jersey)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Su majestad'"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "leyenda1=Leyenda(\"Michael\", \"Jordan\", 56, \"Bulls-23\", \"M\", \"Su majestad\")\n",
    "leyenda1.grado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [],
   "source": [
    "ligas=[\"NCAA\", \"NBA\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jugador Jersey:  Bulls-23\n"
     ]
    }
   ],
   "source": [
    "leyenda1.jugar(ligas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Retirado\n"
     ]
    }
   ],
   "source": [
    "ligas=[\"NCAA\", \"NBA\", \"MLB\", \"NBA\"]\n",
    "leyenda1.jugar(ligas)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Recordatorio de los métodos isinstance() y issubclass()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(leyenda1, Leyenda)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "issubclass(Leyenda, Persona)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ejercicio"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Desarrolla 3 subclases similares a las mostradas en la imagen:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <img src=\"img/futbol1.png\" alt=\"Python\" width=600 hight=400 align=\"center\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una forma sencilla de invocar los métodos de una clase superior, es mediante el método **super()**. Al momento de utilizarlo y escribir \".\" , Python te indicará que métodos puedes sobrecargar."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Otro ejemplo de herencia"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Clase para determinar el cuadrante en el que cae un punto en el plano cartesiano"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Punto:\n",
    "    def cuadrante(self,x,y):\n",
    "        if x>0 and y>0:\n",
    "            print(\"Cuadrante I\")\n",
    "        elif x<0 and y>0:\n",
    "            print(\"Cuadrante II\")\n",
    "        elif x<0 and y<0:\n",
    "            print(\"Cuadrante III\")\n",
    "        elif x>0 and y<0:\n",
    "            print(\"Cuadrante IV\")\n",
    "        elif x!=0 and y==0:\n",
    "            print(\"Eje X\")\n",
    "        elif x==0 and y!=0:\n",
    "            print(\"Eje Y\")\n",
    "        else:\n",
    "            print(\"Origen\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Eje X\n"
     ]
    }
   ],
   "source": [
    "obj_punto=Punto()\n",
    "obj_punto.cuadrante(-6,0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Clase para determinar la magnitud, dirección y sentido de un vector, la cual hereda de la clase punto, el método para determinar el cuadrante:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Herencia\n",
    "class Vector2(Punto):\n",
    "    def __init__(self,x,y):\n",
    "        self.x=x\n",
    "        self.y=y\n",
    "        \n",
    "        '''Utilizamos el método super() para asignar los atribuos \n",
    "        al método heredado de la clase superior'''\n",
    "        \n",
    "        super().cuadrante(self.x,self.y) \n",
    "    def calculos(self):\n",
    "        d = math.sqrt( (self.x)**2 + (self.y)**2 )\n",
    "        d=round(d,3)\n",
    "        angulo=round(math.degrees(math.atan(abs(self.y/self.x))),3)\n",
    "        print(\"Su magnitud es de: \" + str(d))\n",
    "        print(\"Su ángulo es de: \" + str(angulo) + \"°\")\n",
    "        \n",
    "        '''Método heredado en ejecución'''\n",
    "        \n",
    "        self.cuadrante(self.x,self.y) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cuadrante I\n",
      "Su magnitud es de: 7.616\n",
      "Su ángulo es de: 66.801°\n",
      "Cuadrante I\n"
     ]
    }
   ],
   "source": [
    "obj_Vector2=Vector2(float(i),float(j))\n",
    "obj_Vector2.calculos()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejercicios"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Crear una clase que se llame \"Peliculas\" que contenga los siguientes métodos y atributos:\n",
    "    * Nombre\n",
    "    * Duración\n",
    "    * Idioma\n",
    "    * Año\n",
    "    * IniciarPelicula\n",
    "    * PausarPelicula\n",
    "2. Crear 3 clases de genero de película que mas te gusten, y que hereden de \"Peliculas\" todos sus atributos y métodos.\n",
    "3. Asignar 1 atributo y 1 método diferente a cada una de las subclases.\n",
    "4. Crear dos instancias de cada una de las subclases.\n",
    "5. Escribir el código completo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Peliculas():\n",
    "    def __init__(self, nombre, duracion, idioma, anyo):\n",
    "        self.nombre=nombre\n",
    "        self.duracion=duracion\n",
    "        self.idioma=idioma\n",
    "        self.anyo=anyo\n",
    "    def IniciarPelicula(self, play):\n",
    "        if play==True:\n",
    "            print(\"La película \" + self.nombre + \" ha iniciado\")\n",
    "        else:\n",
    "            print(\"La pelicula no se ha iniciado\")\n",
    "    def PausarPelicular(self, pausa):\n",
    "        if pausa==True:\n",
    "            print(\"La película \" + self.nombre + \" se ha pausado\")\n",
    "        else:\n",
    "            print(\"La trama prosigue\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Comedia(Peliculas):\n",
    "    def __init__(self, nombre, duracion, idioma, anyo, pais):\n",
    "        Peliculas.__init__(self, nombre, duracion, idioma, anyo)\n",
    "        self.pais=pais\n",
    "    def agregarsubtitulos(subbed):\n",
    "        if subbed==True:\n",
    "            print(\"La película \" + self.nombre + \" tiene subtitulos\")\n",
    "        else:\n",
    "            print(\"La película \" + self.nombre + \" está en su idioma orignal\")\n",
    "    def quitarsubtitulos(quitar):\n",
    "        if quitar==True:\n",
    "            print(\"La película \" + self.nombre + \" ya no tiene subtitulos\")\n",
    "        else:\n",
    "            print(\"Disfruta la película \" + self.nombre + \" con subtitulos\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [],
   "source": [
    "pelicula1=Comedia(\"Scary Movie\", \"90 min\", \"Ingles\", 2000, \"EUA\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La película Scary Movie ha iniciado\n"
     ]
    }
   ],
   "source": [
    "pelicula1.IniciarPelicula(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La película Scary Movie se ha pausado\n"
     ]
    }
   ],
   "source": [
    "pelicula1.PausarPelicular(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2000"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pelicula1.anyo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Q8fl-ex0cQLC"
   },
   "source": [
    "<a id=\"section136\"></a> \n",
    "### Polimorfismo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "aA2Wad41cQLD"
   },
   "source": [
    "La palabra polimorfismo viene del griego **poli** que significa muchas y morfismo que significa formas, es decir, muchas formas. El polimorfismo en Python es la capacidad que tienen los objetos de diferentes clases para usar un comportamiento o atributo del mismo nombre pero con diferente valor. Em resumen, polimorfismo es la capacidad de una entidad de referenciar en tiempo de ejecución a instancias de diferentes clases.\n",
    "\n",
    "Hace referencia a la llamada de una **función (Método)** de una clase por parte de un objeto. Cuando se produce, se ejecuta la correspondiente al tipo del objeto que lo llama, no al de sus progenitores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "1o38ymkicQLE"
   },
   "outputs": [],
   "source": [
    "# Creamos 3 clases con un método con el mismo nombre, pero generando comportamientos diferentes:\n",
    "\n",
    "class Coche():\n",
    "    def desplazamiento(self):\n",
    "        print (\"Me desplazo en cuatro ruedas\")\n",
    "\n",
    "class Moto():\n",
    "    def desplazamiento(self):\n",
    "        print (\"Me desplazo en dos ruedas\")\n",
    "\n",
    "class Camion():\n",
    "    def desplazamiento(self):\n",
    "        print (\"Me desplazo en seis ruedas\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Me desplazo en cuatro ruedas\n"
     ]
    }
   ],
   "source": [
    "miVehiculo1=Coche()\n",
    "miVehiculo1.desplazamiento()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Me desplazo en dos ruedas\n"
     ]
    }
   ],
   "source": [
    "miVehiculo2=Moto()\n",
    "miVehiculo2.desplazamiento()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Me desplazo en seis ruedas\n"
     ]
    }
   ],
   "source": [
    "miVehiculo3=Camion()\n",
    "miVehiculo3.desplazamiento()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [],
   "source": [
    "def desplazamientoVehiculo(object):\n",
    "    object.desplazamiento()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Me desplazo en cuatro ruedas\n"
     ]
    }
   ],
   "source": [
    "desplazamientoVehiculo(miVehiculo1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Me desplazo en dos ruedas\n"
     ]
    }
   ],
   "source": [
    "desplazamientoVehiculo(miVehiculo2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Me desplazo en cuatro ruedas\n",
      "Me desplazo en dos ruedas\n",
      "Me desplazo en seis ruedas\n"
     ]
    }
   ],
   "source": [
    "vehiculos=[miVehiculo1, miVehiculo2, miVehiculo3]\n",
    "for x in vehiculos:\n",
    "    desplazamientoVehiculo(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Me desplazo en cuatro ruedas\n"
     ]
    }
   ],
   "source": [
    "vehiculos[0].desplazamiento()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "mnt2TT2UcQLN"
   },
   "source": [
    "<a id=\"section137\"></a> \n",
    "## Encapsulamiento"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "l1MCrdYWeBpb"
   },
   "source": [
    "La encapsulación es una forma de darle uso exclusivo a los comportamientos o atributos que posee una clase, es decir, protege esos atributos y comportamientos para que no sean usados de manera externa. Significa que los datos pertenecen a un objeto (espacio de nombres del objeto).\n",
    "\n",
    "Podemos ir más allá y ocultar los datos de un objeto a cualquier otro objeto o código que trate de hacer uso de ellos. Serían sólo accesibles al propio objeto y, en algunos casos, a objetos de sus clases descendientes.”"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <img src=\"img/encapsulamiento.png\" alt=\"Python\" width=470 hight=260 align=\"center\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "dy9rnMvEcQLO"
   },
   "source": [
    "Significa que los datos pertenecen a un objeto (espacio de nombres del objeto). – Podemos ir más allá y ocultar los datos de un objeto a cualquier otro objeto o código que trate de hacer uso de ellos. Serían sólo accesibles al propio objeto y, en algunos casos, a objetos de sus clases descendientes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ljEj0ZcPeBpd"
   },
   "source": [
    "### Modificadores de acceso en C#\n",
    "\n",
    "| Accesibilidad      |                                  Significado                                                      |\n",
    "|:-------------------|:--------------------------------------------------------------------------------------------------|\n",
    "| Public             | El acceso no está restringido                                                                     |\n",
    "| Protected          | El acceso está limitado a la clase que lo contiene y a las clases derivadas                       |\n",
    "| Internal           | El acceso está limitado al ensamble actual                                                        |\n",
    "| Protected internal | El acceso está limitado al ensamble actual o tipos derivados de la clase contenedora              |\n",
    "| Private            | El acceso es limitado al tipo que lo contenga                                                     |\n",
    "| Private protected* | El acceso es limitado a la clase o tipos derivados de la clase contenedora en el ensamble actual* |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "cJOCgrGyeBpe"
   },
   "source": [
    "**. *Disponible desde C# 7.2**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "2_zSvlZVeBpe"
   },
   "source": [
    "Es así que en otros lenguajes de programación los atributos y métodos pueden ser restingidos definiéndolos como públicos, privados, protegidos, etc. No existen atributos privados o protegidos en Python, pero se puede ofuscar el acceso a un atributo mediante **\"name mangling\"**.\n",
    "\n",
    "El name mangling se realiza anteponiendo dobles guiones bajos (__) antes del nombre del atributo a esconder:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "buBhF_USeBpe"
   },
   "outputs": [],
   "source": [
    "class CajaDeSeguridad:\n",
    "    \"\"\"Clase que incluye un atributo \"escondido.\"\"\"\n",
    "    __contraclave = \"123qwe\" #Atributo escondido\n",
    "    \n",
    "    def seguro(self, clave):\n",
    "        if self.__contraclave == clave:\n",
    "            print(\"Acceso concedido.\")\n",
    "        else:\n",
    "            print(\"Acceso denegado.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "HT67f6B6eBpg"
   },
   "outputs": [],
   "source": [
    "caja = CajaDeSeguridad() #Instanciando CajaDeSeguridad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "W-6sEq9DeBpj"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Acceso denegado.\n"
     ]
    }
   ],
   "source": [
    "caja.seguro(\"Hola\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "fjPiDEaleBpp"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Acceso concedido.\n"
     ]
    }
   ],
   "source": [
    "caja.seguro(\"123qwe\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "YJA3OvAJeBpq"
   },
   "outputs": [],
   "source": [
    "#caja.__contraclave"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "yX5r2m_KeBps"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['_CajaDeSeguridad__contraclave', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'seguro']\n"
     ]
    }
   ],
   "source": [
    "print(dir(CajaDeSeguridad))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "D2EUrB6keBpt"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['_CajaDeSeguridad__contraclave', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'seguro']\n"
     ]
    }
   ],
   "source": [
    "print(dir(caja))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "IU50SpaYeBpu"
   },
   "source": [
    "Para acceder a un atributo escondido fuera del objeto es necesario utilizar la siguiente sintaxis:\n",
    "\n",
    "\n",
    "                                 objeto._nombre de la clase.__nombre atributo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "9zKglFUkeBpw"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'123qwe'"
      ]
     },
     "execution_count": 191,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "caja._CajaDeSeguridad__contraclave"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "mhqtJ64fcQLQ"
   },
   "source": [
    "<a id=\"section14\"></a> \n",
    "# <font color=\"#004D7F\"> 3.5 Modificadores de acceso: private, public</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "UIU_KtZPcQLR"
   },
   "source": [
    "En Python, a diferencia de otros lenguajes, solamente considera 3 tipos de modificadores de acceso: **public, private, protected.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "FyUztZpmcQLS"
   },
   "source": [
    "### <img src=\"img/proteccion.png\" alt=\"Python\" width=450 hight=240 align=\"center\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Las variables **public** pueden ser accesadas en cualquier parte, fuera y dentro de la clase.\n",
    "* Las variables **private** pueden ser accesadas únicamente dentro de la clase.\n",
    "* Las variables **protected** pueden ser accesadas dentro del mismo paquete."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veamos como funcionan los diferentes modificadores de acceso en Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Carro:\n",
    "    def __init__(self):\n",
    "        print (\"Arranca motor\")\n",
    "        nombre = \"\"\n",
    "        __fabricante = \"Wolkswagen\"\n",
    "        _modelo = 2016"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En la clase anterior, mediante el uso del constructor se generaron 3 diferentes variables: *nombre*, *fabricante*, *modelo*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| variable | tipo de modificador |\n",
    "|----------|---------------------|\n",
    "| nombre   | public|\n",
    "| fabricante | private|\n",
    "| modelo     | protected|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Arranca motor\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 205,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "carro1=Carro()\n",
    "vars(carro1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [],
   "source": [
    "carro1.nombre=\"Rayo McQueen\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rayo McQueen\n"
     ]
    }
   ],
   "source": [
    "print(carro1.nombre)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'nombre': 'Rayo McQueen'}"
      ]
     },
     "execution_count": 208,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vars(carro1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las variables de tipo **protected** en Python, son posibles de accesar desde fuera de clase, e incluso de modificar. La indicación del guión bajo es solamente para apelar al buen juicio del programador o usuario y que no modifique dichas variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print(carro1._modelo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2019\n"
     ]
    }
   ],
   "source": [
    "carro1._modelo=2019   #En la medida de lo posible, hay que respetar las variables protected\n",
    "print(carro1._modelo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En Python, solamente las variables de tipo **private** no son posibles de acceder para el usuario de manera externa de la clase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print(carro1.__fabricante)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "mGMhYdyVcQLU"
   },
   "source": [
    "<a id=\"section141\"></a>\n",
    "## Funciones que accedan a las propiedades"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### *hasattr()*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perimite saber si dentro de una clase u objeto cuyo nombre es ingresado como primer argumento contiene un atributo con el nombre ingresado como segundo argumento en forma de string. Regresa True en caso de que exista y False en caso contrario."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 213,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hasattr(carro1,\"__fabricante\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 214,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hasattr(carro1,\"_modelo\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 215,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hasattr(carro1,\"nombre\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "pen0V_BHcQLU"
   },
   "source": [
    "### *getattr()*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Regresa el contenido del atributo de una clase u objeto. El primer argumento corresponde al nombre del objeto, y el segundo al nombre del atributo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Rayo McQueen'"
      ]
     },
     "execution_count": 216,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "getattr(carro1,\"nombre\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2019"
      ]
     },
     "execution_count": 217,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "getattr(carro1,\"_modelo\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {},
   "outputs": [],
   "source": [
    "#getattr(carro1,\"__fabricante\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "L6i_tQxKcQLV"
   },
   "source": [
    "### *setattr()*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esta función sirve para añadir un nuevo atributo, o para modificar uno ya existente. Para ello es necesario indicar el nombre del objeto, el nombre del atributo (en formato string) y el valor de asignación."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Tronco-móvil'"
      ]
     },
     "execution_count": 219,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "setattr(carro1,\"nombre\", \"Tronco-móvil\")\n",
    "getattr(carro1,\"nombre\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'65000 AC'"
      ]
     },
     "execution_count": 220,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "setattr(carro1,\"_modelo\", \"65000 AC\")\n",
    "getattr(carro1,\"_modelo\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Carro' object has no attribute '_Carro__fabricante'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-221-1e0e541c496f>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# Un atributo private, no se puede modificar:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0msetattr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcarro1\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m\"__fabricante\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"Ford\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mcarro1\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_Carro__fabricante\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: 'Carro' object has no attribute '_Carro__fabricante'"
     ]
    }
   ],
   "source": [
    "# Un atributo private, no se puede modificar:\n",
    "setattr(carro1,\"__fabricante\", \"Ford\")\n",
    "carro1._Carro__fabricante"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 222,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hasattr(carro1,\"color\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'cafe'"
      ]
     },
     "execution_count": 223,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "setattr(carro1,\"color\", \"cafe\")\n",
    "getattr(carro1,\"color\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 224,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hasattr(carro1,\"color\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### *delattr()*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Elimina el atributo de una clase u objeto cuyo nombre es ingresado como string en el segundo argumento."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {},
   "outputs": [],
   "source": [
    "delattr(carro1,\"color\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 226,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hasattr(carro1,\"color\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "PzJA8rUYcQLX"
   },
   "source": [
    "<a id=\"section15\"></a> \n",
    "# <font color=\"#004D7F\"> 3.6 Constructor</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "8Az_P-vocQLX"
   },
   "source": [
    "Un \"constructor\" es un método especial que se ejecuta en el momento que se crea un objeto de la clase (new).  Su misión es reservar memoria e inicializar las variables miembros de la clase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Carro:\n",
    "\n",
    "    # create class attributes\n",
    "    carro_count = 0\n",
    "\n",
    "    # create class methods\n",
    "    def __init__(self):\n",
    "        Carro.carro_count +=1\n",
    "        print(Carro.carro_count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "carro_a = Carro()\n",
    "carro_b = Carro()\n",
    "carro_c = Carro()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "carro_d=Carro()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "fg1odT8yeBp5"
   },
   "outputs": [],
   "source": [
    "class Calculadora ():\n",
    "    def __init__ (self, operando1, operando2):\n",
    "        self.op1=operando1\n",
    "        self.op2=operando2\n",
    "    def sumar (self):\n",
    "        return self.op1+self.op2\n",
    "    def restar (self):\n",
    "        return self.op1-self.op2\n",
    "    def multiplicar (self):\n",
    "        return self.op1*self.op2\n",
    "    def dividir (self):\n",
    "        return self.op1/self.op2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "rzFWwtRVeBp6"
   },
   "outputs": [],
   "source": [
    "o=Calculadora(10,2) #Creando objeto con atributos 10 y 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "TGJrrLt7eBp7"
   },
   "outputs": [],
   "source": [
    "o.sumar()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "HhyVAqV5eBp_"
   },
   "outputs": [],
   "source": [
    "o.restar()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "6P-m9L0TeBqB"
   },
   "outputs": [],
   "source": [
    "o.multiplicar()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "fitcKqleeBqC"
   },
   "outputs": [],
   "source": [
    "o.dividir()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"section16\"></a> \n",
    "# <font color=\"#004D7F\"> 3.7 Destructor</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otro atributo especial es **_  __del__  _** Este atributo nos permite crear una acción finalizadora para el objeto al momento de ser eliminado por el método **del**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Persona:\n",
    "    #Clase que representa una Persona\n",
    "    edad = 32\n",
    "    nombre = \"Edgar\"\n",
    "    apellido = \"Avalos\"\n",
    "    sexo = \"M\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Alumno(Persona):\n",
    "   \n",
    "    def __del__(self):\n",
    "        print(\"Adios mundo cruel\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {},
   "outputs": [],
   "source": [
    "Edgar=Persona()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 230,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(Edgar,Persona)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {},
   "outputs": [],
   "source": [
    "# El objeto es eliminado, y al no contar con el atributo __del__, no pasa nada más.\n",
    "del Edgar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#isinstance(Edgar,Persona)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {},
   "outputs": [],
   "source": [
    "Edgar=Alumno()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adios mundo cruel\n"
     ]
    }
   ],
   "source": [
    "# Elimina y activa el atributo especial __del__\n",
    "del Edgar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Edgar=Persona()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Alumno(Persona):\n",
    "   \n",
    "    def __del__(self):\n",
    "        print(\"Adios mundo cruel\")\n",
    "        #######################################\n",
    "        #                                     #\n",
    "        # El siguiente método reinicializa el #\n",
    "        # destructor a su estado original.    #\n",
    "        #                                     #\n",
    "        #######################################\n",
    "        def __del__(self):\n",
    "            pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {},
   "outputs": [],
   "source": [
    "Edgar=Persona()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {},
   "outputs": [],
   "source": [
    "del Edgar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "nqBj_RhpcQLY"
   },
   "source": [
    "<a id=\"section17\"></a> \n",
    "# <font color=\"#004D7F\"> 3.8 Variables y métodos estáticos</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "X7OqjQUpcQLZ"
   },
   "source": [
    "Los **métodos estáticos** dentro de una clase pueden ser llamados sin necesidad de realizar una instancia de la clase. Para poder acceder a ellos, es necesario utilizar el siguiente decorador:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "            @staticmethod"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Por definición, un decorador, es una función A, que trabaja sobre una función B, para devolver una función C.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <img src=\"img/confundido.png\" alt=\"Python\" width=600 hight=400 align=\"center\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La mejor manera de entender esto mediante un ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [],
   "source": [
    "def suma():\n",
    "    print(5+10)\n",
    "\n",
    "def resta():\n",
    "    print(10-5)\n",
    "\n",
    "def mult():\n",
    "    print(5*10)\n",
    "\n",
    "def dividir():\n",
    "    print(10/5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n",
      "5\n",
      "50\n",
      "2.0\n"
     ]
    }
   ],
   "source": [
    "suma()\n",
    "resta()\n",
    "mult()\n",
    "dividir()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora bien, supongamos que quisieramos agregar una nueva funcionalidad a cada una de las funciones descritas, para ello ocuparemos un decorador:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [],
   "source": [
    "def funcion_decoradora(funcion_parametro): #Los identificadores los define el usuario\n",
    "    def funcion_interior():\n",
    "        #Acciones que van a decorar a nuestras funciones.\n",
    "        print(\"Vamos a realizar un cálculo: \")\n",
    "        funcion_parametro()\n",
    "        print(\"Gracias\")\n",
    "    return funcion_interior        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un **decorador** es el nombre de un patrón de diseño. Los decoradores alteran de manera dinámica la funcionalidad de una función, método o clase sin tener que hacer subclases o cambiar el código fuente de la clase decorada. En el sentido de Python un decorador es algo más, incluye el patrón de diseño, pero va más allá, Bruce Eckel los asimila a las macros de Lisp. Los decoradores y su utilización en nuestros programas nos ayudan a hacer nuestro código más limpio, a autodocumentarlo y, a diferencia otros lenguajes, no requieren que nos aprendamos otro lenguaje de programación distinto (cómo pasa con las anotaciones de Java por ejemplo)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def suma():\n",
    "    print(5+10)\n",
    "    \n",
    "def resta():\n",
    "    print(10-5)\n",
    "@funcion_decoradora #La función suma ha sido decorada\n",
    "def mult():\n",
    "    print(5*10)\n",
    "    \n",
    "def dividir():\n",
    "    print(10/5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n",
      "5\n",
      "Vamos a realizar un cálculo: \n",
      "50\n",
      "Gracias\n",
      "2.0\n"
     ]
    }
   ],
   "source": [
    "suma()\n",
    "resta()\n",
    "mult()\n",
    "dividir()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ya que se entendió que es un decorador, y como se usan, veamos la implementación para la creación de métodos estáticos. Un **método estático** es aquel método al que no se va a poder accesar de forma directa desde la clase:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Gato:\n",
    "    def __init__(self,nombre):\n",
    "        self.nombre=nombre\n",
    "    def maullar(self):\n",
    "        print(\"Miau\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Gato.maullar()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gato_1=Gato(\"Bigotes\")\n",
    "gato_1.maullar()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Gato:\n",
    "    def __init__(self,nombre):\n",
    "        self.nombre=nombre\n",
    "    @staticmethod    \n",
    "    def maullar():\n",
    "        print(\"Miau\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Gato.maullar()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los métodos estáticos están restringidos en su ámbito, de tal manera que no tienen acceso a los atributos del objeto. Se definen de forma idéntica a una función, sin necesidad de ingresar el parámetro inicial self."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Práctica"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    Como ejercicio final de la unidad, el alumno deberá generar un archivo en spyder, el cual importe 5 módulos con las siguientes características:\n",
    "\n",
    "1. **Introducción**\n",
    "\n",
    "       Módulo correspondiente a los comandos básicos vistos para Python. El alumno hará una selección de los 5 ejemplos de métodos, funciones, sentencias o ciclos que le parescan mas interesantes. \n",
    "\n",
    "2. **Clases, objetos e instancias**\n",
    "\n",
    "       Módulo correspondiente a la sintaxis para generar clases, instancias y objetos. El alumno creará 5 clases, una vacía, una con atributos inicializados, una con constructor, una solo con métodos, y una que contenga métodos y atributos. Posteriormente realizara intancias de cada una de las clases. \n",
    "\n",
    "3. **Herencia**\n",
    "\n",
    "       El alumno realizara 5 ejemplos donde haga uso de la herencia. Necesariamente debe realizar casos de herencia simple, y casos de herencia por medio de constructor con el método super.\n",
    "\n",
    "4. **Polimorfismo**\n",
    "\n",
    "       El alumno investigará y ejemplificará 5 métodos en python que hagan uso del polimorfismo.\n",
    "\n",
    "5. **Encapsulamiento**\n",
    "\n",
    "       El alumno creará 3 clases, la primera solo contendrá variables de tipo private y realizará ejemplos de instancia para verificar que no se pueden accesar. La segunda solo contendrá variables protected y nuevamente realizará pruebas de acceso. La última contendra variables de los 2 tipos junto con sus pruebas de acceso. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los ejemplos de cada uno de los módulos pueden ser similares a los presentados en el curso, mas no idénticos."
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [
    "Q8fl-ex0cQLC",
    "mnt2TT2UcQLN"
   ],
   "name": "Unidad 1.ipynb",
   "provenance": [],
   "version": "0.3.2"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}