dia5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Programación orientada a objetos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creando una clase vacía\n",
    "class Penguin:\n",
    "    pass\n",
    "\n",
    "# Creamos un objeto de la clase Penguin\n",
    "mi_pinguino = Penguin()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Definiendo atributos\n",
    "\n",
    "Es importante distinguir que existen dos tipos de atributos:\n",
    "\n",
    "- <u>Atributos de instancia</u>: Pertenecen a la instancia de la clase o al objeto. Son atributos particulares de cada instancia, en nuestro caso de cada pinguino.\n",
    "- <u>Atributos de clase</u>: Se trata de atributos que pertenecen a la clase, por lo tanto serán comunes para todos los objetos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Creando pinguino: Enri, Emperador\n",
      "Creando pinguino: Roge, Real\n",
      "<class '__main__.Penguin'>\n",
      "Ave\n",
      "Ave Enri Emperador\n",
      "Woooshhhhhhhh\n",
      "Estoy nadando\n",
      "Caminando 10 pasos, lenta y torpemente\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",
    "    def nada(self):\n",
    "        print(\"Woooshhhhhhhh\")\n",
    "        print(\"Estoy nadando\")\n",
    "\n",
    "    def camina(self, pasos):\n",
    "        print(f\"Caminando {pasos} pasos, lenta y torpemente\")\n",
    "        # print(\"Caminando \" + str(pasos) + \" pasos, lenta y torpemente\")\n",
    "\n",
    "# Creando un pingüino\n",
    "mi_pinguino = Penguin(\"Enri\", \"Emperador\")\n",
    "mi_otro_pinguino = Penguin(\"Roge\", \"Real\")\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, mi_pinguino.nombre, mi_pinguino.especie)\n",
    "\n",
    "# Métodos de nuestro pinguino\n",
    "mi_otro_pinguino.nada()\n",
    "mi_pinguino.camina(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicio\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": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Me llamo Michi y soy un mamifero de color gris\n",
      "Me llamo Rene y soy un anfibio de color Verde\n"
     ]
    }
   ],
   "source": [
    "# Solución de un/a participante\n",
    "\n",
    "class Gato:\n",
    "    especie = \"mamifero\"\n",
    "\n",
    "    def __init__ (self, nombre, color):\n",
    "        self.nombre = nombre\n",
    "        self.color = color\n",
    "\n",
    "gato1 = Gato(\"Michi\", \"gris\")\n",
    "\n",
    "class Rana:\n",
    "    especie = \"anfibio\"\n",
    "\n",
    "    def __init__ (self, nombre, color):\n",
    "        self.nombre = nombre\n",
    "        self.color = color\n",
    "\n",
    "rana1 = Rana(\"Rene\", \"Verde\")\n",
    "\n",
    "print(\"Me llamo\", gato1.nombre, \"y soy un\", gato1.especie, \"de color\", gato1.color)\n",
    "print(\"Me llamo\", rana1.nombre, \"y soy un\", rana1.especie, \"de color\", rana1.color)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicio\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": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola mi nombre es Aquiles y soy un gato de color Blanco\n",
      "Lo unico que mi gato sabe decir es qué lindo es Enri lastimosamente\n",
      "El gato cuando tiene hambre va a la cocina que esta a 5 pasos de su arenero.\n",
      "Ñamñamñam\n"
     ]
    }
   ],
   "source": [
    "# Solución de un/a participante\n",
    "\n",
    "class Gato:\n",
    "    especie = \"Mamifero\"\n",
    "    def __init__(self, nombre, color):\n",
    "        print(\"Hola mi nombre es \" + nombre + \" \" \"y soy un gato de color \" + color)\n",
    "        self.nombre = nombre\n",
    "        self.color = color\n",
    "    def habla(self, habla):\n",
    "        print(\"Lo unico que mi gato sabe decir es \" + habla + \" \" \"lastimosamente\")\n",
    "    def camina(self, pasos):\n",
    "        print(f\"El gato cuando tiene hambre va a la cocina que esta a {pasos} pasos de su arenero.\")\n",
    "    def come(self):\n",
    "        print(\"Ñamñamñam\")\n",
    "\n",
    "mi_gato = Gato(\"Aquiles\", \"Blanco\")\n",
    "\n",
    "mi_gato.habla(\"qué lindo es Enri\")\n",
    "mi_gato.camina(5)\n",
    "mi_gato.come()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Herencia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(<class '__main__.Animal'>,)\n",
      "Piton\n",
      "5\n",
      "SssSSsSSSssSSSss\n",
      "Soy un animal del tipo Serpiente\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",
    "    # Metodo generico pero con implementacion particular\n",
    "    def hablar(self):\n",
    "        # Metodo vacio\n",
    "        pass\n",
    "\n",
    "    # Metodo generico con la misma implementacion\n",
    "    def describeme(self):\n",
    "        print(\"Soy un animal del tipo\", type(self).__name__)\n",
    "\n",
    "class Serpiente(Animal):\n",
    "    # Definir 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",
    "\n",
    "mi_serpiente = Serpiente(\"Piton\", 5)\n",
    "print(mi_serpiente.especie)\n",
    "print(mi_serpiente.edad)\n",
    "\n",
    "mi_serpiente.hablar()\n",
    "mi_serpiente.describeme()\n",
    "\n",
    "python = Serpiente(\"Piton\", 10)\n",
    "\n",
    "python.describeme()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicio\n",
    "\n",
    "Definir una clase madre que herede a sus clases hijas dos atributos de instancia. Mostrar ambos atributos en pantalla desde los objetos de las clases hijas.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "Soy un terricola del tipo  Humanos\n"
     ]
    }
   ],
   "source": [
    "# Solución de un/a participante\n",
    "\n",
    "class Terricolas:\n",
    "    def __init__ (self, respirar_carbono, luz_solar):\n",
    "        self.respirar_carbono = respirar_carbono\n",
    "        self.luz_solar = luz_solar\n",
    "\n",
    "    def describeme(self):\n",
    "        print(\"Soy un terricola del tipo \", type(self).__name__)\n",
    "\n",
    "class Humanos(Terricolas):\n",
    "    categoria = \"Terrestres\"\n",
    "\n",
    "paladin = Humanos(True,False)\n",
    "print(paladin.respirar_carbono)\n",
    "print(paladin.luz_solar)\n",
    "paladin.describeme()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Diccionarios"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'nombre': 'Enmanuel', 'apellido': 'Ruffinelli', 'email': 'e@ruffinel.li'}\n",
      "Enmanuel 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",
      "{'nombre': 'Enmanuel', 'email': 'e@ruffinel.li'}\n"
     ]
    }
   ],
   "source": [
    "# Ejemplo de diccionario\n",
    "\n",
    "mi_contacto = { \"nombre\": \"Enmanuel\", \"apellido\": \"Ruffinelli\", \"email\": \"e@ruffinel.li\" }\n",
    "\n",
    "{\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\"], mi_contacto[\"email\"])\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: ultimo par\n",
    "mi_contacto.popitem()\n",
    "print(mi_contacto)\n",
    "\n",
    "# Eliminar datos del diccionario: por clave\n",
    "del mi_contacto[\"apellido\"]\n",
    "print(mi_contacto)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicio \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": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'nombre': 'estrella'}\n",
      "{'nombre': 'estrella', 'apellido': 'ayala'}\n"
     ]
    }
   ],
   "source": [
    "# Solución de un/a participante\n",
    "\n",
    "informacion_deseada = {}\n",
    "seguir_preguntando = True\n",
    "\n",
    "while seguir_preguntando:\n",
    "    \n",
    "    clave = input(\"Agregue el dato que quiera\")\n",
    "    valor = input(\"agregue la informacion del dato\")\n",
    "    informacion_deseada[clave] = valor\n",
    "    print (informacion_deseada)\n",
    "    seguir_preguntando = input(\"Queres seguir anadiendo datos\") == \"si\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'nombre': 'Michi'}\n",
      "{'nombre': 'Michi', 'edad': '2'}\n"
     ]
    }
   ],
   "source": [
    "# Solución de un/a participante\n",
    "\n",
    "def diccionario():\n",
    "    diccionario1 = {}\n",
    "\n",
    "    while True:\n",
    "        agregar_usuario = input(\"Desea participar\")\n",
    "        if agregar_usuario == \"si\":\n",
    "            clave = input(\"Escriba el tipo de dato\")\n",
    "            valor = input(\"Escriba el dato\")\n",
    "            diccionario1[clave] = valor\n",
    "            print(diccionario1)\n",
    "        if agregar_usuario != \"si\":\n",
    "            break\n",
    "\n",
    "diccionario()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicio\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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solución de un/a participante\n",
    "\n",
    "tarjeta_personal = {}\n",
    "\n",
    "while True:\n",
    "    menu = int(input(\"Seleccione una opción: \"))\n",
    "    if menu == 1:\n",
    "        clave = input('¿Qué dato quieres introducir? ')\n",
    "        valor = input(clave + ': ')\n",
    "        tarjeta_personal[clave] = valor\n",
    "        print(tarjeta_personal)\n",
    "    elif menu == 2:\n",
    "        clave = input('¿Qué dato quieres cambiar? ')\n",
    "        valor = input(clave + ': ')\n",
    "        tarjeta_personal[clave] = valor\n",
    "        print(tarjeta_personal)\n",
    "    elif menu == 3:\n",
    "        clave = input('¿Qué dato quieres eliminar? ')\n",
    "        del tarjeta_personal[clave]\n",
    "        print(tarjeta_personal)"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
  },
  "kernelspec": {
   "display_name": "Python 3.9.10 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.10"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}