14. Programación Orientada a Objetos en Python .ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Programación Orientada a Objetos en Python\n",
    "\n",
    "Es posible representar objetos de la vida real en programación. Esto extiende muchos paradigmas a la hora de programar pensando únicamente en funciones.\n",
    "\n",
    "¡En el mundo real y en python todo lo que existe puede verse como un objeto! Cuando decimos que son objetos decimos que son una colección de atributos o de estados y de comportamientos (funciones). ¡Un objeto en el mundo real puede comunicarse con otros objetos y en python tambien!\n",
    "\n",
    "Las **clases** son una plantilla de atributos y métodos y nos van a permitir definir el comportamiento de los objetos a través de variables que representan estados y métodos que representan comportamientos. Un ejemplo de clase puede ser por ejemplo Aeroplano. \n",
    "\n",
    "Los **Objetos** son instancias de una clase. El Aeroplano con identificación HK-1274 que es un Boeing 787 es un objeto de clase (de tipo) Aeroplano.\n",
    "\n",
    "Para poder modelar objetos del mundo se requiere utilizar **abstracción** mediante la cual se esconden detalles y se muestran solo los que necesitan otras entidades como objetos, clientes u otras aplicaciones para interactuar.\n",
    "\n",
    "![](images/class.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los pilares de la programación orientada a objetos son los siguientes:\n",
    "    \n",
    "- Herencia\n",
    "- Polimorfismo\n",
    "- Encapsulamiento"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Herencia\n",
    "\n",
    "Mediante la herencia, una clase extiende comportamiento de otra y puede cambiar su comportamiento si es necesario.\n",
    "Permite Construir Clases basadas en otras clases y evitar duplicar y repetir código. Esta relación se puede ver como ES UN:\n",
    "\n",
    "\n",
    "![](images/herencia.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Polimorfismo\n",
    "\n",
    "Está estrechamente relacionado con herencia. Cuando una clase hereda de otra el polimorfismo permite a una subclase suplir la superclase.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Encapsulamiento:\n",
    "\n",
    "- Se esconden partes de los datos del resto de la aplicación.\n",
    "- Se limita la habilidad de otras partes del código de acceder estos datos.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para crear la clase aeroplano, se realiza lo siguiente:\n",
    "\n",
    "```class Airplane(<nombre de clase padre si hay>):\n",
    "        definición de método 1\n",
    "        definición de método 2\n",
    "        .\n",
    "        .\n",
    "        .\n",
    "        definición de método n\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Airplane object at 0x000001FEB0C55DA0>\n"
     ]
    }
   ],
   "source": [
    "class Airplane():\n",
    "    pass       #rellena el bloque para evitar errores de sintaxis\n",
    "\n",
    "a = Airplane()\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## El método ```__init__```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para definir una clase y tener órden es necesario definir un constructor. Este método se llama automáticamente cuando el programador crea un objeto."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para definir la clase Airplane se define el método init así:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Airplane():\n",
    "    def __init__(self, speed, placa):\n",
    "        self.speed = speed\n",
    "        self.placa = placa\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "------av1-------\n",
      "5000\n",
      "HK920\n",
      "------av2-------\n",
      "550\n",
      "LJ990\n"
     ]
    }
   ],
   "source": [
    "avion1 = Airplane(5000, 'HK920')\n",
    "print('------av1-------')\n",
    "print(avion1.speed)\n",
    "print(avion1.placa)\n",
    "\n",
    "print('------av2-------')\n",
    "avion2 = Airplane(550, 'LJ990')\n",
    "print(avion2.speed)\n",
    "print(avion2.placa)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A continuación definiremos una clase usuario:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Usuario():\n",
    "    def __init__(self, first_name, last_name):\n",
    "        self.first_name = first_name\n",
    "        self.last_name = last_name\n",
    "        self.full_name = first_name + ' ' + last_name\n",
    "        \n",
    "    def create_mail(self):\n",
    "        return self.first_name.lower() + \".\" +self.last_name.lower()+\"@\"+\"kl.edu.co\"\n",
    "    \n",
    "    def __str__(self):\n",
    "        return ('nombre={} correo={}'.format(self.full_name, self.create_mail()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nombre=Arles Rodriguez correo=arles.rodriguez@kl.edu.co\n"
     ]
    }
   ],
   "source": [
    "a = Usuario('Arles', 'Rodriguez')\n",
    "print(a)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Métodos estándar de clases en python\n",
    "\n",
    "Algunos de los métodos predefinidos que vienen con las clases en python son:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- ```__del__```: Usado para liberar variables de tipo archivo o conexión a bases de datos.\n",
    "- ```__str__```: Retornan una representación en string del objeto.\n",
    "- ```__lt__, __le__, __eq__, __ne__, __gt__ and __ge__```: Utilizados para comparar un objeto con otro\n",
    "- ```__hash__```: Los objetos por defecto tienen un hash utilizado para almacenar dichos objetos en sets o diccionarios.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Definiendo herencia\n",
    "\n",
    "Para definir herencia se maneja la siguiente sintaxis:\n",
    "\n",
    "```class DerivedClassName(BaseClassName):\n",
    "    <statement-1>\n",
    "    .\n",
    "    . .\n",
    "    <statement-N>\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Programador(Usuario):\n",
    "    \n",
    "    def __init__(self, first_name, last_name, language, payment):\n",
    "        super().__init__(first_name, last_name)\n",
    "        self.lang = language\n",
    "        self.payment = payment\n",
    "    \n",
    "    def __str__(self):\n",
    "        return super().__str__() + ' lang=' + self.lang + ' payment =' +  str(self.payment)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nombre=Guido VanRossum correo=guido.vanrossum@kl.edu.co lang=Python payment =1000000.0\n",
      "nombre=James Gosling correo=james.gosling@kl.edu.co lang=Java payment =9000000.0\n",
      "nombre=Dennis Ritchie correo=dennis.ritchie@kl.edu.co lang=C payment =100000000.0\n"
     ]
    }
   ],
   "source": [
    "prog = Programador('Guido', 'VanRossum', 'Python', 1000000.00)\n",
    "prog2 = Programador('James', 'Gosling', 'Java', 9000000.00)\n",
    "prog3 = Programador('Dennis', 'Ritchie', 'C', 100000000.00)\n",
    "\n",
    "listP = [prog, prog2, prog3]\n",
    "\n",
    "for programmer in listP:\n",
    "    print(programmer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Herencia Múltiple\n",
    "\n",
    "Es posible heredar de más de una clase en python.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum is  16\n",
      "After substraction  40\n"
     ]
    }
   ],
   "source": [
    "class A():\n",
    "    def sum1(self,a,b):\n",
    "        c = a+b\n",
    "        return c\n",
    "\n",
    "class B():\n",
    "    def sub1(self,a,b):\n",
    "        c = a-b\n",
    "        return c\n",
    "\n",
    "class C(A,B):\n",
    "    pass\n",
    "\n",
    "c_obj = C()\n",
    "print (\"Sum is \", c_obj.sum1(12,4))\n",
    "print (\"After substraction \",c_obj.sub1(45,5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Anular métodos del padre (override methods)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible sobreescribir un método de la clase padre. Para esto se nombran los métodos de la misma forma tanto en la clase padre como en la clase hija."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'__module__': '__main__', 'sum1': <function B.sum1 at 0x000001FEB1DE07B8>, '__doc__': None}\n",
      "In class B\n",
      "41\n"
     ]
    }
   ],
   "source": [
    "class A():\n",
    "    def sum1(self,a,b):\n",
    "        print (\"In class A\")\n",
    "        c = a+b\n",
    "        return c\n",
    "\n",
    "class B(A):\n",
    "    def sum1(self,a,b):\n",
    "        print (\"In class B\")\n",
    "        c= a*a+b*b\n",
    "        return c\n",
    "\n",
    "b_obj = B()\n",
    "print (B.__dict__)\n",
    "print (b_obj.sum1(4,5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sobrecarga de operadores\n",
    "\n",
    "Es posible sobrecargar algunos métodos como:\n",
    "\n",
    "- ```+```: programando la función __add__\n",
    "- ```<```: programando la función __lt__\n",
    "- ```==```: programando la función __eq__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Programador(Usuario):\n",
    "    \n",
    "    def __init__(self, first_name, last_name, language, payment):\n",
    "        Usuario.__init__(self, first_name, last_name)\n",
    "        self.lang = language\n",
    "        self.payment = payment\n",
    "    \n",
    "    def __str__(self):\n",
    "        return Usuario.__str__(self) + ' lang=' + self.lang + ' payment =' +  str(self.payment)\n",
    "    \n",
    "    def __add__(self, other):\n",
    "        return self.__str__() + ' add ' + other.__str__()\n",
    "    \n",
    "    def __eq__(self, other):\n",
    "        return self.payment == other.payment\n",
    "    \n",
    "    def __lt__(self, other):\n",
    "        return self.payment <= other.payment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nombre=James Gosling correo=james.gosling@kl.edu.co lang=Java payment =9000000.0\n",
      "nombre=Guido VanRossum correo=guido.vanrossum@kl.edu.co lang=Python payment =59000000.0\n",
      "nombre=Dennis Ritchie correo=dennis.ritchie@kl.edu.co lang=C payment =100000000.0\n"
     ]
    }
   ],
   "source": [
    "prog = Programador('Guido', 'VanRossum', 'Python', 59000000.00)\n",
    "prog2 = Programador('James', 'Gosling', 'Java', 9000000.00)\n",
    "prog3 = Programador('Dennis', 'Ritchie', 'C', 100000000.00)\n",
    "\n",
    "listP = [prog, prog2, prog3]\n",
    "\n",
    "listP = sorted(listP)\n",
    "for programmer in listP:\n",
    "    print(programmer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Class method:\n",
    "\n",
    "Es un método enlazado a la clase como tal y no al objeto y no requiere la creación de un objeto de una clase para ser utilizado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adam's age is: 19\n",
      "John's age is: 35\n"
     ]
    }
   ],
   "source": [
    "from datetime import date\n",
    "\n",
    "# random Person\n",
    "class Person:\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "    @classmethod\n",
    "    def fromBirthYear(cls, name, birthYear):\n",
    "        return cls(name, date.today().year - birthYear)\n",
    "\n",
    "    def display(self):\n",
    "        print(self.name + \"'s age is: \" + str(self.age))\n",
    "\n",
    "person = Person('Adam', 19)\n",
    "person.display()\n",
    "\n",
    "person1 = Person.fromBirthYear('John',  1985)\n",
    "person1.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Static method:\n",
    "\n",
    "Pertenece a la clase y no requiere ni el objeto ni la clase como argumentos por lo cual no tiene conocimiento ni de la clase ni del objeto. Se comportan como funciones planas pero se definen dentro del alcance de la clase:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Mathematics:\n",
    "    def __init__(self, z):\n",
    "        self.z = z\n",
    "    \n",
    "    @staticmethod\n",
    "    def addNumbers(x, y):\n",
    "        return x + y "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Mathematics.addNumbers(3,4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables y Métodos privados\n",
    "\n",
    "Como tal python no trae atributos ni métodos privados. Un buen ```hack``` es definirlos con dos ```_``` para que el intérprete renombre dichas variables. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "123\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    def __init__(self):\n",
    "        self.__var = 123\n",
    "    \n",
    "    def get_var(self):\n",
    "        return self.__var\n",
    "\n",
    "a = A()\n",
    "#print(a.__var) #error! \n",
    "print(a.get_var())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Clases abstractas (Abstract Base Class)\n",
    "\n",
    "En python es posible definir un método abstracto, haciendo que una clase no se pueda instanciar (sea abstracta). Un método abstracto es un método que se declara pero no tiene implementación. Las clases abstractas no pueden ser instanciadas y requieren que las subclases provean implementación de los métodos abstractos.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "class AbstractClassExample(ABC):\n",
    " \n",
    "    def __init__(self, value):\n",
    "        self.value = value\n",
    "        ABC.__init__(self)\n",
    "    \n",
    "    @abstractmethod\n",
    "    def do_something(self):\n",
    "        pass\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "Can't instantiate abstract class DoAdd42 with abstract methods do_something",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-125-a0befddd221c>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 6\u001b[1;33m \u001b[0mx\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mDoAdd42\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m4\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: Can't instantiate abstract class DoAdd42 with abstract methods do_something"
     ]
    }
   ],
   "source": [
    "class DoAdd42(AbstractClassExample):\n",
    "    def __init__(self, value):\n",
    "        AbstractClassExample.__init__(self, value)\n",
    "\n",
    "    \n",
    "x = DoAdd42(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "52\n",
      "420\n"
     ]
    }
   ],
   "source": [
    "class DoAdd42(AbstractClassExample):\n",
    "\n",
    "    def do_something(self):\n",
    "        return self.value + 42\n",
    "    \n",
    "class DoMul42(AbstractClassExample):\n",
    "   \n",
    "    def do_something(self):\n",
    "        return self.value * 42\n",
    "    \n",
    "x = DoAdd42(10)\n",
    "y = DoMul42(10)\n",
    "\n",
    "print(x.do_something())\n",
    "print(y.do_something())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ejercicio \n",
    "\n",
    "Dado el siguiente sketch de diagrama de clases:\n",
    "\n",
    "![](images/figuras.png)\n",
    "\n",
    "Vamos a programar por partes esta tabla:\n",
    "\n",
    "<table>\n",
    "    <tr>\n",
    "        <td>Class</td><td>get_area</td><td>get_volume</td><td>get_name</td><td>__str__</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td>Shape</td><td>0.0</td><td>0.0</td><td>abstract</td><td>default</td>\n",
    "    </tr>          \n",
    "    <tr>\n",
    "        <td>Point</td><td>0.0</td><td>0.0</td><td>\"Point\"</td><td>[x ,y]</td>\n",
    "    </tr>   \n",
    "    <tr>\n",
    "        <td>Circle</td><td>$\\pi r^2$</td><td>0.0</td><td>\"Circle\"</td><td>Center = [x ,y]<br>radius=r</td>\n",
    "    </tr>\n",
    "     <tr>\n",
    "         <td>Cylinder</td><td>$2 \\pi r^2 + 2 \\pi r h$</td><td>$\\pi r^2 h$</td><td>\"Cylinder\"</td><td>Center = [x ,y]<br>radius=r<br>height=h</td>\n",
    "    </tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejercicio 1: \n",
    "\n",
    "Programe la clase Shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejercicio 2: \n",
    "\n",
    "Programe la clase Point que herede de Shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejercicio 3:\n",
    "\n",
    "Programe la clase Circle que herede de Point"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejercicio 4:\n",
    "\n",
    "Programe la clase Cylinder que herede de Circle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Asociación\n",
    "\n",
    "Otra relación entre las clases es la de asociación en la que una clase tiene atributos de otra clase:\n",
    "\n",
    "![](images/asociacion.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se puede definir así:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Curso():\n",
    "    \n",
    "    def __init__(self, nombre):\n",
    "        self.nombre = nombre\n",
    "        \n",
    "    def __str__(self):\n",
    "        return 'Curso: ' + self.nombre\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Estudiante:\n",
    "    \n",
    "    def __init__(self, nombre, cod, curso):\n",
    "        self.nombre = nombre\n",
    "        self.cod = cod\n",
    "        self.curso = curso\n",
    "        \n",
    "    def __str__(self):\n",
    "        return \"Estudiante nombre:{} código:{} {}\".format(self.nombre, self.cod, str(self.curso))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estudiante nombre:Guido código:6048383 Curso: Programación en Python\n"
     ]
    }
   ],
   "source": [
    "curso = Curso('Programación en Python')\n",
    "e = Estudiante('Guido', '6048383', curso)\n",
    "\n",
    "print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejercicio 1:\n",
    "\n",
    "Modifique el ejemplo anterior para que el estudiante tenga una lista de cursos y no solamente un curso."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejercicio 2:\n",
    "\n",
    "Programe el siguiente diagrama de clases:\n",
    "\n",
    "![](images/autos.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Referencias:\n",
    "\n",
    "- https://www.pythoncentral.io/introduction-to-python-classes/\n",
    "- https://www.programiz.com/python-programming/methods/built-in/staticmethod\n",
    "- https://www.programiz.com/python-programming/methods/built-in/classmethod\n",
    "- https://www.python-course.eu/python3_abstract_classes.php\n",
    "- Das, B. N. (2017). Learn Python in 7 Days. Packt Publishing Ltd.\n",
    "- https://www.python-course.eu/python3_abstract_classes.php\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}