objetos

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

POO es un paradigma de programación: crea un modelo que se pueda
aplicar para resolver un problema. En este modelo existen objetos de
determinada clase que tienen atributos y pueden hacer cosas

EJ: para modelar un aeropuerto tengo que pensar en objetos: aviones,
equipajes, personas, vuelos, etc. Por ejemplo, si pienso en el objeto
avion, tengo como atributos: autonomia de vuelo, modelo, fabricante,
capacidad, aerolinea, etc. Las cosas que puede hacer son: volar, aterrizar, despegar, recargar combustible, etc...

RESUMIENDO:
Un objeto tiene atributos (adjetivos) y hace cosas (llamados a veces
métodos) (verbos)

CLASE: es una abstracción, es la generalización de un objeto
EJ:
Clase Instructor
Objeto o instancia de clase Instructor: alejandro


class Perro:
    """Clase que modeliza un perro"""
    # Atributos de clase
    especie = "Canis familiaris"

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

# creo dos instancias de la clase perro:
sultan = Perro("Sultan", 7, 5)
firulai = Perro("Firulai", 4, 3)

# imprimo el nombre del objeto sultan
print(sultan.nombre)

# imprimo la edad del objeto firulai
print(firulai.edad)

# podemos acceder al atributo de clase
print(sultan.especie)

# los objetos son mutables por default
firulai.peso = 8
print(firulai.peso)

# cada objeto tiene su propia copia del atributo de clase
firulai.especie = "Can doméstico"
print(sultan.especie)
print(firulai.especie)


# Reescribimos la clase pero con métodos
class Perro:
    """Clase que modeliza un perro"""
    # Atributos de clase
    especie = "Canis familiaris"

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

    def descripcion(self):
        """Describe el animal"""
        return f"{self.nombre} tiene {self.edad} años y pesa {self.peso} kgs"

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

tronco = Perro("Tronco", 6, 12)

print(tronco.descripcion())
print(tronco.ladra("Woof Woof"))


# Reescribimos la clase pero con métodos mágicos o dunder methods
class Perro:
    """Clase que modeliza un perro"""
    # Atributos de clase
    especie = "Canis familiaris"

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

    def __str__(self):
        """Describe el animal"""
        return f"{self.nombre} tiene {self.edad} años y pesa {self.peso} kgs"

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

tronco = Perro("Tronco", 6, 12)

print(tronco)
print(tronco.ladra("Woof Woof"))


# Ejercicio: crear una clase auto con dos atributos: color y kilometraje
# Instanciar dos objetos: un auto azul con 20000 kms y otro rojo con
# 30000 kms. Imprimir sus colores y kilometraje
class Auto:
    """Clase Auto"""

    def __init__(self, color, kilometraje):
        self.color = color
        self.kilometraje = kilometraje

    def __str__(self) -> str:
        return f"Color: {self.color} -- Kilometraje {self.kilometraje} Kms"


primer_auto = Auto("Azul", 20000)
segundo_auto = Auto("Rojo", 30000)

print(primer_auto)
print(segundo_auto)


# Encapsulamiento: encapsular es ocultar el estado interno de un objeto
# (o sea sus atributos) NO SE RECOMIENDA EN PYTHON PORQUE COMPLEJIZA
# EL CODIGO

class Persona:
    def __init__(self,nombre):
        self.nombre = nombre
        # self.nacionalidad = "argentina" no encapsulado
        self.__nacionalidad = "argentina"  # encapsulado, atributo privado

ana = Persona("Ana")
print(ana.nombre)
print(ana.nacionalidad) # da error


class Perro:
    """Clase que modeliza un perro"""
    # Atributos de clase
    especie = "Canis familiaris"

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

    def __str__(self):
        """Describe el animal"""
        return f"{self.nombre} tiene {self.edad} años y pesa {self.peso} kgs"

    def __ladra(self, sonido): # método encapsulado (privado)
        return f"{self.nombre} dijo {sonido}"

tronco = Perro("Tronco", 6, 12)

print(tronco)
print(tronco.ladra("Woof Woof")) # da error


# para acceder a atributos privados puedo usar GET SET DEL
class Persona:
    def __init__(self,nombre):
        self.nombre = nombre
        self.__nacionalidad = "argentina"  # encapsulado, atributo privado

    def getnacionalidad(self):
        return self.__nacionalidad

    def setnacionalidad(self,nacionalidad):
        self.__nacionalidad = nacionalidad

    def delnacionalidad(self):
        del self.__nacionalidad


ana = Persona("Ana")
print(ana.nombre)
ana.setnacionalidad("peruana")
print(ana.getnacionalidad())


# HERENCIA
# es el proceso por el cual una clase llamada secundaria o hija asume
# los atributos y métodos de otra clase llamada principal o padre.
# Las clases secundarias pueden modificar o anular los métodos o
# atributos de los padres

class Perro:
    """Clase que modeliza un perro"""
    # Atributos de clase
    especie = "Canis familiaris"

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

    def __str__(self):
        """Describe el animal"""
        return f"{self.nombre} tiene {self.edad} años y pesa {self.peso} kgs"

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

tronco = Perro("Tronco", 6, 12, "Collie")
miles = Perro("Miles", 2, 6, "Bulldog")
jim = Perro("Jim", 6, 4, "Bulldog")

print(tronco.ladra("Woof Woof"))
print(miles.ladra("Guau"))
print(jim.ladra("Guau"))

# El ladrido podría ser una característica de la raza, para modelizar
# eso creo clases hijas

class Perro:
    """Clase que modeliza un perro"""
    # Atributos de clase
    especie = "Canis familiaris"

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

    def __str__(self):
        """Describe el animal"""
        return f"{self.nombre} tiene {self.edad} años y pesa {self.peso} kgs"

    def ladra(self, sonido):
        return f"{self.nombre} grita {sonido}"


class Collie(Perro):
    def ladra(self, sonido="Woof Woof"): # sobreescribo la clase padre
        return f"{self.nombre} dijo {sonido}"

class Bulldog(Perro):
    def ladra(self, sonido="Guau"): # sin sobreescribir
        return super().ladra(sonido) # actualiza los cambios del padre

tronco = Collie("Tronco", 6, 12)
miles = Bulldog("Miles", 2, 6)
jim = Bulldog("Jim", 6, 4,)

print(tronco.ladra())
print(miles.ladra())
print(jim.ladra())


# POLIMORFISMO: dos clases diferentes con metodos de igual nombre
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 mascota(animal):
    return animal.hablar()

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

print(f"{fufu.nombre} dice {mascota(fufu)}")
print(f"{cacho.nombre} dice {mascota(cacho)}")

# lo mismo pero con herencia
class Animal():
    def hablar(self):
        return "Hola..."

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"{fufu.nombre} dice {fufu.hablar()}")
print(f"{cacho.nombre} dice {cacho.hablar()}")

'''
# herencia multiple

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

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


class ClaseHija(ClaseA, ClaseB): # se hereda de derecha a izquierda
    pass

objeto = ClaseHija()
print(objeto.y)
print(objeto.x)