ADD dia 07

This commit is contained in:
Manuel Vergara 2023-04-12 21:59:10 +02:00
parent 9b621581ca
commit 20b05975ec
9 changed files with 643 additions and 0 deletions

28
dia_07/01_clases.py Normal file
View File

@ -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)

34
dia_07/02_atributos.py Normal file
View File

@ -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)

61
dia_07/03_metodos.py Normal file
View File

@ -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)

View File

@ -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)

57
dia_07/05_herencia.py Normal file
View File

@ -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()

View File

@ -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__)

55
dia_07/07_polimorfismo.py Normal file
View File

@ -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)

View File

@ -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)

167
dia_07/09_programa07.py Normal file
View File

@ -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()