Open Closed Principle: extensión sin modificación

Clase 5 de 27 • Curso de Patrones de Diseño y SOLID en Python

Resumen

Domina el principio abierto cerrado, o Open Closed Principle, de SOLID para crear software en Python que crece sin romperse. Abierto para su extensión y cerrado para su modificación: así respondes a cambios del negocio con estabilidad, menos errores y actualizaciones rápidas.

¿Qué es el principio abierto cerrado y por qué importa?

El principio establece que el software debe estar abierto para su extensión, pero cerrado para su modificación. Responde a la naturaleza cambiante del software: agregar nuevas funcionalidades, ajustar las existentes o eliminar las que ya no aportan. Al no tocar código probado, evitas introducir fallas y mantienes la estabilidad del sistema.

¿Qué significa abierto para extensión?

Agregar nuevas capacidades sin alterar la base de código.

Nuevas funcionalidades que se suman como comportamientos adicionales.
Uso de interfaces, abstracciones y polimorfismo para ampliar sin reescribir.
Flexibilidad para evolucionar el producto con menor riesgo.

¿Qué implica cerrado para modificación?

Proteger el código ya validado y en producción.

Evitar cambios sobre lo que está probado y funciona.
Fomentar encapsulamiento y coherencia del diseño.
Reducir errores y acelerar las actualizaciones.

¿Cómo aplicarlo en Python con interfaces, abstracciones y polimorfismo?

En Python, apoyarte en abstracciones y polimorfismo permite agregar comportamientos nuevos sin modificar lo anterior. Diseñas puntos de extensión claros y dejas intacto lo que ya fue validado, cuidando la calidad y el tiempo de entrega.

¿Qué habilidades y conceptos activa?

Diseñar con interfaces y abstracciones para aislar cambios.
Aplicar polimorfismo para intercambiar comportamientos sin tocar el núcleo.
Mantener encapsulamiento para proteger invariantes del sistema.
Priorizar estabilidad con evolución rápida del producto.

¿Qué beneficios directos se observan?

Menos errores al no modificar código probado.
Actualizaciones más fáciles y entregas rápidas.
Mejor respuesta a cambios de requisitos del negocio.

¿Cuándo aplicarlo en un procesador de pagos con Stripe y nuevas pasarelas?

Cuando necesites extender el comportamiento sin tocar el código existente. El ejemplo citado: un procesador de pagos donde se desea añadir una nueva pasarela distinta a Stripe o una nueva forma de notificación más allá de correo electrónico o mensaje de texto.

¿Qué ejemplos prácticos menciona?

Agregar una pasarela diferente a Stripe sin modificar la integración actual.
Incorporar otro canal de notificación además de correo o SMS.
Responder a cambios frecuentes de requisitos sin romper lo que ya funciona.
Garantizar que lo nuevo sea coherente con lo existente.

Comparte en comentarios cómo aplicarías el principio Open Closed al procesador de pagos en el que trabajas y cómo lo has usado en tu día a día para desarrollar con estabilidad y rapidez.

Jovanny Delgado

student•

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.

Juan Andres Bravo Freitez

student•

muy buen aporte

Mario Alexander Vargas Celis

student•

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.


class DiscountCalculator:

&#x20;   def calculate(self, price, discount\_type):

&#x20;       if discount\_type == "percentage":

&#x20;           return price \* 0.90  # 10% de descuento

&#x20;       elif discount\_type == "fixed":

&#x20;           return price - 20  # Descuento fijo de $20

&#x20;       else:

&#x20;           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.


from abc import ABC, abstractmethod



class DiscountStrategy(ABC):

&#x20;   @abstractmethod

&#x20;   def apply\_discount(self, price):

&#x20;       pass



class PercentageDiscount(DiscountStrategy):

&#x20;   def apply\_discount(self, price):

&#x20;       return price \* 0.90  # 10% de descuento



class FixedDiscount(DiscountStrategy):

&#x20;   def apply\_discount(self, price):

&#x20;       return price - 20  # Descuento fijo de $20



class NoDiscount(DiscountStrategy):

&#x20;   def apply\_discount(self, price):

&#x20;       return price  # Sin descuento



class DiscountCalculator:

&#x20;   def \_\_init\_\_(self, strategy: DiscountStrategy):

&#x20;       self.strategy = strategy



&#x20;   def calculate(self, price):

&#x20;       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:


\# 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.

JHONATAN DAVID RESTREPO HENAO

student•

🧠 Preguntas clave para saber si necesitas OCP

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

Pablo Torres Pérez

student•

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.

Joel Gabriel Germán Valdez

student•

Un ejemplo en aplicar este principio en el ejercicio propuesto, seria agregar otra pasarela de pago como PayPal, Authorize etc, es decir haciendo otra clase mas con sus respectivos metodos y configuraciones y simplemente agregandola como otra opcion al PaymentServices

César Ernesto Rivas Martínez

student•

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

Open Closed Principle: extensión sin modificación

Patrones de Diseño y Principios SOLID

Patrones de diseño y SOLID en Python

Principios SOLID

Principio de responsabilidad única en SOLID

Refactorizando código Python con principios SOLID

Cómo aplicar SRP en un procesador de pagos con Stripe