😀CUENTA BANCARIA

// Some code

```python
#!APP DE CUENTA BANCARIA (P4IM0NB4NK)


#!clases


#clase 1 persona nombre y apellido y cuenta
#clase 1 persona nombre y apellido y cuenta, con metodo funcion 1 crea cliente y devuelve un cliente ya creado
class Persona:  
    def __init__(self,nombre,apellido,cuenta):
        self.nombre = nombre
        self.apellido = apellido
        self.cuenta = cuenta  
    def datos_cliente(self):
        self.nombre = input("((BIENVENIDO A P4IM0NB4NK))\n Por favor ingrese su nombre para agregarlo al sistema: ")
        print("="*30+"\n")
        self.apellido = input("Ahora porfavor ingrese su apellido: ")							
        print("="*30+"\n")
        self.cuenta = input("Ingrese por favor su numero de cuenta: ")
        print("="*30+"\n")
        print('Usuario creado exitosamente: ') 
        print('Nombre de usuario: ' + self.nombre +" "+ self.apellido) 
        print('Numero de cuenta:' + self.cuenta)
        print("="*30+"\n")
        	
persona = Persona(" ", " ", " ")





#clase 2 cliente hereda de persona mas numero de cuenta y balance y tres metodos -imprimir cliente y su balance de cuenta , -depositar, -retirar. 
#codigo para q el usuario elija -deoositar o - retirar o -salir (con loop, debe ir llevando la cuenta del balance )
class Cliente(Persona):
    def __init__(self,balanze):
        self.obtener_datos()                                                              #?de esta forma obtenemos los self datos nombre apellido cuenta heredados de la clsae persona, para poder ser usados y llamados en unn texto dentro de esta clase
        super().__init__(self.nombre,self.apellido,self.cuenta)
        self.balanze = balanze   
    def depositar(self):
        positivo = int(input("Ingrese cuanto dinero quiere ingresar a su cuenta: $"))
        self.balanze = self.balanze+positivo
    def retirar(self):
        negativo = int(input("Ingrese cuanto dinero quiere retirar: $"))
        if negativo > int(self.balanze):                                                   #?con esta condicion,  transformo con casting int(self.balance) para que compare dos tipos iguales int y responda si se exedio de retiro por que su balance es menor, o si no que se retire el dinero y se guarde su balance.
            print("El monto a retirar supera su saldo actual. Porfavor ingrese un monto menor ")
        else:
            self.balanze = self.balanze-negativo
    def balance(self):
        print(f"Sr.{self.nombre} {self.apellido}, El saldo total de su cuenta Nº{self.cuenta}, es de: (( ${self.balanze} ))\n"+"/"*30)
    def obtener_datos(self):
        super().datos_cliente()    
        
cliente = Cliente(0)
cliente.balance() 


				
			
						


#!funciones
												

#funcion 1 para decidir si ingreasar o no al sistema appbanck
def entrar():
    decicion = input("quiere ingresar a nuestro sistema de gestion bancaria: (si o no) ")
    return decicion



#funcion 2 brinda el menu de opciones
def opciones():
    print("="*30)
    print("((BIENVENIDO A APPBANCK)) elija el numero de opcion que desea realizar: ")
    print("1- Depositar\n2- Retirar\n3- Ver balance\n"+"="*30)
    opcion =  int(input("porfavor elija la opcion: "))
    return opcion







#!ejecucion del programa


#funcion 3 es la q se encargaria de manejar todo el programa ((P4IM0NB4NK))y de mantener al usuario en elecciones de las opciones de gestion que se le da.
def P4IM0NB4NK():
    datos_clientes = persona.datos_cliente
    if entrar()=="si":
        opcion = opciones()
        if opcion == 1:
            print("="*30+"\n")
            cliente.depositar()
            print("\n"+"="*30+"\n")
            cliente.balance()
            print("="*30+"\n")
            continuar = input("Desea realizar otra operacion: (si o no) ")
            if continuar == "si":
                P4IM0NB4NK()
            else:
                print("="*30 +"\nMuchas gracias por usar nuestra  app amigo ")
        if opcion == 2:
            print("="*30+"\n")
            cliente.retirar() 
            print("\n"+"="*30+"\n")
            cliente.balance()
            print("="*30+"\n")
            continuar = input("Desea realizar otra operacion: (si o no) ")
            if continuar == "si":
                P4IM0NB4NK()
            else:
                print("="*30 +"\nMuchas gracias por usar nuestra  app amigo ") 
        if opcion == 3:
            print("="*30+"\n")
            cliente.balance() 
            print("="*30+"\n")
            continuar = input("Desea realizar otra operacion: (si o no) ")
            if continuar == "si":
                P4IM0NB4NK()
            else:
                print("="*30 +"\nMuchas gracias por usar nuestra  app amigo ")    
    else:
        print("="*30+"\nGracias sera la proxima amigo")   
        
        
        

P4IM0NB4NK()



#! by P4IM0NB4NK
```

CODEO DEL DIA 7:

// Some code

```python
#!programacion orientada a objetos  oop    o  poo



#creando una clase
class Pajaros:                                         #por convencion el nombre de la clase se la comienza en mayuscula
    pass




#creando un objeto de esta clase osea una instancia
mi_pajaro = Pajaros()


print(mi_pajaro)                                       #vemos que nos dic que ya es un objeto

print(type(mi_pajaro))                                 #es de tyipo main


#ejemplo siguen ciendo de la misma clase Pajaros, pero de otra especie cada uno, con caracteristicas difereentes qie le demos
otro_pajaro = Pajaros()                                #podemos crear otor objeto osea otro pajaro con la misma clase para luego darle otras propiedades, y ya vemos que no la crea con otro numero de instancia o ubicacion


print(otro_pajaro)




#practicas



class Personaje:
    pass

harry_potter = Personaje()




class Dinosaurio:
    pass

velociraptor = Dinosaurio()
tiranosaurio_rex = Dinosaurio()
braquiosaurio = Dinosaurio()





class PlataformaStreaming:
    pass


netflix = PlataformaStreaming()
hbo_max = PlataformaStreaming()
amazon_prime_video = PlataformaStreaming()








#!atributos de instancias



class Pajaro:
#def como funcion o metodo + init como constructor del atributo que le daremos + self es la instancia del objeto a crear, se puede usar cualquier otra palabra, pero por convencion se usa self + mas el atributo color que es el que creamos
    def __init__(self, color):
        #atributo (color) = parametro ("verde")
        self.color = color
        
    
loro = Pajaro("verde")

    
print(loro.color)








class Pajaro:
#def como funcion o metodo + init como constructor del atributo que le daremos + self es la instancia del objeto a crear, se puede usar cualquier otra palabra, pero por convencion se usa self + mas el atributo color que es el que creamos
    def __init__(self, color, especie):         #podemos darle varios atributos
        #atributo (color) = parametro ("verde")
        self.color = color
        self.especie = especie
    
loro = Pajaro("verde","loro")

    
print(loro.especie)








class Pajaro:
#def como funcion o metodo + init como constructor del atributo que le daremos + self es la instancia del objeto a crear, se puede usar cualquier otra palabra, pero por convencion se usa self + mas el atributo color que es el que creamos
    def __init__(self, color, especie):         #podemos darle varios atributos
        #atributo (color) = parametro ("verde")
        self.color = color
        self.especie = especie
    
loro = Pajaro("verde","loro")

    
print(f"mi pajaro es un ave de la especie ({loro.especie}) y tiene un plumaje de color ({loro.color}) muy bello")










#!atributos de clase

class Pajaro:
    
    alas = "largas"               #le damos este atributo a todos los pajaros que creamos en esta clase de esta forma. y lo llamamos de la misma forma a posterior.


#def como funcion o metodo + init como constructor del atributo que le daremos + self es la instancia del objeto a crear, se puede usar cualquier otra palabra, pero por convencion se usa self + mas el atributo color que es el que creamos
    def __init__(self, color, especie):         #podemos darle varios atributos
        #atributo (color) = parametro ("verde")
        self.color = color
        self.especie = especie
    
loro = Pajaro("verde","loro")

    
print(f"mi pajaro es un ave de la especie ({loro.especie}) y tiene un plumaje de color ({loro.color}) muy bello, y tienen alas muy {loro.alas}")      #se lo sigue llamando igual que a los otros atributos









#pradcticas


class Casa:
    def __init__(self,color,cantidad_pisos):
        self.color = color
        self.cantidad_pisos = cantidad_pisos

casa_blanca = Casa("blanco",4)





class Cubo:
    caras = 6
    
    def __init__(self,color):
        self.color = color


cubo_rojo = Cubo("rojo")  







class Personaje:
    real = False
    def __init__(self,especie,magico,edad):
        self.especie = especie
        self.magico = magico
        self.edad = edad
        
harry_potter = Personaje("Humano",True,17) 

print(f"Harry es de la especie {harry_potter.especie}, dicen que tiene magia y eso es {harry_potter.magico}, teniendo tan solo {harry_potter.edad} años")







#!metodos





class Pajaro:
    
    alas = "largas"               #le damos este atributo de clase a todos los pajaros que creamos en esta clase de esta forma. y lo llamamos de la misma forma a posterior.


#def como funcion o metodo + init como constructor del atributo que le daremos + self es la instancia del objeto a crear, se puede usar cualquier otra palabra, pero por convencion se usa self + mas el atributo color que es el que creamos
    def __init__(self, color, especie):         #podemos darle varios atributos
        #atributo (color) = parametro ("verde")
        self.color = color
        self.especie = especie
    def cantar(self):                               #el metodo tambien lo hacemos como una funcion , en este caso para que cuando se ejecute la funcion el pajaro imprima y haga pio pio
        print("pio pio y soy de color {}".format(self.color))   #con {}".format(self+atributo color) le podemos pasr y hacer uso de atributos de instancia que ya le hemos dado
    def volar(self, metros):                        #tambien creamos otro metodo o funcion para que el pajaro vuele la cantidad de metros que le ingresemos
        print(f"el pajaro ha volado {metros} metros")
        
        
        




    
loro = Pajaro("verde","loro")

loro.cantar()                       #dichas funciones las llamamos o invocamos para quye se realizen, de esta forma
loro.volar(100)                     #dichas funciones las llamamos o invocamos para quye se realizen, de esta forma, y en este caso le pasamos el parametro 100 dentro de la funcion
    
print(f"mi pajaro es un ave de la especie ({loro.especie}) y tiene un plumaje de color ({loro.color}) muy bello, y tienen alas muy {loro.alas}")      #se lo sigue llamando igual que a los otros atributos







#practicas




class Perro:
    def ladrar(self):
        print("Guau!")
 
perro = Perro()
        
perro.ladrar() 





class Mago:
    def lanzar_hechizo(self):
        print("¡Abracadabra!")
    
merlin = Mago()

merlin.lanzar_hechizo()






class Alarma:
    def postergar(self,cantidad_minutos):
        print(f"La alarma ha sido pospuesta {cantidad_minutos} minutos")

alarma = Alarma() 

alarma.postergar(15)








#!decoradores -metodos de instancia -metodos de clase @classmethod -metodos estaticos @staticmethod





#!metodos de instancias

#?accedemos y modificamos atributos del objeto
class Pajaro:
    
    alas = "largas"               #le damos este atributo de clase a todos los pajaros que creamos en esta clase de esta forma. y lo llamamos de la misma forma a posterior.


#def como funcion o metodo + init como constructor del atributo que le daremos + self es la instancia del objeto a crear, se puede usar cualquier otra palabra, pero por convencion se usa self + mas el atributo color que es el que creamos
    def __init__(self, color, especie):         #podemos darle varios atributos
        #atributo (color) = parametro ("verde")
        self.color = color
        self.especie = especie
    def cantar(self):                               #el metodo tambien lo hacemos como una funcion , en este caso para que cuando se ejecute la funcion el pajaro imprima y haga pio pio
        print("pio pio y soy de color {}".format(self.color))   #con {}".format(self+atributo color) le podemos pasr y hacer uso de atributos de instancia que ya le hemos dado
    def volar(self, metros):                        #tambien creamos otro metodo o funcion para que el pajaro vuele la cantidad de metros que le ingresemos
        print(f"el pajaro ha volado {metros} metros")
    def pintar_negro(self):
        self.color = "blanco"                       #?aca le cambiamos el color que le dimos con self.color, decignandole nuevamente con el mismo atributo , el parametro de color blanco
        print(f"ahora el pajaro es {self.color}")  



loro = Pajaro("verde","loro")

loro.pintar_negro()








#?acceder a otros metodos
class Pajaro:
    
    alas = "largas"               #le damos este atributo de clase a todos los pajaros que creamos en esta clase de esta forma. y lo llamamos de la misma forma a posterior.


#def como funcion o metodo + init como constructor del atributo que le daremos + self es la instancia del objeto a crear, se puede usar cualquier otra palabra, pero por convencion se usa self + mas el atributo color que es el que creamos
    def __init__(self, color, especie):         #podemos darle varios atributos
        #atributo (color) = parametro ("verde")
        self.color = color
        self.especie = especie
    def cantar(self):                               #el metodo tambien lo hacemos como una funcion , en este caso para que cuando se ejecute la funcion el pajaro imprima y haga pio pio
        print("pio pio y soy de color {}".format(self.color))   #con {}".format(self+atributo color) le podemos pasr y hacer uso de atributos de instancia que ya le hemos dado
    def volar(self, metros):                        #tambien creamos otro metodo o funcion para que el pajaro vuele la cantidad de metros que le ingresemos
        print(f"el pajaro ha volado {metros} metros")
        self.cantar()                                #?desde un metod en funcion, podemos accedder a otros metodos declarados
        
        
        




    
loro = Pajaro("verde","loro")

loro.volar(100)













#?modificar el estado de la clase
class Pajaro:
    
    alas = "largas"            #?este es el setado actual de la clase   #le damos este atributo de clase a todos los pajaros que creamos en esta clase de esta forma. y lo llamamos de la misma forma a posterior.


#def como funcion o metodo + init como constructor del atributo que le daremos + self es la instancia del objeto a crear, se puede usar cualquier otra palabra, pero por convencion se usa self + mas el atributo color que es el que creamos
    def __init__(self, color, especie):         #podemos darle varios atributos
        #atributo (color) = parametro ("verde")
        self.color = color
        self.especie = especie
    def cantar(self):                               #el metodo tambien lo hacemos como una funcion , en este caso para que cuando se ejecute la funcion el pajaro imprima y haga pio pio
        print("pio pio y soy de color {}".format(self.color))   #con {}".format(self+atributo color) le podemos pasr y hacer uso de atributos de instancia que ya le hemos dado
    def volar(self, metros):                        #tambien creamos otro metodo o funcion para que el pajaro vuele la cantidad de metros que le ingresemos
        print(f"el pajaro ha volado {metros} metros")
        
        
        




    
loro = Pajaro("verde","loro")

loro.alas = "cortas"                  #?al final nos permite tambien podemos modificar su estado de clase por el parametro que le decignemos, en este caso "cortas"
print(loro.alas)















#!metodos de clases


#?@classmethod , (no pueden acceder a los atributos de instancias ej: self.color da error) pero si podemos hacerlo con los atributoas y parametros de clase, ej: alas
class Pajaro:
    
    alas = "largas"               #le damos este atributo de clase a todos los pajaros que creamos en esta clase de esta forma. y lo llamamos de la misma forma a posterior.


#def como funcion o metodo + init como constructor del atributo que le daremos + self es la instancia del objeto a crear, se puede usar cualquier otra palabra, pero por convencion se usa self + mas el atributo color que es el que creamos
    def __init__(self, color, especie):         #podemos darle varios atributos
        #atributo (color) = parametro ("verde")
        self.color = color
        self.especie = especie
    def cantar(self):                               #el metodo tambien lo hacemos como una funcion , en este caso para que cuando se ejecute la funcion el pajaro imprima y haga pio pio
        print("pio pio y soy de color {}".format(self.color))   #con {}".format(self+atributo color) le podemos pasr y hacer uso de atributos de instancia que ya le hemos dado
    def volar(self, metros):                        #tambien creamos otro metodo o funcion para que el pajaro vuele la cantidad de metros que le ingresemos
        print(f"el pajaro ha volado {metros} metros")
    @classmethod                                    #?con @classmethod no nesecitamos de ninguna instancia para poder ejecutarce
    def poner_huevos(cls, cantidad):
        print(f"puso {cantidad} huevos")            #?nos imprime con la cantidad que le ingresamos abajo a la funcion a posterior
        cls.alas = "plumudas"                       #?con cls, similar como con self, podemos llamar a un atributoi de clase opara poder modificar su parametro, aca ej: plumudas
        print(Pajaro.alas)                          #?imprimimos el atributo de clase ya modificado



    
'''loro = Pajaro("verde","loro")'''                #?aca vemos que no nececita ninguna instancia declarada para poder ejecutarse



Pajaro.poner_huevos(5)








#!metodos estaticos 


#?@staticmethod (este metodo, no se refiere a ningun elemento de clase ni de instancias, Por tanto no trabaja con ningun argumento, ni atributo ni parametro de clase e instancia)
class Pajaro:
    
    alas = "largas"               #le damos este atributo de clase a todos los pajaros que creamos en esta clase de esta forma. y lo llamamos de la misma forma a posterior.


#def como funcion o metodo + init como constructor del atributo que le daremos + self es la instancia del objeto a crear, se puede usar cualquier otra palabra, pero por convencion se usa self + mas el atributo color que es el que creamos
    def __init__(self, color, especie):         #podemos darle varios atributos
        #atributo (color) = parametro ("verde")
        self.color = color
        self.especie = especie
    def cantar(self):                               #el metodo tambien lo hacemos como una funcion , en este caso para que cuando se ejecute la funcion el pajaro imprima y haga pio pio
        print("pio pio y soy de color {}".format(self.color))   #con {}".format(self+atributo color) le podemos pasr y hacer uso de atributos de instancia que ya le hemos dado
    def volar(self, metros):                        #tambien creamos otro metodo o funcion para que el pajaro vuele la cantidad de metros que le ingresemos
        print(f"el pajaro ha volado {metros} metros")
    @staticmethod                                   #?(este metodo, no se refiere a ningun elemento de clase ni de instancias, Por tanto no trabaja con ningun argumento, ni atributo ni parametro de clase e instancia)
    def mirar():
        print("Te mira fijo a los ojos") 
        
        
        




    
'''loro = Pajaro("verde","loro")'''                #?no requiere de una instancia para ejecutarce tampoco

Pajaro.mirar()                                     #?lo invocamos 









#practicas





class Mascota:
    @staticmethod
    def respirar():
        print("Inhalar... Exhalar")
    
Mascota.respirar()




class Jugador:
    vivo = False
    @classmethod
    def revivir(cls):
        cls.vivo = True
        print(Jugador.vivo)
        
Jugador.revivir() 








class Personaje:
    def __init__(self, cantidad_flechas):
        self.cantidad_flechas = cantidad_flechas
    def lanzar_flecha(self):
        self.cantidad_flechas = self.cantidad_flechas - 1
        print(self.cantidad_flechas)
    
    
flechas = Personaje(10)
flechas.lanzar_flecha()







#!herencia (se puede usasr mucho para no repetir codigo, como se suele decir DRY )



class Animal:
    pass

class Perro(Animal):         #?poniendo el nombre de la clase que queremeos que herede propiedades nuestro class lo ponemos entre parentesis
    pass

class Gato(Animal):
    pass

class Pez(Animal):
    pass



print(Perro.__bases__)            #?la propiedad __bases__ nos permite ver de quien hereda propiedades nuestro elemento o class en este caso. Seria similar a un type

print(Animal.__subclasses__())    #?la propiedad __subclasess nos devuelve las clases que toman su herencia











class Animal:
    def nacer(self):
        print("el animal nacio")

class Perro(Animal): 
    pass

class Gato(Animal):
    pass

class Pez(Animal):
    pass



gatito = Gato()
gatito.nacer()                             #?vemos como al herredar las propiedades de Animal, nos aparece y heredo el metodo Nacer 












class Animal:
    def __init__(self,edad,color):          #?le damos como ejemplo do atributos de instancia con parametros, los cuales los heredara a sus clases hijos
        self.edad=edad
        self.color= color
    def nacer(self):
        print("el animal nacio")

class Perro(Animal): 
    pass

class Gato(Animal):
    pass

class Pez(Animal):
    pass



gatito = Gato(12,"marron")                   #?vemos como ahora al heredar dos atributos de class Animal, nuestro class Gato se queja y nos solicita las dos propoiedades o parametros para sus dos atributos heredados
gatito.nacer()
print(gatito.color)
print(gatito.edad)







#practicas




class Persona:
    def __init__(self, nombre, edad):
        self.nombre = nombre
        self.edad = edad
class Alumno(Persona):  
    pass






class Mascota:
    def __init__(self,edad,nombre,cantidad_patas):
        self.edad = edad
        self.nombre = nombre
        self.cantidad_patas = cantidad_patas
class Perro(Mascota):
    pass







class Vehiculo:
    def acelerar(self):
        pass
    def frenar(self):
        pass
class Automovil(Vehiculo):
    pass






#!herencia extendida LOS ELEMENTOS HIJOS(pueden tener metodos heredados, metodos heredados y luego modificados, o sus propioos metos nuevos) y herencias multiples (osea de heredar atributos de varias clases padres )







#?modificar metodos o atributos heredados, agregar nuevos metodos a una clase heredera

class Animal:
    def __init__(self,edad,color):          #?le damos como ejemplo do atributos de instancia con parametros, los cuales los heredara a sus clases hijos
        self.edad=edad
        self.color= color
    def nacer(self):
        print("el animal nacio")
    def hablar(self):                        #?le damos un meto hablar para que luego se lo herede a otro class y al mismo lo modificaremso a posteriori
        print("este animal no habla")    

class Perro(Animal):
    def hablar(self):                        #?dentro de una clase que heredo los atributos, llamamos al metodo a modificar con su mismo nombre con el qu figura en su padre, y lo modificamos, y se respetara esa modificacion a la hora de imprimirlo o llamarlo
        print("este animal ladra")
    def nuevo_metodo(self):
        print("nuevo metodo dado al class hijo")    #?nuevo metodo dado a una clase que hereda 

class Gato(Animal):
    pass

class Pez(Animal):
    pass



perrito = Perro(10,"negro")

perrito.hablar()
perrito.nuevo_metodo()









#?agregar nuevos atribustos de instancia a una clase heredera




class Animal:
    def __init__(self,edad,color):          #?le damos como ejemplo do atributos de instancia con parametros, los cuales los heredara a sus clases hijos
        self.edad=edad
        self.color= color
    def nacer(self):
        print("el animal nacio")

class Perro(Animal): 
    def __init__(self, edad, color, velocidad):     #?esta es -1- una forma de agregar atributos de instancia unicos a una clase heredera de un padre
        self.edad = edad
        self.color = color
        self.velocidad = velocidad
               
        
class Gato(Animal):
    def __init__(self, edad, color, gordo):
        super().__init__(edad, color, gordo)        #?esta es -2- forma, con el uso de super()__init__ hacemos un codigo mucho mas compacto, para evitar ir declarando una por una cada atributo con self
        
    

class Pez(Animal):
    pass





padre = Animal(20,"rojo")
perros = Perro(30,"naranja","100km/h")     #?vemos como nos pide el tercer atributo nuevo que le dimos a la clase heredera, que este atributo nuevo su padre no lo va a tener











#?herencias multiples

class Padre:                              #?padre dara su herencia al hijo
    pass

class Hijo(Padre):                        #?hijo hereda lo del padre, y dara sus propiedades mas las que heredo de su padre, al nieto
    pass

class Nieto(Hijo):                        #?el nieto heredo los del Hijo y el padre
    pass












class Padre:
    def hablar(self):
        print("hola")
    pass

class Hijo(Padre):         
    pass

class Nieto(Hijo):
    pass




mi_nieto = Nieto()      
mi_nieto.hablar()             #? aca vemos como nieto heredo el metodo hola del padre que se transmitio atraves de hijo











#?herencia dada de  multiples clases

class Padre:
    def hablar(self):
        print("hola")
class Madre:
    def reir(self):
        print("riooooo")    

class Hijo(Padre, Madre):         #?agregando a madre , le decimos que tambien herede lo de madre a la ves lo de padre y heredarlo de generacion en generacion
    pass

class Nieto(Hijo):                #?por ende nieto tendra tambien las dos propiedades de clases que heredo hijo
    pass




mi_nieto = Nieto()
mi_nieto.hablar()
mi_nieto.reir()













class Padre:
    def hablar(self):
        print("hola")
class Madre:
    def reir(self):
        print("riooooo")  
    def hablar(self):             #?agregmos un metodo igual que el de padre para ver cual tiene percistencia, y aca tendria percistencia Padre por que dentro del parentecis heredo primero de padre, si fuese alrevese tomaria el de madre   
        print("que tal")      

class Hijo(Padre, Madre):         #?agregando a madre , le decimos que tambien herede lo de madre a la ves lo de padre y heredarlo de generacion en generacion
    pass

class Nieto(Hijo):                #?por ende nieto tendra tambien las dos propiedades de clases que heredo hijo
    pass





mi_nieto = Nieto()
mi_nieto.hablar()
print(Nieto.__mro__)             #?__mro__ metod order resolucion, seria la ruta en el orden que que se resuelve un metodo, para el caso de nieto en este ejmplo












#practicas




class Padre():
    def trabajar(self):
        print("Trabajando en el Hospital")

    def reir(self):
        print("Ja ja ja!")

class Madre():
    def trabajar(self):
        print("Trabajando en la Fiscalía")
        
class Hija(Madre, Padre):
    pass







class Vertebrado:
    vertebrado = True

class Ave(Vertebrado):
    tiene_pico = True
    def poner_huevos(self):
        print("Poniendo huevos")

class Reptil(Vertebrado):
    venenoso = True

class Pez(Vertebrado):
    def nadar(self):
        print("Nadando")
    def poner_huevos(self):
        print("Poniendo huevos")

class Mamifero(Vertebrado):
    def caminar(self):
        print("Caminando")
    def amamantar(self):
        print("Amamantando crías")

class Ornitorrinco(Ave, Reptil, Pez, Mamifero):
    pass











class Padre():
    color_ojos = "marrón"
    tipo_pelo = "rulos"
    altura = "media"
    voz = "grave"
    deporte_preferido = "tenis"
    def reir(self):
        return "Jajaja"
    def hobby(self):
        return "Pinto madera en mi tiempo libre"
    def caminar(self):
        return "Caminando con pasos largos y rápidos"
        
class Hijo(Padre):
    def hobby(self):
        return "Juego videojuegos en mi tiempo libre"












#!Polimorfismo (muchas - formas) (nos permite ejecutar en dos objetos o clases distintas, metodos llamados con el mismo nombre sin problema )





class Vaca:                                          #?creo una clase objeto 
    def __init__(self, nombre):
        self.nombre = nombre
    def hablar(self):                                #?creamos un metodo funcion igual llamado al de la clase siguiente
        print(self.nombre + " dice muuu")    
        
        

class Oveja:                                         #?creo una clase objeto 
    def __init__(self, nombre):
        self.nombre = nombre
    def hablar(self):
        print(self.nombre + " dice beee")   




vaca1 = Vaca("aurora")                               #?creo la instancias
oveja1 = Oveja("shaun")



vaca1.hablar()                                       #?esto es lo que nos permite l polimorfismo, llanmar a dos classes o objetos con un metodo nombrado igual para las dos y no nos causa ningun conflicto. se ejecutan bien ambos por separado
oveja1.hablar()










#?vamos a crear una lista para un bucle para ver mejor el uso deel polimorfismo
class Vaca:                                          #?creo una clase objeto 
    def __init__(self, nombre):
        self.nombre = nombre
    def hablar(self):                                #?creamos un metodo funcion igual llamado al de la clase siguiente
        print(self.nombre + " dice muuu")    
        
        

class Oveja:                                         #?creo una clase objeto 
    def __init__(self, nombre):
        self.nombre = nombre
    def hablar(self):
        print(self.nombre + " dice beee")   




vaca1 = Vaca("aurora")                               #?creo la instancias
oveja1 = Oveja("shaun")



animales = [vaca1, oveja1]                           #?creamos una lista con nuestros dos objetos en instancias creadas

for animal in animales:                              #?creamos elñ loop para que itinere entre cada animal (palabra) que esta dentro de nuestra lista animales y ejecute el metodo siguiente que es el mismo que tienen  ambos objetos. y vemos como se ejecutan sin ningun pproblema a pesar de llamarse ugual y estarse itinerando
    animal.hablar()
















#?tambien lo podemos ver claro al polimorfismo atraves de una funcion
class Vaca:                                          #?creo una clase objeto 
    def __init__(self, nombre):
        self.nombre = nombre
    def hablar(self):                                #?creamos un metodo funcion igual llamado al de la clase siguiente
        print(self.nombre + " dice muuu")    
        
        

class Oveja:                                         #?creo una clase objeto 
    def __init__(self, nombre):
        self.nombre = nombre
    def hablar(self):
        print(self.nombre + " dice beee")   




vaca1 = Vaca("aurora")                               #?creo la instancias
oveja1 = Oveja("shaun")


def animañ_habla(animal):                            #?creamos una fiuncion para que tome nuestros objetos animales
    animal.hablar()                                  #?y ejecute el metodo igual en ambos


animañ_habla(vaca1)                                  #? le damos nuestro objeto a la funcion y nos arroja el mismo resultado sin ningun problema aunque el metodo se llame igual.
animañ_habla(oveja1)







#practicas


palabra = "polimorfismo"
lista = ["Clases", "POO", "Polimorfismo"]
tupla = (1, 2, 3, 80)

def itinera(palabra, lista, tupla):
    print(len(palabra))
    print(len(lista))
    print(len(tupla))


itinera(palabra, lista, tupla)










class Mago():
    def atacar(self):
        print("Ataque mágico")

class Arquero():
    def atacar(self):
        print("Lanzamiento de flecha")

class Samurai():
    def atacar(self):
        print("Ataque con katana")
        

mago = Mago()
arquero = Arquero()
samurai = Samurai()

personajes = [arquero, mago, samurai]

for personaje in personajes:
    personaje.atacar()













class Mago():
    def defender(self):
        print("Escudo mágico")

class Arquero():
    def defender(self):
        print("Esconderse")

class Samurai():
    def defender(self):
        print("Bloqueo")



mago = Mago()
arquero = Arquero()
samurai = Samurai()

def personaje_defender(personaje):
    personaje.defender()









#!metodos especiales (son los que comiensan con doble guion bajo y terminan igual. ej: __init__, __mro__,etc)




mi_lista = [1,1,1,1,1,1,1,1]
print(len(mi_lista))                      #?fuera de un objeto class pordemos usar metodos funciones como len, pero dentro de class NO, salvao usemos metodos especialses





class Objeto:
    pass

mi_objeto = Objeto()           
'''print(len(mi_objeto))'''                      #?aca vemos como nos da error al querer usar len dentro de un class






class Objeto:
    def __init__(self, autor, titulo, canciones):
        self.autor = autor
        self.titulo = titulo
        self.canciones = canciones 
    def __str__(self):                                          #?usando el metodo __str__ es como que castearamos con str o list, osea transforma el contenido de lols atribuitos de nuestra clase en string y los podemos imprimir sin problemas
        return f"albun: {self.titulo} de {self.autor} en pista {self.canciones}"
    def __len__(self):                                          #?usando _len__ podemos hacer el conteo numerico digamos 
        return (self.canciones)
    def __del__(self):                                          #? con del solo no nos muestra nada, solo borra el objeto que le demos, pero usandolo dentro de un metodo __del__ podemos hacer que nos arroje un mensaje cuando se alla eliminado el objeto
        print("se elimino el cd")
        
mi_cd = Objeto("mana","quisiera",20)

print(mi_cd)
print(len(mi_cd))
del mi_cd











#practicas





class Libro():
    def __init__(self, titulo, autor, cantidad_paginas):
        self.titulo = titulo
        self.autor = autor
        self.cantidad_paginas = cantidad_paginas
        
    def __str__(self):
        return f'"{self.titulo}", de {self.autor}'
        
mi_libro = Libro("traisionera", "mana", 20)

print(mi_libro)









class Libro():
    def __init__(self, titulo, autor, cantidad_paginas):
        self.titulo = titulo
        self.autor = autor
        self.cantidad_paginas = cantidad_paginas

    def __len__(self):
        return self.cantidad_paginas
        
libro = Libro("traisionera", "mana", 20)
print(len(libro))










class Libro():
    def __init__(self, titulo, autor, cantidad_paginas):
        self.titulo = titulo
        self.autor = autor
        self.cantidad_paginas = cantidad_paginas

    def __del__(self):
        print("Libro eliminado")
        
libro = Libro("traisionera", "mana", 20)
del libro

























# Define la clase User
class User: 
  def __init__(self, username, password): 
    self.username = username 
    self.password = password 

  def create(self): 
    # obtiene los datos del usuario 
    username = input('Ingresa tu nombre de usuario: ') 
    password = input('Ingresa tu contraseña: ') 
    print('Usuario creado exitosamente: ') 
    print('Nombre de usuario: ' + username) 
    print('Contraseña: ' + password)





# crea una nueva instancia de la clase User 
user = User(" ", " ") 
user.create()

# imprime los detalles del usuario 
'''print('Usuario creado exitosamente: ') 
print('Nombre de usuario: ' + user.username) 
print('Contraseña: ' + user.password) 
'''
# crea un nuevo usuario 
```