#!/usr/bin/env python
# -*- coding: utf-8 -*-
'''
Programación orientada a objetos
 - es un paradigma de programación que proporciona un medio para 
 estructurar programas para que las propiedades y los comportamientos se
 agrupen en objetos individuales
 
 - POO modela entidades del mundo real como objetos de software que
 tiene algunos datos asociados con ellos y pueden realizar determinadas
 funciones

 CLASES e INSTANCIAS:
 - clases: se utilizan para crear estructuras de datos definidas por
    un usuario.
 - instancias: es un objeto en particular de una clase (sustantivos)
 - métodos: son las funciones de las clases que hacen algo (verbos)
 - atributos: son las propiedades (adjetivos)
 
 ej:
 clase Perro
 instancias: RinTinTin, Lassie, Laika, Cacho
 metodos: ladrar, dormir, esCaniche
 atributos: raza, edad, pelaje
 
 clase Futbolista:
 instancias: Messi, Ronaldo, Maradona
 metodos: patear, atajar, 
 atributos: esArgentino, altura, edad, peso
 
 en python los metodos con doble guion bajo se denominan metodos
 magicos o dunder methods

class Perro:
    # Atributo de clase
    especie = "Canis familiaris"
    
    # metodos
    def __init__(self, nombre, edad):
        """Crea los atributos de la instancia"""
        self.nombre = nombre
        self.edad = edad
        
    def __str__(self):
        """Describe al objeto"""
        return f"{self.nombre} tiene {self.edad} años de edad"
        
    def __add__(self1, self2):
        return f"han tenido cachorros"
        
    def ladra(self, sonido):
        """Devuelve como habla el perro"""
        return f"{self.nombre} dijo {sonido}"
        
# creo las instancias
tronco = Perro("Tronco", 4)  
duquesa = Perro("Duquesa", 3)


print(tronco)
print(tronco.ladra("woof woof"))
print(tronco + duquesa)

# los atributos de clase se pueden modificar
tronco.especie = "perro marca calle"
print(tronco.especie)
print(duquesa.especie)


# herencia: es el proceso por el cual una clase asume atributos y metodos
# de otra llamada clase padre o principal. La nueva clase se denomina hija o 
# secundaria

# las clases secundarias pueden modificar los metodos y/o atributos heredados

class JackRusselTerrier(Perro):
    def ladra(self, sonido= "Arf"):
        return f"{self.nombre} dijo {sonido}"
        
class Doberman(Perro):
    def ladra(self, sonido= "GUAU"):
        return f"{self.nombre} dijo {sonido}"

killer = Doberman("Killer",2)
print(killer)
print(killer.ladra())

# verifico que tipo de instancia es killer
print(f"Killer es un doberman: {isinstance(killer,Doberman)}")
print(f"Killer es un JackRusselTerrier: {isinstance(killer,JackRusselTerrier)}")
print(f"Killer es un perro: {isinstance(killer,Perro)}")


# POLIMORFISMO: usar un metodo con el mismo nombre pero de diferentes
# clases

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"
        
# uso del polimorfismo
def escuchar_mascota(animal):
    return animal.hablar()
    
cacho = Perro("Cacho")
fufu = Gato("Fufu")

print(f"Un perro dice {escuchar_mascota(cacho)}")
print(f"Un gato dice {escuchar_mascota(fufu)}")


# lo mismo con herencia
class Animal():
    def hablar(self):
        pass
        
class Gato1(Animal):
    def __init__(self, nombre):
        self.nombre = nombre
        
    def hablar(self):
        return "MIAU"
        
class Perro1(Animal):
    def __init__(self, nombre):
        self.nombre = nombre
        
    def hablar(self):
        return "GUAU"

cacho2 = Perro1("Cacho")
fufu2 = Gato1("Fufu")

print(f"Un perro dice {cacho2.hablar()}")
print(f"Un gato dice {fufu2.hablar()}")
'''

### HERENCIA MULTIPLE
class Madre:
    def __init__(self):
        self.madre = "Ana"
        self.a = "Mama es la mejor"

class Padre:
    def __init__(self):
        self.padre = "Juan"
        self.a = "Papa es el mejor"
        
class Hijo(Madre,Padre):
    pass
    

pepe = Hijo()
print(pepe.a)
print(pepe.madre)
print(pepe.padre)