oop

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
'''
OOP , POO programación orientada a objetos

La POO es un PARADIGMA de programación que proporciona una FORMA de
estructurar programas: Existen Cosas que tienen propiedades y hacen cosas
Existen OBJETOS (sustantivos) que tienen ATRIBUTOS (adjetivos) y hacen cosas
llamadas METODOS (verbos)
Ej: CLASE: es una abstracción o generalización de un objeto
EJ: quiero modelizar un aeropuerto:
objetos: avion Boeing707, avión Concorde, Aviòn LEARJET, piloto Hugo Ramirez,...
abstracción: Clases: Avion, Piloto, Usuarios, Azafatas

1 objeto de la clase avion tiene atributos: autonomía de vuelo, capacidad
tripulación, aerolinea, etc y tiene metodos: vuela, despega, aterriza, recarga_combustible, etc

CLASES E INSTANCIAS: las clases definen funciones (metodos) que identifican
comportamientos y funciones, una instancia de clase es un objeto


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

    def __init__(self, nombre, edad):
        """Crea los atributos de instancia"""
        self.nombre = nombre
        self.edad = edad

# Creo dos instancias de perro
sultan = Perro("Sultan",8)
firulai = Perro("Firulai",5)

# imprimo algo
print(sultan.nombre)
print(firulai.edad)
print(sultan.especie)

# los objetos son mutables por default
sultan.edad = 4
sultan.especie = "Marca Perro"
print(sultan.edad)
print(sultan.especie)
print(firulai.especie)

# Reescribamos la clase con mas mètodos.
class Perro:
    # Atributo de clase
    especie = "Canis familiaris"

    def __init__(self, nombre, edad):
        """Crea los atributos de instancia"""
        self.nombre = nombre
        self.edad = edad

    def descripcion(self):
        """Crea un mètodo de instancia"""
        return f"{self.nombre} tiene {self.edad} años"

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

sultan = Perro("Sultan",8)
firulai = Perro("Firulai",5)
print(firulai.ladra())
print(sultan.ladra("WOOF WOOF"))
print(sultan.descripcion())


# Reescribamos la clase con métodos mágicos: usemos __str__ que es leído
# por print()
class Perro:
    # Atributo de clase
    especie = "Canis familiaris"

    def __init__(self, nombre, edad):
        """Crea los atributos de instancia"""
        self.nombre = nombre
        self.edad = edad

    def __str__(self):
        """Le digo a print() como se imprime un objeto Perro"""
        return f"{self.nombre} tiene {self.edad} años"

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

    def __add__(p,q):
        return f"{p.nombre} y {q.nombre} van a tener cachorros"

sultan = Perro("Sultan",8)
firulai = Perro("Firulai",5)
print(firulai.ladra())
print(sultan.ladra("WOOF WOOF"))
print(sultan)
print(sultan + firulai)


# Herencia: es un mecanismo mediante el cual una clase denominada secundaria
# o hija asume los mismos atributos y mètodos que otra clase llamada
# principal o padre. La clase secundaria puede agregar y/o modificar cualquier
# metodo/atributo
class Perro:
    # Atributo de clase
    especie = "Canis familiaris"

    def __init__(self, nombre, edad):
        """Crea los atributos de instancia"""
        self.nombre = nombre
        self.edad = edad

    def __str__(self):
        """Le digo a print() como se imprime un objeto Perro"""
        return f"{self.nombre} tiene {self.edad} años"

    def ladra(self,sonido="GUAU"):
        return f"{self.nombre} GRITA {sonido}"

    def __add__(p,q):
        return f"{p.nombre} y {q.nombre} van a tener cachorros"

# creo clases hijas

class JackRussellTerrier(Perro):
    def ladra(self, sonido="ARF"):
        return super().ladra(sonido)

class Dogo(Perro):
    def ladra(self, sonido="GRRRRR"):
        return f"{self.nombre} dijo {sonido}"

# instancio
miles = JackRussellTerrier("Miles",4)
buddy = Dogo("Buddy",6)
jim = Dogo("Jim",4)

print(jim.ladra())
print(miles.ladra())
print(isinstance(miles,JackRussellTerrier))
print(type(buddy))


# POLIMORFISMO: son dos metodos iguales de clases diferentes
# por ejemplo ladra en Dogo , JackRusselTerrier y Perro

# Primera forma (sin herencia)
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"


def oir_mascota(animal):
    return animal.hablar()

cacho = Perro("Cacho")
fufu = Gato("Fufu")

print(f"Mi perro {cacho.nombre} dice {oir_mascota(cacho)}")
print(f"Mi gato {fufu.nombre} dice {oir_mascota(fufu)}")

# Segunda forma (con herencia)
class Animal:
    def hablar():
        pass

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

    def hablar(self):
        return "Miau"

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

    def hablar(self):
        return "Guau"



cacho = Perro("Cacho")
fufu = Gato("Fufu")

print(f"Mi perro {cacho.nombre} dice {cacho.hablar()}")
print(f"Mi gato {fufu.nombre} dice {fufu.hablar()}")

'''
##### HERENCIA MULTIPLE
class ClaseA:
    def __init__(self):
        self.x = 1

    def mensaje(self):
        print("Dentro de Clase A")



class ClaseB:
    def __init__(self):
        self.x = 2

    def mensaje(self):
        print("Dentro de Clase B")


class ClaseMultiple(ClaseA, ClaseB): # se hereda de der a izq
    pass

instancia = ClaseMultiple()
print(instancia.x)  # imprime 1, ClaseA sobreescribe el valor de x en ClaseB
instancia.mensaje()