05.1-oop.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Objetos\n",
    "\n",
    "* Un objeto en Python es una abstracción que:\n",
    "    * Tiene un tipo determinado.\n",
    "    * Contiene una representación interna de cirtos datos.\n",
    "        * a través de los atributos\n",
    "    * Provee una interfaz para interactuar con el objeto.\n",
    "        * a través de los metos\n",
    "* Un objeto, a través de los métodos, definine su comportamiento, pero oculta la implementación.\n",
    "    * Es un método de juntar unos datos y unos métodos.\n",
    "* Un objeto es una instancia de un tipo (o clase).\n",
    "    * `3` es una instancia de `int`\n",
    "    * `\"hola\"` es una instancia de `str`\n",
    "* Podemos saber el tipo de un objeto a través de la función `type()`\n",
    "* Podemos comprobar si un objeto es de un cierto tipo utilizando la funcion `isinstance()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 3\n",
    "print(type(a))\n",
    "\n",
    "b = \"hola\"\n",
    "print(type(b))\n",
    "\n",
    "c = [1, 2, 3]\n",
    "print(type(c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(isinstance(a, int))\n",
    "print(isinstance(a, str))\n",
    "print(isinstance(a, list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Objetos y Clases\n",
    "\n",
    "* Un objeto es una instancia de una clase\n",
    "* Una clase es un nuevo tipo de datos\n",
    "* Para crear una clase en Python se utiliza la keyword `class`:\n",
    "```python\n",
    "class Clase(ClasePadre):\n",
    "    \"\"\"Docstring\"\"\"\n",
    "    statements\n",
    "```\n",
    "* Normalmente, las sentencias dentro de una clase serán las definciones de atributos (variables) y métodos (funciones).\n",
    "* Una clase puede heredar de una clase padre, heredando todos sus atributos y metodos.\n",
    "* La herencia es opcional, *pero*:\n",
    "    * En Python2 es conveniente heredar *siempre* de la clase `object`\n",
    "    * En Python3 no hace falta heredar de la clase `object`\n",
    "    * Para tratar de garantizar la compatibilidad, podemos heradar siempre de `object`.\n",
    "* En Python las clases no tienen un constructor, pero existe el método `__init__` que se utiliza para inicializar la misma.\n",
    "* Todos los métodos de una clase deben tener como primer argumento `self`, que se igualará de forma automática con la referencia al propio objeto cuando se invoque el método."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Coordinate(object):  # Clase\n",
    "    \"\"\"A coordinate with an x and y value.\"\"\"\n",
    "    \n",
    "    def __init__(self, x, y):\n",
    "        \"\"\"Initialize the object with x and y\"\"\"\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        \n",
    "help(Coordinate)  # Todo en Python es un objeto\n",
    "        \n",
    "c = Coordinate(3, 4)  # creo un objeto de la clase Coordenada\n",
    "print(type(c))  # c contiene una referencia al objeto\n",
    "print(c.x, c.y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Métodos\n",
    "\n",
    "* Un método es una función que funciona en el contexto de la clase.\n",
    "* Cuando se invoca un método de un objeto, Python siempre pasa como primer argumento la referencia al objeto.\n",
    "* La convención es llamar a este primer argumento `self`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Coordinate(object):  # Clase\n",
    "    \"\"\"A coordinate with an x and y value.\"\"\"\n",
    "    \n",
    "    def __init__(self, x, y):\n",
    "        \"\"\"Initialize the object with x and y\"\"\"\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        \n",
    "    def distance(self, other):\n",
    "        \"\"\" Returns the euclidean distance between two points \"\"\"\n",
    "        x_diff_sq = (self.x - other.x)**2\n",
    "        y_diff_sq = (self.y - other.y)**2\n",
    "        \n",
    "        return (x_diff_sq + y_diff_sq)**0.5 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = Coordinate(1, 2)\n",
    "d = Coordinate(7, 9)\n",
    "\n",
    "c.distance(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Métodos especiales\n",
    "\n",
    "* Hay algunos [métodos especiales](https://docs.python.org/3/reference/datamodel.html#special-method-names) que Python invoca cuando se realizan ciertas operationes.\n",
    "    * Por ejemplo cuando se suman dos objetos\n",
    "    * O cuando se imprime un objeto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejemplo: imprimir el objeto\n",
    "\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Podemos sobreescribir esos métodos para realizar la acción que nosotros queramos\n",
    "    * Por ejemplo, mostrar información sobre el propio objeto cuando se imprime, sobreescribiendo el método `__str__`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Coordinate(object):  # Clase\n",
    "    \"\"\"A coordinate with an x and y value.\"\"\"\n",
    "    \n",
    "    def __init__(self, x, y):\n",
    "        \"\"\"Initialize the object with x and y\"\"\"\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        \n",
    "    def distance(self, other):\n",
    "        \"\"\" Returns the euclidean distance between two points \"\"\"\n",
    "        x_diff_sq = (self.x - other.x)**2\n",
    "        y_diff_sq = (self.y - other.y)**2\n",
    "        \n",
    "        return (x_diff_sq + y_diff_sq)**0.5\n",
    "    \n",
    "    def __str__(self):\n",
    "        return \"<Coordinate (\" + str(self.x) + \", \" + str(self.y) + \")>\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = Coordinate(4, 7)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ejemplos de otros métodos:\n",
    " * `__add__(self, other)`: `self + other` \n",
    " * `__sub__(self, other)`: `self - other`\n",
    " * `__eq__(self, other)`: `self == other`\n",
    " * `__lt__(self, other)`: `self < other`\n",
    " * `__len__(self)`: `len(self)`\n",
    " * `__str__(self)`: `print self`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Coordinate(object):  # Clase\n",
    "    \"\"\"A coordinate with an x and y value.\"\"\"\n",
    "    \n",
    "    def __init__(self, x, y):\n",
    "        \"\"\"Initialize the object with x and y\"\"\"\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        \n",
    "    def distance(self, other):\n",
    "        \"\"\" Returns the euclidean distance between two points \"\"\"\n",
    "        x_diff_sq = (self.x - other.x)**2\n",
    "        y_diff_sq = (self.y - other.y)**2\n",
    "        \n",
    "        return (x_diff_sq + y_diff_sq)**0.5\n",
    "    \n",
    "    def __str__(self):\n",
    "        return \"<Coordinate (\" + str(self.x) + \", \" + str(self.y) + \")>\"\n",
    "    \n",
    "    def __add__(self, other):\n",
    "        return Coordinate(self.x + other.x, self.y + other.y)\n",
    "    \n",
    "c = Coordinate(5, 4)\n",
    "d = Coordinate(3, 3)\n",
    "e = c + d\n",
    "print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Herencia\n",
    "\n",
    "* Una clase puede heredar de otras clases.\n",
    "* Podemos definir una jerarquía de clases padre e hijo.\n",
    "* Una clase hijo hereda todos los atributos y métodos de las clases padre\n",
    "* Una clase hijo puede añadir más atributos y métodos, o reemplazar algunos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Animal(object):\n",
    "    species = None\n",
    "    \n",
    "    def __init__(self, age, name):\n",
    "        self.age = age\n",
    "        self.name = name\n",
    "        \n",
    "    def make_noise(self):\n",
    "        print(\"I do not know which animal I am, I cannot make noise!\")\n",
    "        \n",
    "    def __str__(self):\n",
    "        return \"<Animal of species \"+self.species+\" named \"+self.name+\">\"\n",
    "    \n",
    "    \n",
    "class Rabbit(Animal):\n",
    "    species = \"Rabbit\"\n",
    "    \n",
    "    def is_furry(self):\n",
    "        return True\n",
    "\n",
    "    def make_noise(self):\n",
    "        print(\"Rabbits do not make noise\")\n",
    "\n",
    "    \n",
    "class Cow(Animal):\n",
    "    species = \"Cow\"\n",
    "    \n",
    "    def make_noise(self):\n",
    "        print(\"Mooo\")\n",
    "        \n",
    "r = Rabbit(5, \"flufy\")\n",
    "c = Cow(1, \"foo\")\n",
    "\n",
    "r.make_noise()\n",
    "c.make_noise()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Se puede llamar a los métodos de la clase padre mediante la función `super`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class StrangeAnimal(Animal):\n",
    "    species = \"unknown\"\n",
    "    \n",
    "    def __init__(self, age, name, attribute):\n",
    "        super(StrangeAnimal, self).__init__(age, name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = StrangeAnimal(10, \"foo\", \"bar\")"
   ]
  }
 ],
 "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}