Principio Abierto/Cerrado (OCP) en Python

El **Principio Abierto/Cerrado (Open-Closed Principle, OCP)** es un pilar fundamental en la programación orientada a objetos. Establece que las entidades de software (clases, módulos, funciones) deben estar abiertas a la extensión, pero cerradas a la modificación. Es decir, debemos poder agregar nuevas funcionalidades sin alterar el código existente. ### ¿Por qué es importante el OCP en Python? * **Mayor mantenibilidad:** Al evitar modificar código existente, reducimos el riesgo de introducir nuevos errores. * **Mayor flexibilidad:** Permite agregar nuevas funcionalidades sin afectar el comportamiento de las partes existentes del sistema. * **Fomenta la reutilización:** Las clases diseñadas siguiendo el OCP son más fáciles de reutilizar en diferentes contextos. ### Cómo aplicar el OCP en Python **1. Abstracción:** * **Identificar las áreas de cambio:** Determina qué partes de tu código son más propensas a cambiar en el futuro. * **Crear abstracciones:** Utiliza clases abstractas, interfaces o clases base para definir un contrato que las clases concretas deben cumplir. **2. Extensión:** * **Heredar de las abstracciones:** Crea nuevas clases que hereden de las abstracciones y proporcionen implementaciones concretas. * **Utilizar polimorfismo:** Permite que diferentes objetos respondan de manera diferente al mismo mensaje. **Ejemplo: Sistema de pagos** Python from abc import ABC, abstractmethod ​ class Pagador(ABC):   @abstractmethod   def pagar(self, monto):       pass ​ class PayPal(Pagador):   def pagar(self, monto):       print(f"Pagando {monto} dólares a través de PayPal") ​ class TarjetaCredito(Pagador):   def pagar(self, monto):       print(f"Pagando {monto} dólares con tarjeta de crédito") ​ \# Cliente def procesar\_pago(pagador, monto):   pagador.pagar(monto) ​ \# Uso paypal = PayPal() tarjeta = TarjetaCredito() ​ procesar\_pago(paypal, 100) procesar\_pago(tarjeta, 50) En este ejemplo: * `Pagador` es una clase abstracta que define el contrato para todos los pagadores. * `PayPal` y `TarjetaCredito` heredan de `Pagador` y proporcionan implementaciones específicas. * La función `procesar_pago` es polimórfica, ya que puede trabajar con cualquier objeto que implemente la interfaz `Pagador`. **3. Herramientas de Python para el OCP:** * **Clases abstractas:** Definidas con `ABC` y `abstractmethod`. * **Interfaces:** Aunque Python no tiene interfaces explícitas, se pueden simular usando clases abstractas con solo métodos abstractos. * **Herencia:** Permite crear nuevas clases a partir de clases existentes. * **Polimorfismo:** Permite que objetos de diferentes clases respondan de manera diferente al mismo mensaje. ### Otros principios SOLID relacionados con el OCP: * **Principio de Sustitución de Liskov (LSP):** Los objetos de una superclase deben poder ser reemplazados por objetos de sus subclases sin alterar la corrección del programa. * **Principio de Segregación de Interfaces (ISP):** Muchas interfaces específicas son mejores que una única interfaz de propósito general. ### Conclusiones El principio OCP es una herramienta poderosa para crear software más flexible, mantenible y extensible. Al aplicarlo en Python, podemos construir sistemas que sean más fáciles de adaptar a los cambios futuros y que sean más robustos ante la evolución de los requisitos.

1. en el *Notificator*, para tener 1 por cada tipo de notificacion que querramos enviar, para no tener que modificar la que ya tenemos 2. en el Logger, por si ocupamos diferentes formas de logear errores

## **🧠 Preguntas clave para saber si necesitas OCP** 1. **¿Necesito modificar una clase o función cada vez que agrego una nueva funcionalidad?** (Si es así, aplica OCP). 2. **¿Puedo extender la funcionalidad agregando una nueva clase en lugar de modificar una existente?** 3. **¿Hay muchos if/else o switch/case que podrían convertirse en clases separadas?** 4. **¿Cada vez que hay un cambio en las reglas de negocio, tengo que modificar el código existente?**

El \*\*Principio Abierto/Cerrado\*\* (Open/Closed Principle, OCP) establece que \*\*una clase debe estar abierta para su extensión, pero cerrada para su modificación\*\*. Esto significa que deberíamos poder agregar nuevas funcionalidades a una clase sin cambiar su código existente, lo cual es esencial para preservar la estabilidad del software y minimizar los errores. Una forma común de aplicar el OCP en Python es utilizando la \*\*herencia\*\* o la \*\*composición\*\* para extender el comportamiento de las clases sin modificar su código base. \### Ejemplo de una Clase que Viola el OCP Imaginemos una clase que calcula el descuento para una tienda en línea. La clase `DiscountCalculator` contiene lógica para aplicar distintos tipos de descuentos. Sin embargo, si necesitamos agregar un nuevo tipo de descuento, tendríamos que modificar la clase, violando así el principio OCP. ```python class DiscountCalculator: def calculate(self, price, discount\_type): if discount\_type == "percentage": return price \* 0.90 # 10% de descuento elif discount\_type == "fixed": return price - 20 # Descuento fijo de $20 else: return price ``` Si se agrega un nuevo tipo de descuento, como un descuento para clientes frecuentes, sería necesario modificar el método `calculate`, lo que va en contra del principio OCP. \### Solución: Aplicando OCP Para aplicar el OCP, separamos cada tipo de descuento en clases independientes, que pueden extenderse sin necesidad de modificar la lógica existente. Utilizaremos \*\*polimorfismo\*\* mediante una clase base abstracta `DiscountStrategy`. ```python from abc import ABC, abstractmethod class DiscountStrategy(ABC): @abstractmethod def apply\_discount(self, price): pass class PercentageDiscount(DiscountStrategy): def apply\_discount(self, price): return price \* 0.90 # 10% de descuento class FixedDiscount(DiscountStrategy): def apply\_discount(self, price): return price - 20 # Descuento fijo de $20 class NoDiscount(DiscountStrategy): def apply\_discount(self, price): return price # Sin descuento class DiscountCalculator: def \_\_init\_\_(self, strategy: DiscountStrategy): self.strategy = strategy def calculate(self, price): return self.strategy.apply\_discount(price) ``` \### Explicación \- \*\*Clase `DiscountStrategy`\*\*: Es una clase abstracta que define el método `apply\_discount`, el cual debe ser implementado por cada tipo de descuento. \- \*\*Clases `PercentageDiscount`, `FixedDiscount` y `NoDiscount`\*\*: Cada una implementa una estrategia de descuento específica. Puedes agregar nuevas estrategias sin modificar las clases existentes. \- \*\*Clase `DiscountCalculator`\*\*: Su método `calculate` utiliza una instancia de `DiscountStrategy` para aplicar el descuento. Esta clase no necesita ser modificada al agregar un nuevo tipo de descuento. \### Uso del Código Podemos usar `DiscountCalculator` con distintas estrategias de descuento de forma flexible: ```python \# Crear instancias de estrategias de descuento percentage\_discount = PercentageDiscount() fixed\_discount = FixedDiscount() no\_discount = NoDiscount() \# Aplicar descuentos calculator = DiscountCalculator(percentage\_discount) print(f"Precio con descuento del 10%: ${calculator.calculate(100)}") calculator.strategy = fixed\_discount print(f"Precio con descuento fijo de $20: ${calculator.calculate(100)}") calculator.strategy = no\_discount print(f"Precio sin descuento: ${calculator.calculate(100)}") ``` \### Ventajas de Aplicar el Principio OCP 1\. \*\*Extensibilidad\*\*: Puedes agregar nuevos tipos de descuento sin modificar las clases existentes. 2\. \*\*Mantenibilidad\*\*: Al no modificar el código base, reduces el riesgo de introducir errores en el código existente. 3\. \*\*Flexibilidad\*\*: Puedes intercambiar estrategias de descuento dinámicamente, haciendo el sistema más adaptable. \### Conclusión Aplicar el Principio Abierto/Cerrado permite que el sistema sea extensible y flexible. Este enfoque de diseño reduce la posibilidad de errores al minimizar los cambios en el código existente y fomenta la reutilización de componentes a través del polimorfismo.

Alguna vez usé este principio para crear un filtro con el patrón de filtrado por encadenamiento. Así permitía agregar nuevos filtros sin modificar los que ya existen. Yo lo utilicé para filtrar contratos, pero también puede ser aplicado a un listado de productos. Se puede crear una clase Filter que sirva como interfaz. Luego crear clases para cada tipo de filtro. Ejemplo: class PrecioFilter(Filter): class ColorFilter(Filter): class TipoFilter(Filter): . y otra clase para encadenar los filtros existentes.