Poo en Python muy sencillo

Código completo (para referencia)

class Animal:
    def __init__(self, nombre):
        self.nombre = nombre

    def hablar(self):
        return "Sonido genérico"

class Perro(Animal):
    def hablar(self):
        return "Guau!"

class Gato(Animal):
    def hablar(self):
        return "Miau!"

animales = [Perro("Firulais"), Gato("Misu")]

for animal in animales:
    print(f"{animal.nombre} dice: {animal.hablar()}")

---

Primera parte: clase Animal

class Animal:

• class Animal:
  Declara una nueva clase llamada Animal.
  Una clase es un “molde” o “plantilla” para crear objetos del tipo Animal.

    def __init__(self, nombre):

• def __init__(self, nombre):
  Define el método especial __init__, que es el constructor.
  Se ejecuta automáticamente cuando creas un Animal.

  • self representa al propio objeto.
  • nombre es un parámetro que recibirá el nombre del animal.

        self.nombre = nombre

• self.nombre = nombre
  Crea un atributo llamado nombre dentro del objeto.
  Guarda en self.nombre el valor que se pasa al crear el animal.
  Es decir, el objeto recordará su nombre.

    def hablar(self):

• def hablar(self):
  Declara un método llamado hablar para la clase Animal.
  Este será el comportamiento “genérico” de hablar.

        return "Sonido genérico"

• return "Sonido genérico"
  Cuando se llame a hablar() en un Animal, devolverá esta cadena.
  Más adelante, las clases hijas lo cambiarán por sonidos más específicos.

---

Segunda parte: clase Perro que hereda de Animal

class Perro(Animal):

• class Perro(Animal):
  Crea una clase Perro que hereda de Animal.
  Eso significa que Perro tiene todo lo de Animal (como nombre), pero puede añadir o cambiar cosas.

    def hablar(self):

• def hablar(self):
  Define el método hablar en Perro.
  Este método sobrescribe (reemplaza) el hablar genérico de Animal.

        return "Guau!"

• return "Guau!"
  Cuando se llame a hablar() en un Perro, devolverá "Guau!".

---

Tercera parte: clase Gato que también hereda de Animal

class Gato(Animal):

• class Gato(Animal):
  Declara la clase Gato que también hereda de Animal.
  Igual que Perro, tiene nombre y puede hablar.

    def hablar(self):

• def hablar(self):
  Sobrescribe el método hablar para los gatos.

        return "Miau!"

• return "Miau!"
  Cuando se llame a hablar() en un Gato, devolverá "Miau!".

---

Cuarta parte: creando objetos y usando polimorfismo

animales = [Perro("Firulais"), Gato("Misu")]

• animales = [...]
  Crea una lista llamada animales.
• Perro("Firulais")
  Crea un objeto de tipo Perro con nombre = "Firulais".
  Internamente llama a __init__ de Animal y guarda ese nombre.
• Gato("Misu")
  Crea un objeto de tipo Gato con nombre = "Misu".
  También usa el constructor heredado.
• La lista contiene ahora dos objetos: un perro y un gato.

for animal in animales:

• for animal in animales:
  Inicia un bucle que recorre cada elemento de la lista animales.
  En cada vuelta, la variable animal será:

  • Primero, el Perro("Firulais")
  • Después, el Gato("Misu")

    print(f"{animal.nombre} dice: {animal.hablar()}")

• print(f"{animal.nombre} dice: {animal.hablar()}")
  Usa una f-string para formatear el texto.

  • animal.nombre accede al atributo nombre del objeto actual.
  • animal.hablar() llama al método hablar del objeto actual.

• Aquí es donde aparece el polimorfismo:

  • Si animal es un Perro, hablar() devuelve "Guau!".
  • Si animal es un Gato, hablar() devuelve "Miau!".

• En pantalla verás:

  • Firulais dice: Guau!
  • Misu dice: Miau!