objetos

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
"""
POO programacion orientada a objetos es un paradigma de programación:
en POO: se intenta modelar un problema en funcion de objetos que tienen
propiedades y pueden hacer cosas

Problema: hacer un software que administre un aeropuerto:

objetos: avion boeing767, piloto Juan Gomez, azafata Luisa Lane
avion boeing 747, pasajero Juan Perez

Los objetos pueden agruparse en clases:
clase avion, clase piloto, clase azafata, clase despachante, clase pasajero

Cuando creo UN OBJETO PARTICULAR se dice que es una instancia de clase
ej boeing786 es una instancia de la clase avión

ATRIBUTOS: adjetivos   METODOS: verbos


# Vamos a crear una clase perro
# cada caracteristica de un perro es un atributo: pelaje, edad, raza, tamaño, etc
# la mayoria de los atributos varian de perro en perro
# Los atributos iguales para todos los perros se llaman ATRIBUTOS DE CLASE

class Perro:
    # atributos de clase
    especie = "Canis familiaris"

    def __init__(self,nombre,edad):
        '''Construye la instancia creando sus atributos'''
        self.nombre = nombre
        self.edad = edad

# creo dos instancias de perro
sultan = Perro("Sultan",6)
firulai = Perro("Firulai",4)

# imprime alguna atributos
print(f"Edad de firulai: {firulai.edad}")
print(f"ESpecie de los perros: {sultan.especie}")
print(f"Nombre de sultan: {sultan.nombre}")

# los atributos se pueden modificar /los objetos son mutables por default
sultan.especie = "Marca perro"
sultan.edad = 2

print(sultan.especie)
print(firulai.especie)
print(sultan.edad)


# Los métodos de la instancia son las cosas que puede hacer
# ladrar, comer, saltar, dormir, morder, jugar

# Resscribo la clase Perro pero con métodos

class Perro:
    # atributos de clase
    especie = "Canis familiaris"

    def __init__(self,nombre,edad):
        '''Construye la instancia creando sus atributos'''
        self.nombre = nombre
        self.edad = edad

    def describir(self):
        return f"{self.nombre} tiene {self.edad} años de edad"

    def ladrar(self,sonido="guau"):
        return f"{self.nombre} dijo {sonido}"

tronco = Perro("tronco",4)

print(tronco.describir())
print(tronco.ladrar())
print(tronco.ladrar("woof woof"))


# reescribo la clase perro usando métodos mágicos o dunder methods
class Perro:
    # atributos de clase
    especie = "Canis familiaris"

    def __init__(self,nombre,edad):
        '''Construye la instancia creando sus atributos'''
        self.nombre = nombre
        self.edad = edad

    def __str__(self):
        return f"{self.nombre} tiene {self.edad} años de edad"

    def ladrar(self,sonido="guau"):
        return f"{self.nombre} dijo {sonido}"

tronco = Perro("tronco",4)

print(tronco)
print(tronco.ladrar())
print(tronco.ladrar("woof woof"))


# Herencia: es el proceso mediante el cual una clase
# llamada secundaria o hija asume atributos y
# o metodos de otras clases, llamadas principales o padres
# En PYTHON EXISTE LA HERENCIA MULTIPLE

# Si quisiera razas de perros, no voy a reescribir la clase Perro: simplemente
# la heredo creando clases hijas

class JackRussellTerrier(Perro):
    def ladrar(self,sonido="ARF"):
        return f"{self.nombre} dijo {sonido}"

class Bulldog(Perro):
    def ladrar(self,sonido="woof woof"):
        return f"{self.nombre} dijo {sonido}"

# instancio
miles = JackRussellTerrier("Miles",5)
jim = Bulldog("Jim",4)

print(jim.ladrar())
print(miles)

# verifico la raza de un perro
print(isinstance(miles,JackRussellTerrier))

# Que pasa si la clase perro modifica su función ladrar (dijo por gritó)
# mi raza sigue diciendo no grita como su clase padre

class Perro:
    # atributos de clase
    especie = "Canis familiaris"

    def __init__(self,nombre,edad):
        '''Construye la instancia creando sus atributos'''
        self.nombre = nombre
        self.edad = edad

    def __str__(self):
        return f"{self.nombre} tiene {self.edad} años de edad"

    def ladrar(self,sonido="guau"):
        return f"{self.nombre} gritó {sonido}"

class JackRussellTerrier(Perro):
    def ladrar(self,sonido="ARF"):
        # return f"{self.nombre} dijo {sonido}"
        return super().ladrar(sonido="ARF")   # invoca ladrar de la clse padre

jim = JackRussellTerrier("Jim",4)
print(jim.ladrar())
"""
# polimorfismo: el mismo método puede ser llamado por dos objetos distintos

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

    def hablar(self):
        return "MIAU"


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

    def hablar(self):
        return "GUAU"

# creo el polimorfismo
def EscucharMascota(animal):
    return animal.hablar()


cacho = Perro("cacho")
fufu = Gato("fufu")
print(f"Un perro dice {EscucharMascota(cacho)}")
print(f"Un gato dice {EscucharMascota(fufu)}")


# lo mismo usando herencia
class Animal:
    def __init__(self, nombre):
        self.nombre = nombre

    def hablar(self):
        pass


class Gato(Animal):
    def hablar(self):
        return "MIAU"


class Perro(Animal):
    def hablar(self):
        return "GUAU"

cacho = Perro("cacho")
fufu = Gato("fufu")
print(f"Un perro dice {cacho.hablar()}")
print(f"Un gato dice {fufu.hablar()}")

# herencia multiple
# la clase hija hereda de sus padres resolviendo de derecha a izquierda

class PadreA:
    def __init__(self):
        self.a = 1

    def mensaje(self):
        print("Soy A")

class PadreB:
    def __init__(self):
        self.a = 2

    def mensaje(self):
        print("Soy B")

    def mensaje2(self):
        print("Insisto, soy B")



class Hija(PadreA,PadreB):
    pass


hija = Hija()
print(hija.a)  # imprime 1, la última herencia viene de PadreA
hija.mensaje()
hija.mensaje2()