From 2f977ee4826880b4582405ece03aa0662be309e1 Mon Sep 17 00:00:00 2001
From: Pablo Alvarez <105523491+alvarezpablo98@users.noreply.github.com>
Date: Tue, 4 Oct 2022 23:33:42 -0300
Subject: [PATCH] Alvarez pablo Comision 4 . Matricula 50810   Prac3

---
 exercise1.py |  50 +++++++++++++++++++
 exercise2.py |  91 ++++++++++++++++++++++++++++++++++
 exercise3.py |  89 +++++++++++++++++++++++++++++++++
 exercise4.py |  69 ++++++++++++++++++++++++++
 exercise5.py | 135 +++++++++++++++++++++++++++++++++++++++++++++++++++
 5 files changed, 434 insertions(+)
 create mode 100644 exercise1.py
 create mode 100644 exercise2.py
 create mode 100644 exercise3.py
 create mode 100644 exercise4.py
 create mode 100644 exercise5.py

diff --git a/exercise1.py b/exercise1.py
new file mode 100644
index 0000000..93a94d1
--- /dev/null
+++ b/exercise1.py
@@ -0,0 +1,50 @@
+"""Variables de Instancia y Métodos de instancia."""
+
+from math import pi
+
+
+class Circle:
+    """Todo cículo tiene un radio y se desea conocer tanto el área como el
+    perímetro (longitud de circunferencia).
+
+    Reportar los números redondeados a dos decimales
+
+    Restricciones:
+        - Utilizar 1 variable de instancia
+        - Utilizar 2 métodos de instancia
+        - No utilizar variable de clase
+        - No utilizar Dataclasses
+        - No utilizar Properties
+        - Utilizar Type Hints en todos los métodos y variables
+    """
+    def __init__ (self,radio):
+        self.radio=radio
+    def area(self):
+        return round(pi*self.radio**2,2)
+    def perimetro(self):
+        return round(pi*self.radio*2,2)
+
+# NO MODIFICAR - INICIO
+# Test básico
+circle = Circle(1)
+assert circle.radio == 1
+assert circle.area() == 3.14
+assert circle.perimetro() == 6.28
+
+# Test palabra clave
+circle = Circle(radio=1)
+assert circle.radio == 1
+assert circle.area() == 3.14
+assert circle.perimetro() == 6.28
+
+# Test parámetro obligatorio
+try:
+    circle = Circle()
+    assert False, "No se puede instanciar sin radio"
+except TypeError:
+    assert True
+
+# Test invocación encadenada
+assert Circle(1).area() == 3.14
+assert Circle(1).perimetro() == 6.28
+# NO MODIFICAR - FIN
diff --git a/exercise2.py b/exercise2.py
new file mode 100644
index 0000000..cdaf50d
--- /dev/null
+++ b/exercise2.py
@@ -0,0 +1,91 @@
+"""Variables de Clase y Métodos de Clase."""
+
+
+class Article:
+    """Todos los artículos tienen un nombre y un costo, opcionalmente algunos
+    tienen un porcentaje de descuento.
+
+    El IVA es un impuesto que se aplica a todos los productos por igual,
+    actualmente es de 21% pero puede cambiar en el futuro.
+
+    Para calcular el precio de un artículo, hay que sumar el IVA y luego restar
+    los descuentos si hubiera. Redondear a 2 decimales.
+
+    Restricciones:
+        - Utilizar 3 variables de instancia .
+        - Utilizar 1 método de instancia
+        - Utilizar 1 variable de clase .
+        - Utilizar 1 método de clase
+        - No utilizar Dataclasses
+        - No utilizar Properties
+        - Utilizar Type Hints en todos los métodos y variables
+    """
+    #variable de clase
+    __iva=0.21
+
+    #constructor    #3 varibles de instancias
+    def __init__(self,nombre,costo,descuento=0) :
+        self.nombre=nombre
+        self.costo=costo
+        self.descuento=descuento
+
+    def calcular_precio(self):
+        precio = round(self.costo + (self.costo * self.__iva), 2)
+        print(precio)
+        precio_final = round(precio - (self.descuento * precio), 2)
+        print(precio_final)
+        return precio_final
+    #metodo de clase
+    @classmethod
+    def actualizar_iva(cls,iva):
+        cls.__iva=iva
+
+
+
+# NO MODIFICAR - INICIO
+# Test parámetro obligatorio
+try:
+    article = Article()
+    assert False, "No se puede instanciar sin nombre ni costo"
+except TypeError:
+    assert True
+
+try:
+    article = Article("Auto")
+    assert False, "No se puede instanciar sin costo"
+except TypeError:
+    assert True
+
+try:
+    article = Article(nombre="Auto", costo=1)
+    assert True
+except TypeError:
+    assert False, "El descuento es opcional"
+
+# Test básico
+article = Article("Auto", 1)
+assert article.nombre == "Auto"
+assert article.calcular_precio() == 1.21
+
+article = Article("Auto", 1, 0.21)
+assert article.nombre == "Auto"
+assert article.calcular_precio() == 0.96
+
+
+# Test palabra clave
+article = Article(costo=1, nombre="Auto")
+assert article.nombre == "Auto"
+assert article.calcular_precio() == 1.21
+
+article = Article(costo=1, nombre="Auto", descuento=0.21)
+assert article.nombre == "Auto"
+assert article.calcular_precio() == 0.96
+
+
+# Test de método de clase
+Article.actualizar_iva(0.25)
+
+article = Article(costo=1, nombre="Auto")
+assert article.nombre == "Auto"
+assert article.calcular_precio() == 1.25
+# NO MODIFICAR - FIN
diff --git a/exercise3.py b/exercise3.py
new file mode 100644
index 0000000..db96f9b
--- /dev/null
+++ b/exercise3.py
@@ -0,0 +1,89 @@
+"""Properties"""
+
+
+class Article:
+    """Re-Escribir el ejercicio anterior utilizando una property en vez de un
+    método de instancia.
+
+    Restricciones:
+        - Utilizar 3 variables de instancia
+        - Utilizar 1 property
+        - Utilizar 1 variable de clase
+        - Utilizar 1 método de clase
+        - No utilizar métodos de instancia
+        - No utilizar Dataclasses
+        - 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
+    def precio(self):
+        precio = round(self.costo + (self.costo * self.__iva), 2)
+        precio_final = round(precio - (self.descuento * precio), 2)
+        return precio_final
+        
+    @classmethod
+    def actualizar_iva(cls,iva):
+        cls.__iva=iva
+
+# NO MODIFICAR - INICIO
+# Test parámetro obligatorio
+try:
+    article = Article()
+    assert False, "No se puede instanciar sin nombre ni costo"
+except TypeError:
+    assert True
+
+try:
+    article = Article("Auto")
+    assert False, "No se puede instanciar sin costo"
+except TypeError:
+    assert True
+
+try:
+    article = Article(nombre="Auto", costo=1)
+    assert True
+except TypeError:
+    assert False, "El descuento es opcional"
+
+try:
+    article = Article(nombre="Auto", costo=1)
+    article.precio = 2
+    assert False, "No se puede modificar el precio"
+except AttributeError:
+    assert True
+
+
+# Test básico
+article = Article("Auto", 1)
+assert article.nombre == "Auto"
+assert article.precio == 1.21
+
+
+article = Article("Auto", 1, 0.21)
+assert article.nombre == "Auto"
+assert article.precio == 0.96
+
+
+# Test palabra clave
+article = Article(costo=1, nombre="Auto")
+assert article.nombre == "Auto"
+assert article.precio == 1.21
+
+article = Article(costo=1, nombre="Auto", descuento=0.21)
+assert article.nombre == "Auto"
+assert article.precio == 0.96
+
+
+# Test de método de clase
+Article.actualizar_iva(0.25)
+
+article = Article(costo=1, nombre="Auto")
+assert article.nombre == "Auto"
+assert article.precio == 1.25
+# NO MODIFICAR - FIN
diff --git a/exercise4.py b/exercise4.py
new file mode 100644
index 0000000..2e31d7f
--- /dev/null
+++ b/exercise4.py
@@ -0,0 +1,69 @@
+"""DataClasses y Sobrecarga de operadores."""
+
+from dataclasses import dataclass
+from typing import List
+
+
+"""Una carrera tiene varias materias, la "longitud" de una carrera hace
+referencia a cuantas materias tiene.
+
+Cada materia tiene un nombre.
+
+Escribir una estructura de clases que refleje lo anterior.
+
+Restricciones:
+    - Utilizar Dataclasses
+    - Utilizar 2 clases
+    - Utilizar 1 variables de instancia en cada clase
+    - Utilizar 1 método mágico
+    - No utilizar variables de clase
+    - No utilizar métodos de clase
+    - No utilizar métodos de instancia
+    - No utilizar properties
+    - Utilizar Type Hints en todos los métodos y variables
+"""
+@dataclass
+class Materia:
+    nombre:str
+@dataclass
+class Carrera:
+    longitud:list
+    def __str__(self):
+        return f"Carrera(materias={self.longitud})"
+    def __len__(self) -> int:
+        return len(self.longitud)
+            
+            
+
+# NO MODIFICAR - INICIO
+# Test parámetro obligatorio
+    
+    
+try:
+    materia = Materia()
+    assert False, "No se puede instanciar sin nombre"
+except TypeError:
+    assert True
+
+try:
+    materia = Carrera()
+    assert False, "No se puede instanciar sin materias"
+except TypeError:
+    assert True
+
+# Test básico
+matematica = Materia("Matemática")
+assert matematica.nombre == "Matemática"
+
+estadistica = Materia(nombre="Estadística")
+assert estadistica.nombre == "Estadística"
+
+ciclo_basico = Carrera([matematica, estadistica])
+assert (
+    str(ciclo_basico)
+    == "Carrera(materias=[Materia(nombre='Matemática'), Materia(nombre='Estadística')])"  # noqa: 501
+)
+
+assert len(ciclo_basico) == 2
+
+# NO MODIFICAR - FIN
diff --git a/exercise5.py b/exercise5.py
new file mode 100644
index 0000000..da0ca59
--- /dev/null
+++ b/exercise5.py
@@ -0,0 +1,135 @@
+"""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
+
+
+class Contribuyente(ABC): 
+
+
+    @abstractmethod
+    def calcular_sueldo(self):
+        pass
+
+
+   # """Dada una lista de contribuyentes, devuelve una lista de los sueldos de
+   # cada uno."""
+@dataclass
+class Monotributista(Contribuyente):
+
+    sueldo: float
+    def calcular_sueldo(self) -> float:
+        if self.sueldo < 30833:
+           return self.sueldo - 2646.22
+        elif self.sueldo < 45833:
+            return self.sueldo - 2958.95
+        elif self.sueldo < 64166:
+            return self.sueldo - 3382.62
+        elif self.sueldo > 64166:
+            return self.sueldo - 3988.85
+
+@dataclass
+class Empleado(Contribuyente):
+    sueldo: float
+    def calcular_sueldo(self) -> float:  
+        return self.sueldo - self.sueldo * 0.17  
+
+
+def calcular_sueldos(contribuyentes: List[Contribuyente]):
+    listaSueldos=[]
+    for elemento in contribuyentes:
+        listaSueldos.append(elemento.calcular_sueldo())
+    return listaSueldos
+
+# 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