Merge pull request #8122 from raynerpv2022/main

#28- Python

Author: kontroldev

Roadmap/28 - SOLID LSP/python/raynerpv2022.py

@@ -0,0 +1,144 @@
+
+# /*
+#  * EJERCICIO:
+#  * Explora el "Principio SOLID de Sustitución de Liskov (Liskov Substitution Principle, LSP)" 
+#  * y crea un ejemplo simple donde se muestre su funcionamiento
+#  * de forma correcta e incorrecta.
+#  *
+
+
+class Figura:
+    def __init__(self ):
+        pass
+
+    
+    def Area(self):
+        pass
+        
+
+
+class Rectangle(Figura):
+    def __init__(self, x, y):
+         if  x<= 0 and y <= 0:
+             raise ValueError("Valores deben ser mayores q que 0")
+         self.x = x
+         self.y = y
+
+    
+    
+    
+    def Area(self):
+         
+        return self.x*self.y
+         
+            
+    
+
+class Square(Figura):
+    def __init__(self, x):
+        if  x <= 0 :
+             raise ValueError("Valores deben ser mayoresq que 0")
+        self.x = x
+     
+    
+    def Area(self):
+         return self.x ** 2
+         
+        
+class Circle(Figura):
+    def __init__(self, r):
+        if  r <= 0 :
+            raise ValueError("Valores deben ser mayores q que 0")
+        self.r = r
+    
+    def Area(self):
+            return 3.14*self.r ** 2
+         
+            
+        
+def Calcular_Area(f: Figura):
+    print(f.Area())
+    
+R =  Rectangle(12,14) 
+S =  Square(7) 
+
+C = Circle(10)
+
+
+
+
+Figurillas = [R,S,C]
+for i in Figurillas:
+    Calcular_Area(i)
+
+
+#  * DIFICULTAD EXTRA (opcional):
+#  * Crea una jerarquía de vehículos. Todos ellos deben poder acelerar y frenar, así como
+#  * cumplir el LSP.
+#  * Instrucciones:
+#  * 1. Crea la clase Vehículo.
+#  * 2. Añade tres subclases de Vehículo.
+#  * 3. Implementa las operaciones "acelerar" y "frenar" como corresponda.
+#  * 4. Desarrolla un código que compruebe que se cumple el LSP.
+#  */
+
+class Vehiculo:
+    def __init__(self, speed = 0):
+        self.speed = speed
+
+    def acelerar(self, i):
+        self.speed += i
+
+    def frenar(self, d):
+        self.speed -= d
+        if self.speed <= 0 :
+            self.speed = 0
+            
+        
+
+class carricoche(Vehiculo):
+    def __init__(self, speed=0):
+        super().__init__(speed)
+    
+    def acelerar(self,i):
+        super().acelerar(i)
+        return f" Carricoche ACELERAR Velocidad {self.speed}"
+
+    def frenar(self,d):
+       super().frenar(d)
+       return f" Carricoche FRENO Velocidad {self.speed}"
+
+    
+class riquimbili(Vehiculo):
+     def __init__(self, speed=0):
+        super().__init__(speed)
+    
+     def acelerar(self, i):
+        super().acelerar(i)
+        return f" Rikimbili ACELERAR Velocidad {self.speed}"
+
+     def frenar(self,d):
+       super().frenar(d)
+       return f" Rikimbili FRENO Velocidad {self.speed}"
+
+C = carricoche()
+R = riquimbili()
+V = [C,R]
+
+def test_LSP(v: Vehiculo):
+    print(v.acelerar(100))
+    print(v.acelerar(12))
+    print(v.acelerar(1))
+    print(v.acelerar(45))
+    print(v.frenar(34))
+
+
+
+print("EXTRA")
+ 
+
+test_LSP(C)    
+test_LSP(R )
+test_LSP(C )
+test_LSP(C )
+test_LSP(R )

Roadmap/29 - SOLID ISP/python/raynerpv2022.py

@@ -0,0 +1,162 @@
+# /*
+#  * EJERCICIO:
+#  * Explora el "Principio SOLID de Segregación de Interfaces (Interface Segregation Principle, ISP)" 
+#  * y crea un ejemplo simple donde se muestre su funcionamiento de forma correcta e incorrecta.
+#  *
+
+
+
+# Viola el principio de segregacion ..
+from abc import ABC,abstractmethod
+
+class Worker(ABC):
+    @abstractmethod
+    def sleep(self):
+        pass
+
+    @abstractmethod
+    def work(self):
+        pass
+
+    @abstractmethod
+    def eat(self):
+        pass
+
+class Robot(Worker):
+    def work(self):
+        print("Robot is working...")
+
+    def sleep(self):
+         pass
+    
+    def eat(self):
+        pass
+
+class Human (Worker):
+    def sleep(self):
+        print("Human is sleeping...")
+    def work(self):
+        print("Human is working...")
+    def eat(self):
+        print("Human is eating..")
+
+print("Whitout iSP")
+R = Robot()
+R.work()
+H = Human()
+H.work()
+H.eat()
+H.sleep()
+
+#  aplicando principio de segregacion
+
+class WorkInterface(ABC):
+    @abstractmethod
+    def work(self):
+        pass
+
+class EatINterface(ABC):
+    @abstractmethod
+    def eat(self):
+        pass
+
+class SleepInterface(ABC):
+    @abstractmethod
+    def sleep(self):
+        pass
+
+class Human(WorkInterface,SleepInterface,EatINterface):
+     
+    def work(self):
+        print("HUman is working...")
+    
+    def sleep(self):
+        print("HUman is sleeping")
+
+    def eat(self):
+        print("Human is eating")  
+
+class Robot(WorkInterface):
+    def work(self):
+        print("Robot is workiing...")
+
+
+print("ISP")
+Ro = Robot()
+Ro.work()
+Hu = Human()
+Hu.sleep()
+Hu.work()
+Hu.eat()
+
+
+# EXTRA
+
+#  * DIFICULTAD EXTRA (opcional):
+#  * Crea un gestor de impresoras.
+#  * Requisitos:
+#  * 1. Algunas impresoras sólo imprimen en blanco y negro.
+#  * 2. Otras sólo a color.
+#  * 3. Otras son multifunción, pueden imprimir, escanear y enviar fax.
+#  * Instrucciones:
+#  * 1. Implementa el sistema, con los diferentes tipos de impresoras y funciones.
+#  * 2. Aplica el ISP a la implementación.
+#  * 3. Desarrolla un código que compruebe que se cumple el principio.
+#  */
+
+
+class Scaninterface(ABC):
+    @abstractmethod
+    def Scan(self):
+        pass
+    
+class FAXinterface(ABC):
+    @abstractmethod
+    def Fax(self):
+        pass
+
+class PrintetInterface(ABC):
+    @abstractmethod
+    def Print(self):
+        pass
+
+
+class ColorPrintInterface(ABC):
+    @abstractmethod
+    def Print_color(self):
+        pass
+
+class Printer (PrintetInterface):
+    def Print(self):
+        print("IMpresora solo imprime white and black")
+    
+
+class PrinterColor(ColorPrintInterface):
+    def Print_color(self):
+        print("Impresora a Color...")
+
+class MultiFunction(PrintetInterface,ColorPrintInterface,Scaninterface,FAXinterface):
+    def Print(self):
+        print("Multifuncion Printing white and Black...")
+        
+    def Print_color(self):
+        print("Multifuncion Printing in color...")
+        
+
+    def Scan(self):
+        print("Mutifunction Scanning...")
+
+    def Fax(self):
+        print("MultiFunction Faxing...")
+print("PRINTER")
+
+printer_wb = Printer()
+printer_wb.Print()
+printer_c = PrinterColor()
+printer_c.Print_color()
+
+multi = MultiFunction()
+multi.Print()
+multi.Print_color()
+multi.Scan()
+multi.Fax()