Estrategia (Patrón de diseño) — Python: Polimorfismo

• ¿Cuál es el problema?
• ¿Qué es el patrón Estrategia?
• Agregar una nueva estrategia: mayores de 65

A medida que avanzamos en programación, a menudo encontramos tareas que pueden resolverse de varias maneras según el contexto. Un buen ejemplo es calcular el costo de un seguro de viaje, que depende de factores como la duración del viaje, la edad del viajero o las actividades que realizará.

Cuando la lógica crece, el código puede volverse difícil de entender. Pero hay una solución: el el patrón de diseño llamado estrategia.

Hoy exploraremos cómo este patrón puede ayudarte a mantener tu código limpio, claro y fácil de adaptar.

¿Cuál es el problema?

Imaginemos que inicialmente tenemos algo así para calcular el valor del seguro:

if age < 18:
    cost = salary * age
    if country == 'uganda':
        cost = cost / 2
elif 18 <= age < 24:
    # y así seguimos agregando más condiciones...

¿Qué es el patrón Estrategia?

Así evitamos escribir mil condicionales en una sola función. Mejor usamos una clase diferente para cada caso.

Implementar el patrón Estrategia

Vamos a crear un sistema paso por paso que calcule el costo del seguro según el tipo de viajero:

1. Definir las estrategias

Cada estrategia es una manera diferente de calcular el costo.

class BasicInsuranceStrategy:
    def calculate(self, data: dict) -> float:
        # 100 pesos por cada día de viaje
        return data["days"] * 100


class ActiveRestInsuranceStrategy:
    def calculate(self, data: dict) -> float:
        # 200 pesos por día + 50 por cada actividad riesgosa
        return data["days"] * 200 + data["risk_activities"] * 50

Acá tenemos dos clases. Cada una tiene un método calculate() que recibe los datos y devuelve el costo, con fórmulas distintas según el perfil del viajero.

2. Crear el "calculador" principal

Este será quien decida qué estrategia usar:

class InsuranceCalculator:
    def __init__(self, strategy):
        # Guardamos la estrategia seleccionada
        self.strategy = strategy

    def calculate(self, data: dict) -> float:
        # Usamos esa estrategia para calcular
        return self.strategy.calculate(data)

Esto nos permite tener un solo objeto que puede calcular de mil formas diferentes, dependiendo de la estrategia que le pasemos.

3. Usar las estrategias

Ahora que tenemos todo listo, solo debemos elegir la estrategia correcta:

# Creamos dos estrategias
basic_strategy = BasicInsuranceStrategy()
active_rest_strategy = ActiveRestInsuranceStrategy()

# Usamos la estrategia básica
calculator = InsuranceCalculator(basic_strategy)
params = {"days": 10}
print(calculator.calculate(params))  # 1000

# Cambiamos a la estrategia de actividades riesgosas
calculator = InsuranceCalculator(active_rest_strategy)
params = {"days": 10, "risk_activities": 5}
print(calculator.calculate(params))  # 2250

Podemos cambiar fácilmente la forma de calcular sin tocar el código del InsuranceCalculator, simplemente usamos otra estrategia.

Agregar una nueva estrategia: mayores de 65

Supongamos que ahora necesitamos otro tipo de cálculo para personas mayores:

class SeniorInsuranceStrategy:
    def calculate(self, data: dict) -> float:
        # 150 pesos por día
        return data["days"] * 150

La incorporamos como antes:

senior_strategy = SeniorInsuranceStrategy()
calculator = InsuranceCalculator(senior_strategy)
params = {"days": 10}
print(calculator.calculate(params))  # 1500

Ya tenemos una nueva estrategia funcional, sin romper nada de lo anterior.

Tabla comparativa de estrategias

¿Cuándo usar el patrón Estrategia?

Este patrón es ideal cuando:

• Tenemos muchas formas distintas de hacer una tarea (como calcular precios).
• No queremos llenar el código de condiciones complicadas.
• Queremos que el sistema sea flexible, fácil de extender o cambiar.

⚠️

Pero ojo: si el número de estrategias empieza a ser muy alto, puede que necesitemos organizar mejor o pensar en otra forma de solución.