Patrón Strategy

from abc import ABC, abstractmethod


class EstrategiaEnvio(ABC):
    """La estrategia: una forma de calcular el envío."""
    @abstractmethod
    def coste(self, kg, km): ...


class Estandar(EstrategiaEnvio):
    def coste(self, kg, km):
        return 3 + 0.5 * kg


class Urgente(EstrategiaEnvio):
    def coste(self, kg, km):
        return 8 + kg + 0.02 * km


class Pedido:
    """El contexto: usa una estrategia sin saber cuál es."""
    def __init__(self, kg, km):
        self.kg, self.km = kg, km
        self.estrategia = Estandar()

    def set_estrategia(self, e):                 # se cambia en tiempo de ejecución
        self.estrategia = e

    def coste_envio(self):                       # ni un if sobre el tipo de envío
        return self.estrategia.coste(self.kg, self.km)


class RecogidaEnTienda(EstrategiaEnvio):
    def coste(self, kg, km):
        return 0


def euros(x):
    return f"{x:.2f}".replace(".", ",") + " €"


p = Pedido(2, 300)
print("Estándar:", euros(p.coste_envio()))
p.set_estrategia(Urgente())
print("Urgente:", euros(p.coste_envio()))
p.set_estrategia(RecogidaEnTienda())
print("Recogida en tienda:", euros(p.coste_envio()))

/** Cada estrategia es una clase con el mismo método: coste(kg, km). */
class Estandar {
    coste(kg, km) { return 3 + 0.5 * kg; }
}

class Urgente {
    coste(kg, km) { return 8 + kg + 0.02 * km; }
}

/** El contexto: usa una estrategia sin saber cuál es. */
class Pedido {
    estrategia = new Estandar();
    constructor(kg, km) { this.kg = kg; this.km = km; }

    setEstrategia(e) { this.estrategia = e; }                        // se cambia en tiempo de ejecución

    costeEnvio() { return this.estrategia.coste(this.kg, this.km); } // ni un if sobre el tipo de envío
}

const euros = (x) => x.toFixed(2).replace(".", ",") + " €";

const p = new Pedido(2, 300);
console.log("Estándar: " + euros(p.costeEnvio()));
p.setEstrategia(new Urgente());
console.log("Urgente: " + euros(p.costeEnvio()));
p.setEstrategia({ coste: () => 0 });        // vale cualquier objeto con un método coste
console.log("Recogida en tienda: " + euros(p.costeEnvio()));

using System;
using System.Globalization;

// La estrategia: una forma de calcular el envío.
interface IEstrategiaEnvio {
    double Coste(double kg, double km);
}

class Estandar : IEstrategiaEnvio {
    public double Coste(double kg, double km) => 3 + 0.5 * kg;
}

class Urgente : IEstrategiaEnvio {
    public double Coste(double kg, double km) => 8 + kg + 0.02 * km;
}

class RecogidaEnTienda : IEstrategiaEnvio {
    public double Coste(double kg, double km) => 0;
}

// El contexto: usa una estrategia sin saber cuál es.
class Pedido {
    private readonly double kg, km;
    private IEstrategiaEnvio estrategia = new Estandar();

    public Pedido(double kg, double km) { this.kg = kg; this.km = km; }

    public void SetEstrategia(IEstrategiaEnvio e) => estrategia = e;   // se cambia en tiempo de ejecución

    public double CosteEnvio() => estrategia.Coste(kg, km);            // ni un if sobre el tipo de envío
}

class Program {
    static void Main() {
        var es = CultureInfo.GetCultureInfo("es-ES");
        var p = new Pedido(2, 300);
        Console.WriteLine("Estándar: " + p.CosteEnvio().ToString("F2", es) + " €");
        p.SetEstrategia(new Urgente());
        Console.WriteLine("Urgente: " + p.CosteEnvio().ToString("F2", es) + " €");
        p.SetEstrategia(new RecogidaEnTienda());
        Console.WriteLine("Recogida en tienda: " + p.CosteEnvio().ToString("F2", es) + " €");
    }
}

<?php
/** La estrategia: una forma de calcular el envío. */
interface EstrategiaEnvio {
    public function coste(float $kg, float $km): float;
}

class Estandar implements EstrategiaEnvio {
    public function coste(float $kg, float $km): float { return 3 + 0.5 * $kg; }
}

class Urgente implements EstrategiaEnvio {
    public function coste(float $kg, float $km): float { return 8 + $kg + 0.02 * $km; }
}

/** El contexto: usa una estrategia sin saber cuál es. */
class Pedido {
    private EstrategiaEnvio $estrategia;

    public function __construct(private float $kg, private float $km) {
        $this->estrategia = new Estandar();
    }

    public function setEstrategia(EstrategiaEnvio $e): void { $this->estrategia = $e; }   // se cambia en tiempo de ejecución

    public function costeEnvio(): float { return $this->estrategia->coste($this->kg, $this->km); }   // ni un if
}

function euros(float $x): string { return number_format($x, 2, ",", ".") . " €"; }

$p = new Pedido(2, 300);
echo "Estándar: " . euros($p->costeEnvio()) . "\n";
$p->setEstrategia(new Urgente());
echo "Urgente: " . euros($p->costeEnvio()) . "\n";
$p->setEstrategia(new class implements EstrategiaEnvio {       // una clase anónima también vale
    public function coste(float $kg, float $km): float { return 0; }
});
echo "Recogida en tienda: " . euros($p->costeEnvio()) . "\n";

# key= es la estrategia de ordenación: sort no cambia, la forma de comparar sí
alumnos = cargar_alumnos()
alumnos.sort(key=lambda a: a.nota, reverse=True)       # por nota, de mayor a menor
alumnos.sort(key=lambda a: (a.curso, a.nombre))        # por curso y, dentro, por nombre

// La función de comparación es la estrategia: sort no cambia, la forma de comparar sí
const alumnos = cargarAlumnos();
alumnos.sort((a, b) => b.nota - a.nota);                                         // por nota, de mayor a menor
alumnos.sort((a, b) => a.curso - b.curso || a.nombre.localeCompare(b.nombre));   // por curso y, dentro, por nombre

// El selector de clave es la estrategia: OrderBy no cambia, la forma de comparar sí
List<Alumno> alumnos = CargarAlumnos();
var porNota = alumnos.OrderByDescending(a => a.Nota).ToList();                 // por nota, de mayor a menor
var porCurso = alumnos.OrderBy(a => a.Curso).ThenBy(a => a.Nombre).ToList();   // por curso y, dentro, por nombre

// La función de comparación es la estrategia: usort no cambia, la forma de comparar sí
$alumnos = cargarAlumnos();
usort($alumnos, fn($a, $b) => $b->nota <=> $a->nota);                                 // por nota, de mayor a menor
usort($alumnos, fn($a, $b) => [$a->curso, $a->nombre] <=> [$b->curso, $b->nombre]);   // por curso y, dentro, por nombre