Strategy Pattern con Python y setprocessor

Curso de Patrones de Diseño y SOLID en Python

Contenido del curso

Patrones de Diseño y Principios SOLID

1
Patrones de diseño y SOLID en Python
02:07 min

Principios SOLID

Reestructuración del proyecto

13
Reestructuración con módulos de Python y SOLID
13:32 min

Patrones de Diseño

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:001:55

Strategy Pattern con Python y setprocessor

Curso de Patrones de Diseño y SOLID en Python

Clase 15 de 27

Clase 15 / 27

Comentarios (3)3 comentarios

Mario Alexander Vargas Celis

Hace 2 años

El **Patrón Strategy** es un patrón de diseño de comportamiento que permite definir una familia de algoritmos, encapsular cada uno de ellos y hacerlos intercambiables. Este patrón facilita que los algoritmos puedan variar independientemente del cliente que los utiliza, promoviendo la extensibilidad y reducción de la complejidad.

### Conceptos Clave del Patrón Strategy

1. **Estrategia (Strategy)**: Es una interfaz o clase abstracta que define un comportamiento común para un conjunto de algoritmos o estrategias.

2. **Estrategias Concretas (Concrete Strategies)**: Son las clases que implementan el comportamiento de una estrategia específica.

3. **Contexto (Context)**: Es la clase que utiliza una estrategia para llevar a cabo su operación. El contexto contiene una referencia a una estrategia y permite cambiarla dinámicamente.

### Ejemplo en Python: Estrategia de Pago

Imaginemos que tenemos una tienda en línea que acepta diferentes métodos de pago. Usaremos el patrón Strategy para poder intercambiar fácilmente entre métodos de pago, como tarjeta de crédito, PayPal y criptomonedas.

#### Paso 1: Definir la Interfaz de Estrategia

Definimos una interfaz común que todos los métodos de pago deben implementar. Esta interfaz tiene un método pay que cada estrategia concreta debe sobreescribir.


from abc import ABC, abstractmethod



class PaymentStrategy(ABC):

&#x20;   @abstractmethod

&#x20;   def pay(self, amount):

&#x20;       pass

#### Paso 2: Crear las Estrategias Concretas

Implementamos diferentes métodos de pago como clases concretas que heredan de PaymentStrategy y proporcionan una implementación del método pay.


class CreditCardPayment(PaymentStrategy):

&#x20;   def pay(self, amount):

&#x20;       print(f"Paying {amount} using Credit Card.")



class PayPalPayment(PaymentStrategy):

&#x20;   def pay(self, amount):

&#x20;       print(f"Paying {amount} using PayPal.")



class CryptoPayment(PaymentStrategy):

&#x20;   def pay(self, amount):

&#x20;       print(f"Paying {amount} using Cryptocurrency.")

Cada clase concreta implementa pay de una manera diferente, proporcionando su propio comportamiento específico.

#### Paso 3: Crear la Clase Contexto

La clase ShoppingCart actúa como el contexto en el cual se usa el patrón Strategy. Esta clase permite que el usuario seleccione una estrategia de pago y luego la ejecuta al confirmar el pago.


class ShoppingCart:

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

&#x20;       self.total\_amount = 0

&#x20;       self.payment\_strategy = None



&#x20;   def add\_item(self, price):

&#x20;       self.total\_amount += price



&#x20;   def set\_payment\_strategy(self, strategy: PaymentStrategy):

&#x20;       self.payment\_strategy = strategy



&#x20;   def checkout(self):

&#x20;       if not self.payment\_strategy:

&#x20;           raise Exception("Payment strategy not set!")

&#x20;       self.payment\_strategy.pay(self.total\_amount)

- add\_item permite agregar el precio de los artículos al carrito.

- set\_payment\_strategy establece la estrategia de pago deseada (tarjeta, PayPal, etc.).

- checkout realiza el pago utilizando la estrategia de pago configurada.

#### Paso 4: Usar el Patrón Strategy

Con esta estructura, podemos cambiar la estrategia de pago en cualquier momento, sin modificar la clase ShoppingCart.


\# Crear un carrito de compras

cart = ShoppingCart()

cart.add\_item(50)

cart.add\_item(100)



\# Usar la estrategia de pago con tarjeta de crédito

cart.set\_payment\_strategy(CreditCardPayment())

cart.checkout()

\# Output: Paying 150 using Credit Card.



\# Cambiar la estrategia de pago a PayPal

cart.set\_payment\_strategy(PayPalPayment())

cart.checkout()

\# Output: Paying 150 using PayPal.



\# Cambiar la estrategia de pago a Criptomoneda

cart.set\_payment\_strategy(CryptoPayment())

cart.checkout()

\# Output: Paying 150 using Cryptocurrency.

### Ventajas del Patrón Strategy

1. **Extensibilidad**: Es fácil añadir nuevas estrategias sin modificar las clases existentes, simplemente creando nuevas clases de estrategia.

2. **Cambio Dinámico de Comportamiento**: Podemos cambiar el comportamiento del contexto en tiempo de ejecución sin modificar su código.

3. **Separación de Responsabilidades**: Cada algoritmo se encapsula en su propia clase, manteniendo un código más limpio y organizado.

### Desventajas del Patrón Strategy

1. **Aumento del Número de Clases**: Cada estrategia es una nueva clase, lo que puede aumentar la complejidad en proyectos grandes.

2. **Complejidad**: Puede ser excesivo para casos simples, especialmente si los algoritmos son pequeños y similares.

### Conclusión

El patrón Strategy en Python es útil cuando queremos implementar múltiples algoritmos o comportamientos intercambiables para una tarea específica. Nos permite cumplir con el Principio Abierto/Cerrado (OCP) al hacer el sistema extensible y modular, mejorando la mantenibilidad y escalabilidad de nuestras aplicaciones.

Jhon Alexander Triana Arcila

Hace un año

César Ernesto Rivas Martínez

Hace 2 años

El patron Strategy sirve comunmente para cuando tenemos diferentes escenarios ejecutables y se complementa con otros patrones de dise;o, por ejemplo el Factory, podrias tener un Lector de archivos y cada tipo de archivos es una estrategia de lectura y el factory se encarga de crear el Reader que ocuparas

Recursos

El Strategy Pattern te ayuda a diseñar software flexible y mantenible. Aquí verás cómo intercambiar múltiples algoritmos, modificar la estrategia en tiempo de ejecución y programar contra interfaces usando protocols de Python, con un ejemplo claro aplicado a un servicio de pagos y el método setprocessor en PaymentService.

¿Qué es el Strategy Pattern y por qué importa?

El Strategy es un patrón de diseño de comportamiento que permite definir una familia de algoritmos, encapsularlos y hacerlos intercambiables sin tocar la lógica de alto nivel. La clase de alto nivel depende de una interfaz, no de implementaciones concretas, y cada estrategia concreta implementa esa interfaz. Así, se inyecta la estrategia adecuada al contexto correcto.

Intercambio de algoritmos sin modificar el cliente.
Cambio de estrategia en tiempo de ejecución con un método dedicado.
Bajo acoplamiento al depender de interfaces o protocols.
Reutilización de código y mayor legibilidad.

¿Cómo se aplica en un servicio de pagos con Python?

En un flujo de pagos, la clase PaymentService expone un método setprocessor para cambiar la estrategia activa. Se definen tres procesadores como estrategias, todos cumpliendo la misma interfaz. La selección puede venir de una función externa que decide qué estrategia conviene según las condiciones del contexto y la inyecta en el servicio.

¿Cómo definir la interfaz con Protocol?

Usa Protocol para expresar la interfaz esperada por la clase de alto nivel. Así, cualquier implementación que cumpla la firma puede actuar como estrategia.

from typing import Protocol

class PaymentProcessor(Protocol):
    def process(self, amount: float) -> str: ...

class ProcessorOne:
    def process(self, amount: float) -> str:
        return f"Procesado con ProcessorOne: {amount}"

class ProcessorTwo:
    def process(self, amount: float) -> str:
        return f"Procesado con ProcessorTwo: {amount}"

class ProcessorThree:
    def process(self, amount: float) -> str:
        return f"Procesado con ProcessorThree: {amount}"

¿Cómo cambiar la estrategia con setprocessor?

La clase de alto nivel depende solo de la interfaz y ofrece setprocessor para modificar la estrategia en ejecución sin reiniciar ni reescribir lógica.

class PaymentService:
    def __init__(self, processor: PaymentProcessor):
        self._processor = processor

    def setprocessor(self, processor: PaymentProcessor) -> None:
        self._processor = processor

    def pay(self, amount: float) -> str:
        return self._processor.process(amount)

Puedes centralizar la elección en una función externa que retorna la estrategia adecuada según el contexto, y luego inyectarla con setprocessor.

def select_strategy(condicion: str) -> PaymentProcessor:
    if condicion == "opcion1":
        return ProcessorOne()
    if condicion == "opcion2":
        return ProcessorTwo()
    return ProcessorThree()

service = PaymentService(select_strategy("opcion1"))
service.pay(100.0)
service.setprocessor(select_strategy("opcion2"))
service.pay(150.0)

¿Qué habilidades y keywords conviene dominar?

Para aplicarlo con solidez conviene dominar los conceptos y su relación práctica en el código. Esto facilita seleccionar la estrategia correcta y mantener bajo acoplamiento.

Strategy Pattern: patrón de diseño de comportamiento para algoritmos intercambiables.
Algoritmos intercambiables: varias clases resuelven el mismo problema de formas distintas.
Modificación en tiempo de ejecución: cambiar la estrategia mientras el programa corre con setprocessor.
Interfaces y protocolos en Python: uso de Protocol para tipar y validar la estrategia.
Inyección de estrategia: selección e inyección del procesador en PaymentService.
Clases de alto y bajo nivel: alto nivel depende de una interfaz, bajo nivel implementa la interfaz.
Selección de estrategia externa: función o clase que decide la estrategia y la inyecta con setprocessor.

¿Has utilizado el Strategy Pattern? Comparte en comentarios cómo lo implementaste y qué decisiones de selección de estrategia te funcionaron mejor.

class CreditCardPayment(PaymentStrategy):

&#x20;   def pay(self, amount):

&#x20;       print(f"Paying {amount} using Credit Card.")

class PayPalPayment(PaymentStrategy):

&#x20;   def pay(self, amount):

&#x20;       print(f"Paying {amount} using PayPal.")

class CryptoPayment(PaymentStrategy):

&#x20;   def pay(self, amount):

&#x20;       print(f"Paying {amount} using Cryptocurrency.")

class ShoppingCart:

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

&#x20;       self.total\_amount = 0

&#x20;       self.payment\_strategy = None

&#x20;   def add\_item(self, price):

&#x20;       self.total\_amount += price

&#x20;   def set\_payment\_strategy(self, strategy: PaymentStrategy):

&#x20;       self.payment\_strategy = strategy

&#x20;   def checkout(self):

&#x20;       if not self.payment\_strategy:

&#x20;           raise Exception("Payment strategy not set!")

&#x20;       self.payment\_strategy.pay(self.total\_amount)

\# Crear un carrito de compras

cart = ShoppingCart()

cart.add\_item(50)

cart.add\_item(100)

\# Usar la estrategia de pago con tarjeta de crédito

cart.set\_payment\_strategy(CreditCardPayment())

cart.checkout()

\# Output: Paying 150 using Credit Card.

\# Cambiar la estrategia de pago a PayPal

cart.set\_payment\_strategy(PayPalPayment())

cart.checkout()

\# Output: Paying 150 using PayPal.

\# Cambiar la estrategia de pago a Criptomoneda

cart.set\_payment\_strategy(CryptoPayment())

cart.checkout()

\# Output: Paying 150 using Cryptocurrency.

Resumen

¿Qué es el Strategy Pattern y por qué importa?

Intercambio de algoritmos sin modificar el cliente.
Cambio de estrategia en tiempo de ejecución con un método dedicado.
Bajo acoplamiento al depender de interfaces o protocols.
Reutilización de código y mayor legibilidad.

¿Cómo se aplica en un servicio de pagos con Python?

¿Cómo definir la interfaz con Protocol?

Usa Protocol para expresar la interfaz esperada por la clase de alto nivel. Así, cualquier implementación que cumpla la firma puede actuar como estrategia.

from typing import Protocol

class PaymentProcessor(Protocol):
    def process(self, amount: float) -> str: ...

class ProcessorOne:
    def process(self, amount: float) -> str:
        return f"Procesado con ProcessorOne: {amount}"

class ProcessorTwo:
    def process(self, amount: float) -> str:
        return f"Procesado con ProcessorTwo: {amount}"

class ProcessorThree:
    def process(self, amount: float) -> str:
        return f"Procesado con ProcessorThree: {amount}"

¿Cómo cambiar la estrategia con setprocessor?

La clase de alto nivel depende solo de la interfaz y ofrece setprocessor para modificar la estrategia en ejecución sin reiniciar ni reescribir lógica.

class PaymentService:
    def __init__(self, processor: PaymentProcessor):
        self._processor = processor

    def setprocessor(self, processor: PaymentProcessor) -> None:
        self._processor = processor

    def pay(self, amount: float) -> str:
        return self._processor.process(amount)

Puedes centralizar la elección en una función externa que retorna la estrategia adecuada según el contexto, y luego inyectarla con setprocessor.

def select_strategy(condicion: str) -> PaymentProcessor:
    if condicion == "opcion1":
        return ProcessorOne()
    if condicion == "opcion2":
        return ProcessorTwo()
    return ProcessorThree()

service = PaymentService(select_strategy("opcion1"))
service.pay(100.0)
service.setprocessor(select_strategy("opcion2"))
service.pay(150.0)

¿Qué habilidades y keywords conviene dominar?

Para aplicarlo con solidez conviene dominar los conceptos y su relación práctica en el código. Esto facilita seleccionar la estrategia correcta y mantener bajo acoplamiento.

Strategy Pattern: patrón de diseño de comportamiento para algoritmos intercambiables.
Algoritmos intercambiables: varias clases resuelven el mismo problema de formas distintas.
Modificación en tiempo de ejecución: cambiar la estrategia mientras el programa corre con setprocessor.
Interfaces y protocolos en Python: uso de Protocol para tipar y validar la estrategia.
Inyección de estrategia: selección e inyección del procesador en PaymentService.
Clases de alto y bajo nivel: alto nivel depende de una interfaz, bajo nivel implementa la interfaz.
Selección de estrategia externa: función o clase que decide la estrategia y la inyecta con setprocessor.

¿Has utilizado el Strategy Pattern? Comparte en comentarios cómo lo implementaste y qué decisiones de selección de estrategia te funcionaron mejor.

Patrones de Diseño y Principios SOLID

Patrones de diseño y SOLID en Python

Principios SOLID

Qué es el principio de responsabilidad única

Procesador de pagos en Python con Stripe

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

Principio open-closed en Python

Clases abstractas y principio abierto-cerrado

Principio de Liskov en S.O.L.I.D.

Principio de sustitución de Liskov en Python

Principio de segregación de interfaces en SOLID

Segregación de interfaces en procesadores de pagos

Principio de inversión de dependencias en SOLID

Principio de inversión de dependencias: servicio de pagos flexible

Reestructuración del proyecto

Reestructuración con módulos de Python y SOLID

Patrones de Diseño

Qué son los patrones de diseño: definición y categorías

Strategy Pattern con Python y setprocessor

Strategy Pattern para pagos en Python

Factory Pattern: centralizar creación de objetos

Patrón Factory para procesar pagos con match

Qué es el patrón Decorator

Patrón decorador en servicios de pagos

Builder Pattern: construcción paso a paso

Builder Pattern aplicado a un servicio de pagos

Observer Pattern en sistemas de eventos

Observer en sistemas de pagos con Python

Chain of Responsibility para validar pagos

Chain of Responsibility en servicios de pagos

Código funcional vs código mantenible en Python

Strategy Pattern con Python y setprocessor

Progreso del curso

Patrones de Diseño y Principios SOLID

Principios SOLID

Reestructuración del proyecto

Patrones de Diseño

Recursos

Recursos