From 20b05975ecc6cd849b7b751fcc4a97da052f7b3f Mon Sep 17 00:00:00 2001 From: Manuel Vergara Date: Wed, 12 Apr 2023 21:59:10 +0200 Subject: [PATCH] ADD dia 07 --- dia_07/01_clases.py | 28 ++++++ dia_07/02_atributos.py | 34 +++++++ dia_07/03_metodos.py | 61 ++++++++++++ dia_07/04_tipos_metodos.py | 90 +++++++++++++++++ dia_07/05_herencia.py | 57 +++++++++++ dia_07/06_herencia_extendida.py | 85 ++++++++++++++++ dia_07/07_polimorfismo.py | 55 +++++++++++ dia_07/08_metodos_especiales.py | 66 +++++++++++++ dia_07/09_programa07.py | 167 ++++++++++++++++++++++++++++++++ 9 files changed, 643 insertions(+) create mode 100644 dia_07/01_clases.py create mode 100644 dia_07/02_atributos.py create mode 100644 dia_07/03_metodos.py create mode 100644 dia_07/04_tipos_metodos.py create mode 100644 dia_07/05_herencia.py create mode 100644 dia_07/06_herencia_extendida.py create mode 100644 dia_07/07_polimorfismo.py create mode 100644 dia_07/08_metodos_especiales.py create mode 100644 dia_07/09_programa07.py diff --git a/dia_07/01_clases.py b/dia_07/01_clases.py new file mode 100644 index 0000000..634f9bd --- /dev/null +++ b/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) diff --git a/dia_07/02_atributos.py b/dia_07/02_atributos.py new file mode 100644 index 0000000..fab5b50 --- /dev/null +++ b/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) diff --git a/dia_07/03_metodos.py b/dia_07/03_metodos.py new file mode 100644 index 0000000..d7e538c --- /dev/null +++ b/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) diff --git a/dia_07/04_tipos_metodos.py b/dia_07/04_tipos_metodos.py new file mode 100644 index 0000000..a24c854 --- /dev/null +++ b/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) diff --git a/dia_07/05_herencia.py b/dia_07/05_herencia.py new file mode 100644 index 0000000..5b31939 --- /dev/null +++ b/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() diff --git a/dia_07/06_herencia_extendida.py b/dia_07/06_herencia_extendida.py new file mode 100644 index 0000000..1d29b22 --- /dev/null +++ b/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__) diff --git a/dia_07/07_polimorfismo.py b/dia_07/07_polimorfismo.py new file mode 100644 index 0000000..b4628c4 --- /dev/null +++ b/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) diff --git a/dia_07/08_metodos_especiales.py b/dia_07/08_metodos_especiales.py new file mode 100644 index 0000000..b77bd8d --- /dev/null +++ b/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) diff --git a/dia_07/09_programa07.py b/dia_07/09_programa07.py new file mode 100644 index 0000000..1f0961c --- /dev/null +++ b/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()