From 3f17eda402b1c2a5311be7714503e9f1bc9b60f9 Mon Sep 17 00:00:00 2001 From: MarceloFracassi Date: Wed, 28 Sep 2022 22:27:04 -0300 Subject: [PATCH] Practica 3, Fracassi Marcelo legajo: 50574 --- exercises/exercise1.py | 7 ++ exercises/exercise2.py | 16 ++++ exercises/exercise3.py | 23 ++++++ exercises/exercise4.py | 16 +++- exercises/exercise5.py | 31 +++++++- exercises/tempCodeRunnerFile.py | 132 ++++++++++++++++++++++++++++++++ 6 files changed, 223 insertions(+), 2 deletions(-) create mode 100644 exercises/tempCodeRunnerFile.py diff --git a/exercises/exercise1.py b/exercises/exercise1.py index 4d88ccc..d38d1f4 100644 --- a/exercises/exercise1.py +++ b/exercises/exercise1.py @@ -18,6 +18,13 @@ class Circle: - Utilizar Type Hints en todos los métodos y variables """ + def __init__(self, radio): + self.radio = radio + + def perimetro(self): + return round(2*self.radio*pi,2) + def area(self): + return round(pi*self.radio**2,2) # NO MODIFICAR - INICIO # Test básico diff --git a/exercises/exercise2.py b/exercises/exercise2.py index 2b02c90..b49c8a4 100644 --- a/exercises/exercise2.py +++ b/exercises/exercise2.py @@ -21,6 +21,22 @@ class Article: - Utilizar Type Hints en todos los métodos y variables """ + __iva = 0.21 + + def __init__(self, nombre, costo, descuento = 0): + self.nombre = nombre + self.costo = costo + self.descuento = descuento + + def calcular_precio (self): + precio_iva = round((self.costo * self.__iva) + self.costo,2) + precio = round((precio_iva - precio_iva * self.descuento),2) + return precio + + @classmethod + def actualizar_iva(cls, iva_nuevo): + cls.__iva = iva_nuevo + return cls.__iva # NO MODIFICAR - INICIO # Test parámetro obligatorio diff --git a/exercises/exercise3.py b/exercises/exercise3.py index 331440a..bd446da 100644 --- a/exercises/exercise3.py +++ b/exercises/exercise3.py @@ -15,6 +15,29 @@ class Article: - Utilizar Type Hints en todos los métodos y variables """ + __iva = 0.21 + + def __init__(self, nombre, costo, descuento = 0): + self.nombre = nombre + self.costo = costo + self.descuento = descuento + + @property #Sirve para definir un atributo calculado + def precio(self): + precio =round(self.costo + (self.costo * self.__iva),2) + precio_final = round(precio-(self.descuento * precio),2) + return precio_final + + @classmethod #Defino metodo de clase + def actualizar_iva(cls, iva_nuevo): #Metodo de clase usa cls en vez de self + cls.__iva = iva_nuevo + return cls.__iva + + def calcular_precio(self): + precio_iva = round((self.costo * self.__iva) + self.costo,2) + precio = round((precio_iva - precio_iva * self.descuento),2) + return precio + # NO MODIFICAR - INICIO # Test parámetro obligatorio diff --git a/exercises/exercise4.py b/exercises/exercise4.py index b424db7..f841530 100644 --- a/exercises/exercise4.py +++ b/exercises/exercise4.py @@ -4,7 +4,7 @@ from typing import List -"""Una carrera tiene varias materias, la "longitud" de una carrera hace +"""Una carrera tiene varias (refiere a lista) materias, la "longitud" de una carrera hace referencia a cuantas materias tiene. Cada materia tiene un nombre. @@ -22,6 +22,20 @@ - No utilizar properties - Utilizar Type Hints en todos los métodos y variables """ +@dataclass +class Materia: + nombre:str #esto permite definir un contrusctor mas rapido + +@dataclass +class Carrera: + longitud:list + + def __str__(self): + return f"Carrera(materias={self.longitud})" + + def __len__(self): + return len(self.longitud) + # NO MODIFICAR - INICIO diff --git a/exercises/exercise5.py b/exercises/exercise5.py index 92d717c..24260c3 100644 --- a/exercises/exercise5.py +++ b/exercises/exercise5.py @@ -37,11 +37,40 @@ from dataclasses import dataclass from typing import List +#Clase padre contribuyentes +#Clase hijo dependencia y clase hijo monotributo + +class Contribuyente(ABC): + @abstractmethod #va a calcular el sueldo de un mono y para dependencia + def calcular_sueldo(self): + pass + +@dataclass +class Empleado(Contribuyente): + sueldo:float + def calcular_sueldo(self)->float: + return self.sueldo - (self.sueldo*0.17) + +@dataclass +class Monotributista(Contribuyente): + sueldo:float + def calcular_sueldo(self)->float: + if self.sueldo < (370000/12): + return self.sueldo - 2646.22 + if self.sueldo < (550000/12): + return self.sueldo - 2958.95 + if self.sueldo < (770000/12): + return self.sueldo - 3382.62 + if self.sueldo > (770000/12): + return self.sueldo - 3988.85 def calcular_sueldos(contribuyentes: List[Contribuyente]): """Data una lista de contribuyentes, devuelve una lista de los sueldos de cada uno.""" - + sueldos=[] + for i in contribuyentes: + sueldos.append(i.calcular_sueldo()) + return sueldos # NO MODIFICAR - INICIO assert type(Contribuyente) == abc.ABCMeta, "Contribuyente debe ser abstracta" diff --git a/exercises/tempCodeRunnerFile.py b/exercises/tempCodeRunnerFile.py new file mode 100644 index 0000000..24260c3 --- /dev/null +++ b/exercises/tempCodeRunnerFile.py @@ -0,0 +1,132 @@ +"""El ente regulador de impuestos llama a todas las personas activas +laboralmente Contribuyentes, sin embargo, existen varios tipos de +contribuyentes, por ejemplo, el Monotributista y el que es Empleado en relación +de dependencia. Ambos están dentro del sistema pero pagan diferentes impuestos. + +El monotributista tiene que pagar en función de sus ingresos brutos anuales: + - Si son menores a $370.000, paga $2646,22 mensuales + - Si son menores a $550.000, paga $2958,95 mensuales + - Si son menores a $770.000, paga $3382,62 mensuales + - Si son mayores a $770.000, paga $3988,85 mensuales + +En el caso de los empleados en relación de dependencia, ellos pagan un 17% de +impuestos sobre sus ingresos brutos mensuales. + +Inspirado en datos reales: https://www.afip.gob.ar/monotributo/categorias.asp + +Escribir una estructura de clases que refleje lo anterior. Para simplificar el +análisis, todos los montos serán mensuales (dividir los límites del monotributo +por 12). + +Aclaración: Este ejercicio está basado en la realidad pero se realizaron +múltiples simplificaciones para adecuarlo al contexto del curso. + +Restricciones: + - Utilizar Dataclasses + - Utilizar 3 clases: 1 abstracta y 2 concretas + - Utilizar 1 variables de instancia en cada clase concreta + - Utilizar 1 métodos de instancia con polimorfismo + - No utilizar variables de clase + - No utilizar métodos de clase + - No utilizar properties + - Utilizar Type Hints en todos los métodos y variables +""" + +import abc +from abc import ABC, abstractmethod +from dataclasses import dataclass +from typing import List + +#Clase padre contribuyentes +#Clase hijo dependencia y clase hijo monotributo + +class Contribuyente(ABC): + @abstractmethod #va a calcular el sueldo de un mono y para dependencia + def calcular_sueldo(self): + pass + +@dataclass +class Empleado(Contribuyente): + sueldo:float + def calcular_sueldo(self)->float: + return self.sueldo - (self.sueldo*0.17) + +@dataclass +class Monotributista(Contribuyente): + sueldo:float + def calcular_sueldo(self)->float: + if self.sueldo < (370000/12): + return self.sueldo - 2646.22 + if self.sueldo < (550000/12): + return self.sueldo - 2958.95 + if self.sueldo < (770000/12): + return self.sueldo - 3382.62 + if self.sueldo > (770000/12): + return self.sueldo - 3988.85 + +def calcular_sueldos(contribuyentes: List[Contribuyente]): + """Data una lista de contribuyentes, devuelve una lista de los sueldos de + cada uno.""" + sueldos=[] + for i in contribuyentes: + sueldos.append(i.calcular_sueldo()) + return sueldos + +# NO MODIFICAR - INICIO +assert type(Contribuyente) == abc.ABCMeta, "Contribuyente debe ser abstracta" +assert issubclass(Empleado, Contribuyente), "Empleado debe heredar de Contribuyente" # noqa: 501 +assert issubclass(Monotributista, Contribuyente), "Monotributista debe heredar de Contribuyente" # noqa: 501 + +try: + juan = Contribuyente() + assert False, "No se puede instanciar una clase abstracta" +except TypeError: + assert True + +try: + juan = Empleado() + assert False, "No se puede instanciar sin sueldo" +except TypeError: + assert True + +try: + juan = Monotributista() + assert False, "No se puede instanciar sin sueldo" +except TypeError: + assert True + + +# Test Básico +juan = Monotributista(25_000) +assert juan.calcular_sueldo() == 22353.78 + +juan = Monotributista(35_000) +assert juan.calcular_sueldo() == 32041.05 + +juan = Monotributista(50_000) +assert juan.calcular_sueldo() == 46617.38 + +juan = Monotributista(75_000) +assert juan.calcular_sueldo() == 71011.15 + + +maria = Empleado(25_000) +assert maria.calcular_sueldo() == 20750.0 + +maria = Empleado(35_000) +assert maria.calcular_sueldo() == 29050.0 + +maria = Empleado(50_000) +assert maria.calcular_sueldo() == 41500.0 + +maria = Empleado(75_000) +assert maria.calcular_sueldo() == 62250.0 + + +# Test Calculadora de sueldos + +contribuyentes = [Monotributista(80_000), Empleado(80_000)] + +assert calcular_sueldos(contribuyentes) == [76011.15, 66400.0] + +# NO MODIFICAR - FIN