ADD dia 07

dia_07/01_clases.py

@@ -0,0 +1,28 @@
+"""
+Clases
+"""
+
+# La mínima clase es poner pass
+
+
+class Pajaro:
+    pass
+
+
+# mi_pajaro es una instancia de Pajaro,
+# que en este punto se considera un objeto
+mi_pajaro = Pajaro()
+
+# Si intentamos mostrar la expresión mínima nos dirá
+# que es un objeto guardado en cierto espacio de memoria
+print(mi_pajaro)
+
+# Si mostramos el tipo nos dirá __main__
+print(type(mi_pajaro))
+
+# Podemos crear más objectos y serán distintos de la misma clase
+otro_pajaro = Pajaro()
+
+# Mostrando en pantalla nos mostrará que se guarda
+# en otro espacio de memoria
+print(otro_pajaro)

dia_07/02_atributos.py

@@ -0,0 +1,34 @@
+"""
+Atributos
+"""
+
+
+# Sintaxis:
+# def tipo/método (tipo_parámetro, parámetro):
+#   tipo_parámetro.atributo = parámetro
+
+# Creamos la clase
+
+
+class Pajaro:
+    # Atributos de clase
+    # Para valores comunes entre todos los objetos de la clase
+    alas = True
+
+    # Atributos de instancia
+    # Constructor de la clase pajaro --> Con el método__init__
+    def __init__(self, color, especie):  # En el paréntesis pasamos dos parámetros
+        self.color = color     # Le damos la instancia que vamos a crear con el atributo
+        self.especie = especie
+
+
+# Creamos la instancia. Si dejamos vacios los paréntesis dará error.
+# por que pajaro exige un argumento, debe ser un valor para el atributo.
+mi_pajaro = Pajaro('negro', 'Tucan')
+
+# Con el punto podremos ver el atributo entre otras propiedades
+print(
+    f'Mi pajaro es de color {mi_pajaro.color} y de la especie {mi_pajaro.especie}')
+
+# Los atributos de clases se pueden dar a la clase y a la instancia:
+print(Pajaro.alas, mi_pajaro.alas)

dia_07/03_metodos.py

@@ -0,0 +1,61 @@
+"""
+Métodos
+"""
+
+# self es un argumento obligatorio
+# hace referencia a cada instancia de la clase
+
+
+class Pajaro:
+
+    alas = True
+
+    def __init__(self, color, especie):
+        self.color = color
+        self.especie = especie
+
+    # Cuando se hace referencia a un atributo se debe poner self por delante
+    # para que se asocie correctamente
+    def piar(self):
+        print('pio, mi color es {}'.format(self.color))
+
+    def volar(self, metros):
+        print(f'El pajaro ha volado {metros} metros')
+
+
+piolin = Pajaro('amarillo', 'canario')
+
+piolin.piar()
+
+piolin.volar(50)
+
+# Otro ejemplo
+
+
+class Persona:
+    especie = "humano"
+
+    def __init__(self, nombre, edad):
+        self.nombre = nombre
+        self.edad = edad
+
+    def saludar(self):
+        print(f'Hola, mi nombre es {self.nombre}')
+
+    def cumplir_anios(self, estado_humor):
+        print(f'Cumplir {self.edad + 1} años me pone {estado_humor}')
+
+
+juan = Persona("Juan", 37)
+juan.saludar()
+juan.cumplir_anios("feliz")
+
+
+class Alarma:
+    def postergar(self, cantidad_minutos):
+        print(f"La alarma ha sido pospuesta {cantidad_minutos} minutos")
+
+
+sonar = Alarma()
+
+sonar.postergar(10)

dia_07/04_tipos_metodos.py

@@ -0,0 +1,90 @@
+"""
+Tipos de métodos
+
+# Decoradores:
+- Métodos de instancia:
+
+    def mi_metodo(self):
+        print('algo')
+    mi_metodo
+
+    - Acceden y modifican atributos del objeto.
+    - Acceden a otro métodos.
+    - Pueden modificar el estado de la clase.
+
+- Métodos de clase      @classmethod:
+
+    def mi_metodo(cls):
+        print('algo')
+
+    - No están asociados a las instancias de la clase, sino a la clase en si misma
+    - Pueden ser llamados desde la instancia y desde la clase
+    - No pueden acceder a los atributos de instancia pero si a los de la clase
+
+- Métodos estáticos     @staticmethod:
+
+    @staticmethod
+    def mi_metodo():
+        print('algo')
+
+    - No acepta como parámetro ni self ni cls
+    - No pueden modificar ni el estado de la clase ni de la instancia
+    - Pueden aceptar parámetros de entrada
+"""
+
+
+class Pajaro:
+
+    alas = True
+
+    def __init__(self, color, especie):
+        self.color = color
+        self.especie = especie
+
+    # Cuando se hace referencia a un atributo se debe poner self por delante
+    # para que se asocie correctamente
+    def piar(self):
+        print('pio, mi color es {}'.format(self.color))
+
+    def volar(self, metros):
+        print(f'El pajaro ha volado {metros} metros')
+        # De instancia - Acceden a otro métodos
+        self.piar()
+
+    # De instancia - Acceden y modifican atributos del objeto
+    def pintar_negro(self):
+        self.color = 'negro'
+        print(f'Ahora el pájaro es {self.color}')
+
+    # Métodos de clase. Necesita el decorador
+    @classmethod
+    def poner_huevos(cls, cantidad):
+        print(f'Puso {cantidad} huevos')
+        # No pueden acceder a los métodos de instancia
+        # print(f'Es de color {self.color}')
+        # Pero si que puede acceder a los métodos de clase
+        cls.alas = False
+        print(Pajaro.alas)
+
+    @staticmethod
+    def mirar():
+        # No accede ni a métodos de instancia ni de clase
+        # self.color = 'rojo'
+        # cls.alas = 2
+        # Así te aseguras que no se modifiquen los métodos
+        print('El pajaro mira')
+
+
+Pajaro.poner_huevos(3)
+
+Pajaro.mirar()
+
+piolin = Pajaro('amarillo', 'canario')
+
+piolin.pintar_negro()
+
+piolin.volar(45)
+
+# De instancia - Pueden modificar el estado de la clase
+piolin.alas = False
+print(piolin.alas)

dia_07/05_herencia.py

@@ -0,0 +1,57 @@
+"""
+Herencia
+
+D ONT'T
+R EPEAT
+Y OURSELF
+
+No repitas el código!
+
+"""
+
+# Ejemplo
+
+
+class Animal:
+
+    # Atributos
+    def __init__(self, edad, color):
+        self.edad = edad
+        self.color = color
+
+    # Métodos
+    def nacer(self):
+        print("Este animal ha nacido")
+
+    def morir(self):
+        pass
+
+    def respirar(self):
+        pass
+
+
+class Pajaro(Animal):
+    pass
+
+
+class Mamifero(Animal):
+    pass
+
+
+class Insecto(Animal):
+    pass
+
+
+# Podemos ver de donde vienen las clase con __bases__
+print(Pajaro.__bases__)
+
+# Podemos ver las subclases de una clase
+print(Animal.__subclasses__())
+
+# Creamos una instancia de pájaro y debe tener los atributos de Animal
+piolin = Pajaro(2, "negro")
+
+print(f'Piolin tiene {piolin.edad} años y es de color {piolin.color}')
+
+# La instancia de Pájaro ha heredado los métodos de Animal
+piolin.nacer()

dia_07/06_herencia_extendida.py

@@ -0,0 +1,85 @@
+"""
+Herencia Extendidad
+
+D ONT'T
+R EPEAT
+Y OURSELF
+
+No repitas el código!
+
+"""
+
+
+class Animal:
+
+    def __init__(self, edad, color):
+        self.edad = edad
+        self.color = color
+
+    def nacer(self):
+        print("Este animal ha nacido")
+
+    def hablar(self):
+        print("Este animal emite un sonido")
+
+
+class Pajaro(Animal):
+
+    def __init__(self, edad, color, altura_vuelo):
+        super().__init__(edad, color)
+        self.altura_vuelo = altura_vuelo
+
+    def hablar(self):
+        print("pio")
+
+    def volar(self, metros):
+        print(f'El pájaro vuela {metros} metros')
+
+
+# Declarar variables
+piolin = Pajaro(3, 'amarillo', 500)
+
+mi_animal = Animal(19, 'negro')
+
+piolin.hablar()
+
+piolin.volar(100)
+
+mi_animal.hablar()
+
+# otro ejemplo
+
+
+class Padre:
+    def hablar(self):
+        print('Hola')
+
+
+class Madre:
+    def reir(self):
+        print('ja ja ja')
+
+    def hablar(self):
+        print('Que tal')
+
+
+class Hijo(Padre, Madre):
+    pass
+
+
+class Nieto(Hijo):
+    pass
+
+# Nieto es capaz de hablar y reir aunque no herede directamente
+
+
+mi_nieto = Nieto()
+
+mi_nieto.reir()
+
+# El método que hereda es el primero que se encuentra en sus atributos
+mi_nieto.hablar()
+
+# Podemos ver el orden de las herencias con __mro__
+
+print(Nieto.__mro__)

dia_07/07_polimorfismo.py

@@ -0,0 +1,55 @@
+"""
+Polimorfismo
+
+Distintas clases pueden tener el mismo método
+pero se aplicará de manera distinta para cada clase
+"""
+
+
+class Vaca:
+
+    def __init__(self, nombre):
+        self.nombre = nombre
+
+    def hablar(self):
+        print(self.nombre + " dice muuu")
+
+
+class Oveja:
+
+    def __init__(self, nombre):
+        self.nombre = nombre
+
+    def hablar(self):
+        print(self.nombre + " dice beee")
+
+
+vaca1 = Vaca('Aurora')
+oveja1 = Oveja('Jacinta')
+
+# Dos classes distintas con el mismo método
+# que dicen cosas distintas
+vaca1.hablar()
+oveja1.hablar()
+
+
+print()
+# Ahora en una lista para iterar
+# Cuidao! Es genial!
+animales = [vaca1, oveja1]
+
+for animal in animales:
+    animal.hablar()
+
+print()
+# También en funciones.
+# Impresionante!
+
+
+def animal_habla(animal):
+
+    animal.hablar()
+
+
+animal_habla(vaca1)
+animal_habla(oveja1)

dia_07/08_metodos_especiales.py

@@ -0,0 +1,66 @@
+"""
+Métodos especiales
+
+Se han visto:
+__init__
+__mro__
+__bases__
+__subclasses__
+
+Vamos a ver:
+__str__
+__len__
+"""
+
+mi_lista = [1, 1, 1, 1, 1, 1, 1, 1]
+
+# print(len(mi_lista))
+
+
+class Objeto:
+    pass
+
+
+mi_objeto = Objeto()
+# No se puede aplicar len
+#           print(len(mi_objeto))
+
+# Tampoco podemos ver el objeto
+#           print(mi_objeto)
+
+# Otro ejemplo
+
+
+class CD:
+    def __init__(self, autor, titulo, canciones):
+        self.autor = autor
+        self.titulo = titulo
+        self.canciones = canciones
+
+    # Vamos a modif el comportamiento del método especial __str__
+    # cada vez que se llame para mostrar lo que se quiera
+    def __str__(self):
+        return f'Albun: {self.titulo} de {self.autor}'
+
+    # Comportamiento de len
+    def __len__(self):
+        return self.canciones
+
+    # Podemos añadir un mensaje cuando usemos la función del
+    def __del__(self):
+        print("Se ha eliminado el cd")
+
+
+mi_cd = CD('Pink Floyd', 'The Wall', 24)
+
+# Ahora sí que veremos el return modificado
+print(mi_cd)
+
+# También len, hemos modificado su uso para
+# que muestre el número de canciones
+print(len(mi_cd))
+
+# Podemos eliminar con la función del
+del mi_cd
+# Si lo intentamos imprimir nos dirá que no existe
+#       print(mi_cd)

dia_07/09_programa07.py

@@ -0,0 +1,167 @@
+"""
+Programa día 7 - Cuenta bancaria
+
+ESTAFA BANK
+"""
+import os
+
+
+""" Variables """
+limpiar = 'clear'
+sleep = 'sleep 2'
+
+""" Clases """
+
+
+class Persona:
+
+    # Atributos: nombre y apellido
+    def __init__(self, nombre, apellido):
+        self.nombre = nombre
+        self.apellido = apellido
+
+
+class Cliente(Persona):
+
+    # atributos propios: número de cuenta y balance
+    # es decir, el saldo que tiene en su cuenta bancaria.
+    def __init__(self, nombre, apellido, num_cuenta, balance):
+        super().__init__(nombre, apellido)
+        self.num_cuenta = num_cuenta
+        self.balance = float(round(balance, 2))
+
+    # tres métodos
+    # # método especial que permite que podamos imprimir a nuestro cliente
+    def __str__(self):
+        return f'***  CLIENTE ESTAFA BANK  ***\n\n\tCliente: \t{self.nombre} {self.apellido}\n\tNº Cuenta: \t{self.num_cuenta}\n\tBalance: \t{self.balance} pesos'
+
+    # # Método Depositar que permita decidir cuánto dinero quiere agregar a su cuenta
+
+    def depositar(self, cantidad_ingreso):
+        self.balance += cantidad_ingreso
+        self.balance = round(self.balance, 2)
+        print(
+            f'\nHa ingresado {cantidad_ingreso} Pesos.\n')
+
+    # # Método llamado Retirar que permita decidir cuánto dinero quiere sacar de su cuenta
+
+    def retirar(self, cantidad_a_retirar):
+        if (self.balance - cantidad_a_retirar) < 0:
+            print(
+                f'\nDisculpa, no tienes tanto dinero.\nBalance: {self.balance} pesos')
+        else:
+            self.balance -= cantidad_a_retirar
+            self.balance = round(self.balance, 2)
+            print(
+                f'\nHa retirado {cantidad_a_retirar} Pesos.\n')
+
+
+""" Funciones """
+
+
+def clearConsole():
+    # Función limpiar consola
+    os.system(limpiar)
+
+
+def bienvenida():
+
+    clearConsole()
+
+    # bienvenida al usuario
+    print(
+        '\n',
+        '#' * 39,
+        '\n #   Bienvenid@ a tu cuenta bancaria   #\n',
+        '#' * 39)
+
+    os.system(sleep)
+
+    clearConsole()
+
+    # Iniciar programa pidiendo datos del cliente
+    crear_cliente()
+
+    # Pedir operaciones a realizar - PROGRAMA
+    operaciones()
+
+
+def despedida():
+    clearConsole()
+
+    print('Gracias por usar los servicios de ESTAFA BANK, su banco sincero.\n\n¡Ciao!\n')
+
+
+def crear_cliente():
+
+    nombre_cliente = input("Dime tu nombre: ")
+    apellido_cliente = input("Dime tu/s apelludo/s: ")
+
+    global cliente1
+
+    cliente1 = Cliente(
+        nombre_cliente,
+        apellido_cliente,
+        '324789563417896324',
+        0)
+
+
+def operaciones():
+
+    # PROGRAMA
+    # Pedir al usuario que elija si quiere hacer depósitos o retiros.
+
+    operacion = ''
+    while operacion.lower() != 's':
+        print(
+            f'\n',
+            cliente1,
+            '\n\n Indicar la operación a realizar:\n',
+            '\n\t- i\t-->\tIngresar'
+            '\n\t- r\t-->\tRetirar'
+            '\n\t- s\t-->\tSalir\n')
+
+        operacion = input()
+
+        operacion = operacion.lower()
+
+        if operacion == "i":
+            cantidad_a_ingresar = preguntar_cantidad('ingresar')
+            cliente1.depositar(cantidad_a_ingresar)
+            continue
+
+        elif operacion == "r":
+            cantidad_a_retirar = preguntar_cantidad('retirar')
+            cliente1.retirar(cantidad_a_retirar)
+            continue
+
+        elif operacion == "s":
+            break
+
+        else:
+            clearConsole()
+            print('Disculpa, ingresa un valor valido\n')
+            continue
+    despedida()
+
+
+def preguntar_cantidad(ope):
+
+    clearConsole()
+
+    print(
+        f'\nSu balance actual es de {cliente1.balance} Pesos.\n\n',
+        f'¿Qué cantidad quiere {ope}?')
+
+    cantidad = input()
+
+    cantidad = round(float(cantidad), 2)
+
+    return cantidad
+
+
+""" Programa - Se inicia a través de la función de bienvenida """
+
+
+# Bienvenida e iniciar programa
+bienvenida()