dia5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Programación orientada a objetos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Clases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creando una clase vacia\n",
    "class Penguin:\n",
    "    pass\n",
    "\n",
    "# Creamos un objeto de la clase penguin\n",
    "mi_pinguino = Penguin()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Definir atributos\n",
    "\n",
    "Dos tipos de atributos:\n",
    "- Atributos de instancia\n",
    "- Atributos de clase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Creando penguin: 'Enri', Emperador\n",
      "Creando penguin: 'Steven', Fachero\n",
      "Creando penguin: 'Alex', Cool\n",
      "<class '__main__.Penguin'>\n",
      "Ave\n",
      "Ave\n",
      "Enri\n",
      "Emperador\n",
      "Steven\n",
      "Fachero\n",
      "Alex\n",
      "Cool\n"
     ]
    }
   ],
   "source": [
    "# Crear clase\n",
    "class Penguin:\n",
    "    # Definiendo un atributo de clase\n",
    "    categoria = \"Ave\"\n",
    "\n",
    "    # El metodo __init__ es llamado al crear el objeto\n",
    "    def __init__(self, nombre, especie):\n",
    "        print(\"Creando penguin: \" + \"'\" + nombre + \"', \" + especie)\n",
    "\n",
    "        # Atributos de instancia\n",
    "        self.nombre = nombre\n",
    "        self.especie = especie\n",
    "\n",
    "# Creando un pingüino\n",
    "mi_pinguino = Penguin(\"Enri\", \"Emperador\")\n",
    "mi_otro_pinguino = Penguin(\"Steven\", \"Fachero\")\n",
    "mi_otra_pinguina = Penguin(\"Alex\", \"Cool\")\n",
    "\n",
    "# Viendo qué tipo de dato es mi_pinguino\n",
    "print(type(mi_pinguino))\n",
    "\n",
    "# Viendo qué clase de animal es\n",
    "print(Penguin.categoria)\n",
    "print(mi_pinguino.categoria)\n",
    "print(mi_pinguino.nombre)\n",
    "print(mi_pinguino.especie)\n",
    "print(mi_otro_pinguino.nombre)\n",
    "print(mi_otro_pinguino.especie)\n",
    "print(mi_otra_pinguina.nombre)\n",
    "print(mi_otra_pinguina.especie)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge 🤺\n",
    "\n",
    "Crear dos `class` de animales que tengan atributos de instancia y de clase.\n",
    "\n",
    "- Atributo de instancia: `nombre` & `color`.\n",
    "- Atributo de clase: `especie`.\n",
    "\n",
    "Luego, crear nuevos objetos a partir de las nuevas `class`. Imprimir el `nombre` y el `color` de los animales en una frase que diga: \"Me llamo Alex y soy un ave de color blanco\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mi blanca vaca lola tiene cabeza y cola\n",
      "Es fido dido colorido\n"
     ]
    }
   ],
   "source": [
    "# Solución\n",
    "\n",
    "class Vaca:\n",
    "    especie = \"vaca\"\n",
    "    def __init__(self, N,C,S):\n",
    "        self.nombre = N\n",
    "        self.color = C\n",
    "        self.tiene = S\n",
    "\n",
    "lola = Vaca(\"lola\", \"blanca\", \"cabeza y cola\")\n",
    "print(\"Mi \" + lola.color + ' ' + lola.especie + \" \" + lola.nombre + \" tiene \" + lola.tiene)\n",
    "\n",
    "class Perrito:\n",
    "    especie = \"perrito\"\n",
    "    def __init__(self, nombre, apellido, color):\n",
    "        self.nombre = nombre\n",
    "        self.color = color\n",
    "        self.apellido = apellido\n",
    "\n",
    "fido = Perrito(\"fido\", \"dido\", \"colorido\")\n",
    "print(\"Es\" , fido.nombre , fido.apellido , fido.color) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Definiendo métodos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Creando pinguino: 'Santi', Rey\n",
      "Santi\n",
      "Rey\n",
      "Wooooshhhhhhhh!!!!!\n",
      "Caminando 99 pasos, lenta y torpemente\n",
      "El pinguino esta comiendo sushi\n"
     ]
    }
   ],
   "source": [
    "class Penguin:\n",
    "    # Definiendo un atributo de clase\n",
    "    categoria = \"Ave\"\n",
    "\n",
    "    # El método init es llamado al crear el objeto\n",
    "    def __init__(self, nombre, especie):\n",
    "        print(\"Creando pinguino: \" + \"'\" + nombre + \"', \" + especie)\n",
    "\n",
    "        # Atributos de instancia\n",
    "        self.nombre = nombre\n",
    "        self.especie = especie\n",
    "\n",
    "    # Definir métodos\n",
    "    def nada(self):\n",
    "        print(\"Wooooshhhhhhhh!!!!!\")\n",
    "\n",
    "    def camina(self, pasos):\n",
    "        print(\"Caminando \" + pasos + \" pasos, lenta y torpemente\")\n",
    "\n",
    "    def come(self, comida):\n",
    "        print(\"El pinguino esta comiendo \" + comida)\n",
    "\n",
    "# Creando un objeto\n",
    "mi_pinguino = Penguin(\"Santi\", \"Rey\")\n",
    "\n",
    "# Llamando atributos\n",
    "print(mi_pinguino.nombre)\n",
    "print(mi_pinguino.especie)\n",
    "\n",
    "# Llamando métodos\n",
    "mi_pinguino.nada()\n",
    "mi_pinguino.camina(\"99\")\n",
    "mi_pinguino.come(\"sushi\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge 🤺\n",
    "\n",
    "Crear dos métodos por animal, que sea `hablar` y `moverse`. \n",
    "\n",
    "- En el método `hablar`, imprimir: \"Cuando hablo, digo X\".\n",
    "- En el método `mover`, imprimir: \"Cuando me muevo, hago X\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Creando vaca: Rita,blanca\n",
      "Cuando hablo, digo cosas\n",
      "Cuando me muevo, hago ruido\n"
     ]
    }
   ],
   "source": [
    "# Solución de Caro\n",
    "\n",
    "class Vaca:\n",
    "    categoria = \"mamifero\"\n",
    "    def __init__(self, nombre, color):\n",
    "        print(\"Creando vaca: \" + nombre + \",\" + color)\n",
    "        self.nombre = nombre\n",
    "        self.color = color\n",
    "\n",
    "    def hablar(self):\n",
    "        print(\"Cuando hablo, digo cosas\")\n",
    "    def moverse(self):\n",
    "        print(\"Cuando me muevo, hago ruido\")\n",
    "\n",
    "mi_vaca = Vaca(\"Rita\", \"blanca\")\n",
    "mi_vaca.hablar()\n",
    "mi_vaca.moverse()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola, me llamo Frida y soy un felino de color gris\n",
      "Cuando hablo digo Miau\n",
      "Cuando me muevo bailo\n"
     ]
    }
   ],
   "source": [
    "# Solución de Norma\n",
    "\n",
    "class Gato:\n",
    "    categoria = \"felino\"\n",
    "\n",
    "    def __init__(self, nombre, color):\n",
    "        print(\"Hola, me llamo \" + nombre + \" y soy un felino de color \" + color)\n",
    "        self.nombre = nombre\n",
    "        self.color = color\n",
    "    def habla(self, palabra):\n",
    "        print(\"Cuando hablo digo \" + palabra)\n",
    "    def mover(self, pasos):\n",
    "        print(\"Cuando me muevo \" + str(pasos))\n",
    "\n",
    "mi_gato = Gato(\"Frida\", \"gris\")\n",
    "mi_gato.habla(\"Miau\")\n",
    "mi_gato.mover(\"bailo\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Herencia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(<class '__main__.Animal'>,)\n",
      "(<class 'object'>,)\n",
      "Piton\n",
      "10\n",
      "ssSSsssSsssSSSSS\n",
      "Soy un animal del tipo Serpiente\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    def __init__(self, especie, edad):\n",
    "        self.especie = especie\n",
    "        self.edad = edad\n",
    "    \n",
    "    # Método genérico pero con implementacion particular\n",
    "    def hablar(self):\n",
    "        # Metodo vacio\n",
    "        pass\n",
    "\n",
    "    # Método genérico con la misma implementacion\n",
    "    def describeme(self):\n",
    "        print(\"Soy un animal del tipo\", type(self).__name__)\n",
    "\n",
    "class Serpiente(Animal):\n",
    "    # Definiendo un atributo de clase\n",
    "    categoria = \"reptil\"\n",
    "\n",
    "    def hablar(self):\n",
    "        print(\"ssSSsssSsssSSSSS\")\n",
    "\n",
    "# Corroborar la herencia\n",
    "print(Serpiente.__bases__)\n",
    "print(Animal.__bases__)\n",
    "\n",
    "mi_serpiente = Serpiente(\"Piton\", 10)\n",
    "print(mi_serpiente.especie)\n",
    "print(mi_serpiente.edad)\n",
    "\n",
    "mi_serpiente.hablar()\n",
    "mi_serpiente.describeme()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge 🤺\n",
    "\n",
    "Definir una clase principal que herede a sus subclases dos atributos de instancia. Mostrar ambos atributos en pantalla desde los objetos de las subclases.\n",
    "\n",
    "<u>Observación</u>: Editar las subclases para que no se inicialicen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "barata\n",
      "baja\n",
      "yada\n",
      "medio\n",
      "oiko\n",
      "alto\n"
     ]
    }
   ],
   "source": [
    "# Solución de Oscar\n",
    "\n",
    "class Hidrocarburos:\n",
    "    def __init__(self, nafta,octanos):\n",
    "        self.nafta = nafta\n",
    "        self.octanos = octanos\n",
    "\n",
    "class Mbarete(Hidrocarburos):\n",
    "    # Definiendo atributo de clase\n",
    "    pass\n",
    "\n",
    "class Ne(Hidrocarburos):\n",
    "    pass\n",
    "\n",
    "class Purete(Hidrocarburos):\n",
    "    pass\n",
    "\n",
    "combustible_vai = Mbarete(\"barata\", \"baja\")\n",
    "print(combustible_vai.nafta)\n",
    "print(combustible_vai.octanos)\n",
    "combustible_ne = Ne(\"yada\", \"medio\")\n",
    "print(combustible_ne.nafta)\n",
    "print(combustible_ne.octanos)\n",
    "combustible_Purete = Purete(\"oiko\", \"alto\")\n",
    "print(combustible_Purete.nafta)\n",
    "print(combustible_Purete.octanos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### DRY = Don't Repeat Yourself !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Diccionarios\n",
    "\n",
    "Un diccionario es una colección de pares formados por una clave y un valor asociado a la clave. Se construyen poniendo los pares entre llaves { } separados por comas, y separando la clave del valor con dos puntos :.\n",
    "\n",
    "Se caracterizan por:\n",
    "\n",
    "- No tienen orden.\n",
    "- Pueden contener elementos de distintos tipos.\n",
    "- Son mutables, es decir, pueden alterarse durante la ejecución de un programa.\n",
    "- Las claves son únicas, es decir, no pueden repetirse en un mismo diccionario, y pueden ser de cualquier tipo de datos inmutable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'nombre': 'Enmanuel', 'apellido': 'Ruffinelli', 'email': 'e@ruffinel.li'}\n",
      "Enmanuel\n",
      "e@ruffinel.li\n",
      "{'nombre': 'Enmanuel', 'apellido': 'Ruffinelli', 'email': 'e@ruffinel.li', 'barrio': 'Los Laureles'}\n",
      "{'nombre': 'Enmanuel', 'apellido': 'Ruffinelli', 'email': 'e@ruffinel.li', 'barrio': 'Recoleta'}\n",
      "{'nombre': 'Enmanuel', 'apellido': 'Ruffinelli', 'email': 'e@ruffinel.li'}\n",
      "{'apellido': 'Ruffinelli', 'email': 'e@ruffinel.li'}\n"
     ]
    }
   ],
   "source": [
    "# Ejemplo de diccionario\n",
    "\n",
    "mi_contacto = {\"nombre\": [\"Steven\", \"Enmanuel\"], \"apellido\": \"Ruffinelli\", \"numero\": 1, \"toma_alcohol\": False}\n",
    "\n",
    "# Ejemplo de diccionario estilizado\n",
    "otro_contacto = {\n",
    "   \"nombre\": \"Enmanuel\",\n",
    "   \"apellido\": \"Ruffinelli\",\n",
    "   \"email\": \"e@ruffinel.li\" \n",
    "}\n",
    "\n",
    "# Imprimir el diccionario\n",
    "print(mi_contacto)\n",
    "\n",
    "# Acceder a datos del diccionario\n",
    "print(mi_contacto[\"nombre\"])\n",
    "print(mi_contacto[\"email\"])\n",
    "\n",
    "# Desplegar datos del diccionario\n",
    "mi_contacto.keys()\n",
    "mi_contacto.values()\n",
    "mi_contacto.items()\n",
    "\n",
    "# Añadir datos al diccionario\n",
    "mi_contacto[\"barrio\"] = \"Los Laureles\"\n",
    "print(mi_contacto)\n",
    "\n",
    "# Actualizar datos del diccionario\n",
    "mi_contacto[\"barrio\"] = \"Recoleta\"\n",
    "print(mi_contacto)\n",
    "\n",
    "# Eliminar datos del diccionario\n",
    "mi_contacto.pop(\"barrio\")\n",
    "print(mi_contacto)\n",
    "\n",
    "del mi_contacto[\"nombre\"]\n",
    "print(mi_contacto)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge 🤺\n",
    "\n",
    "Escribir un programa que cree un diccionario vacío y lo vaya llenado con información sobre una persona (por ejemplo nombre, edad, sexo, teléfono, correo electrónico, etc.) que se le pida al usuario. Cada vez que se añada un nuevo dato debe imprimirse el contenido del diccionario."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'nombre': 'enma'}\n",
      " \n",
      "{'nombre': 'enma', 'apellido': 'ruffi'}\n",
      " \n",
      "{'nombre': 'enma', 'apellido': 'ruffi', 'telefono': '12345'}\n",
      " \n",
      "{'nombre': 'enma', 'apellido': 'ruffi', 'telefono': '12345', 'pin de itau': '1234'}\n",
      " \n",
      "{'nombre': 'enma', 'apellido': 'ruffi', 'telefono': '12345', 'pin de itau': '1234', 'asd': '123'}\n",
      " \n"
     ]
    }
   ],
   "source": [
    "# Solución de Caleb\n",
    "\n",
    "datos = 0\n",
    "DatosDeCliente = {}\n",
    "while datos != 5:\n",
    "    dato = input(\"Introduzca su valor: \")\n",
    "    valor = input(\"Introduzca su llave: \")\n",
    "    DatosDeCliente[dato] = valor\n",
    "    print(DatosDeCliente)\n",
    "    print(\" \")\n",
    "    datos += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Favor ingresar Nombre\n",
      "Favor ingresar Apellido\n",
      "Favor ingresar Mail\n",
      "Favor ingresar Telefono\n",
      "{'Nombre': 'enma', 'Apellido': 'ruffi', 'Mail': 'hola arroba mail punto com', 'Telefono': '12345'}\n"
     ]
    }
   ],
   "source": [
    "# Solución de Jony\n",
    "\n",
    "datos_requeridos = [\"Nombre\", \"Apellido\", \"Mail\", \"Telefono\"]\n",
    "datos_conseguidos = {}\n",
    "\n",
    "for i in range(len(datos_requeridos)):\n",
    "    print(\"Favor ingresar\", datos_requeridos[i])\n",
    "    dato_ingresado = input(\"Ingrese datos\")\n",
    "    datos_conseguidos[datos_requeridos[i]] = dato_ingresado\n",
    "\n",
    "print(datos_conseguidos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'nombre': 'enma'}\n",
      "{'nombre': 'enma', 'apellido': 'ruffi'}\n"
     ]
    }
   ],
   "source": [
    "# Solución de Clau\n",
    "\n",
    "mi_contacto = {}\n",
    "flag = \"\" # bandera\n",
    "\n",
    "while flag != \"salir\":\n",
    "    valor = input(\"Introduzca el tipo de dato\")\n",
    "    mi_contacto[valor] = input(\"Introduce tu dato\")\n",
    "    print(mi_contacto)\n",
    "    flag = input(\"Si desea salir, escriba salir\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge 🤺\n",
    "\n",
    "Crear una tarjeta personal. El usuario (mediante `input`) puede elegir:\n",
    "\n",
    "1. Crear datos nuevos\n",
    "2. Modificar datos\n",
    "3. Eliminar datos"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
  },
  "kernelspec": {
   "display_name": "Python 3.9.12 64-bit",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}