clases

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
"""
Programación procedimental (como trabajamos hasta ahora): es una forma de
estructurar programas como una receta, en donde se siguen una serie de
pasos en forma de funciones y bloques de código secuencialmente hasta
completar una tarea.

Programación orientada a objetos (POO): es una forma de estructurar
programas en torno a objetos, sus propiedades y comportamientos

"""

# Clases e instancias
# Las clases se usan para estrcuturar datos y son definidas por el usuario.
# Las clases definen funciones llamadas METODOS. Una instancia es un objeto
# particular construido a partir de la clase que contiene datos reales
# Los ATRIBUTOS de la clase definen las propiedades

class Perro:
    # defino los atributos
    # Atributo de clase
    especie = "Canis familiaris"     # atributo con el mismo valor para
                                    # todas las instancia

    # método especial para crear la instancia
    def __init__(self, nombre, edad):   # atributo mutable
        """Crea los atributos de la instancia"""
        self.nombre = nombre
        self.edad = edad

# Creo dos instancias de la clase perro
sultan = Perro("Sultan",9)
firulai = Perro("Firulai",4)

# imprimo la edad de firulai
print(firulai.edad)

# imprimo el nombre de sultan
print(sultan.nombre)

# imprimo el atributo de clase

# imprimo la edad de firulai
print(firulai.especie)

# imprimo la edad de firulai
print(sultan.especie)

# los atributos se pueden modificar
sultan.edad = 7
print(f"Edad de sultan: {sultan.edad}")

# modifico el valor de especie en sultan, no cambia en firulai
sultan.especie = "Raza canina"
print(firulai.especie)

### Reescribir la clase Perro pero con más métodos

class Perro:
    especie = "Canis familiaris"

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

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

    def ladrar(self, sonido):
        return f"{self.nombre} dice {sonido}"

tronco = Perro("Tronco",4)
print(tronco.descripcion())
print(tronco.ladrar("Woof Woof"))

### Mejoremos la descripción con __str__
class Perro:
    especie = "Canis familiaris"

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

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

    def ladrar(self, sonido):
        return f"{self.nombre} dice {sonido}"

duque = Perro("Duque",8)
print(duque)
print(tronco.ladrar("Guau"))

"""
Ej: Script que crea una clase Auto con dos atributos de instancia: color
y kilometraje. Luego crear dos instancias, uno azul con 20000 kms y otro
rojo con 30000 kms. Imprimir sus colores y kilometrajes.
"""
class Auto:
    def __init__(self, color, kilometraje):
        self.color = color
        self.kilometraje = kilometraje

auto_azul = Auto("azul", 20_000)
auto_rojo = Auto(color="rojo", kilometraje=30_000)
print(type(auto_azul))


for auto in (auto_azul, auto_rojo):
    print(f"El auto {auto.color} tiene un kilometraje de {auto.kilometraje} kms")

##### HERENCIA
"""
Una clase hereda a otra cuando asume sus atributos y mètodos. Las clases
recien formadas son secundarias o hijas y las otras primarias o padres

Las clases secundarias pueden anular o ampliar los atributos y métodos
"""
class Perro:
    especie = "Canis familiaris"

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

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

    def ladrar(self, sonido):
        return f"{self.nombre} dice {sonido}"

miles = Perro("miles",4,"Jack Rusell Terrier")
jack = Perro("jack",3,"Bulldog")
jim = Perro("jim",5,"Bulldog")

print(miles.ladrar("Yap"))
print(jack.ladrar("Guau"))
print(jim.ladrar("Guau")) # repetitivo, el sonido debe ser de la raza

# para solucionar creamos una clase hija para cada raza de perro
class Perro:
    especie = "Canis familiaris"

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

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

    def ladrar(self, sonido):
        return f"{self.nombre} dice {sonido}"

class JackRusellTerrier(Perro):
    def ladrar(self, sonido="Yap"):
        return f"{self.nombre} dice {sonido}"

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

miles = JackRusellTerrier("miles",4)
jack = Bulldog("jack",3)
jim = Bulldog("jim",50)

print(jim.ladrar())

### POLIMORFISMO
# el polimorfismo nos posibilita invocar un método que devolverà distintos
# resultados dependiendo del objeto

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

    def hablar(self):
        print("Miau")

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

    def hablar(self):
        print("Guau")

def EscucharMascota(animal):
    animal.hablar()

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

EscucharMascota(cacho)
EscucharMascota(fufu)

# Con herencia
class Animal:
    def hablar(self):
        print("Hola....")

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

    def hablar(self):
        print("Miau")

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

    def hablar(self):
        print("Guau")

ozzy = Perro("ozzy")
milka = Gato("milka")

milka.hablar()
ozzy.hablar()

###### HERENCIA MULTIPLE

class ClaseA:
    def __init__(self):
        self.x = 1

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

class ClaseC(ClaseA, ClaseB):
    pass

class ClaseD(ClaseB, ClaseA):
    pass

objeto1 = ClaseC()
objeto2 = ClaseD()

print(objeto1.x) # imprime 1
print(objeto2.x) # imprime 2