POO avanzada: herencia, composición y modularidad

Hay empleados de salario fijo, por hora (con horas extra) y vendedores (base + comisión). ¿Cómo calculo la planilla sin un if por tipo en cada lugar?

Los tres son empleados: tienen nombre y un pago. Lo que cambia es cómo se calcula el pago. Una clase madre con lo común y una hija por cada forma de pago.

class Empleado:
    def __init__(self, nombre, salario_base):
        self.nombre = nombre
        self.salario_base = salario_base

    def calcular_pago(self):
        return self.salario_base

    def __str__(self):
        return f"{self.nombre:<6} {type(self).__name__:<11} ${self.calcular_pago():>9,.2f}"


class PorHora(Empleado):
    def __init__(self, nombre, tarifa, horas):
        super().__init__(nombre, 0)
        self.tarifa = tarifa
        self.horas = horas

    def calcular_pago(self):                       # redefine el de Empleado
        extra = max(0, self.horas - 160) * self.tarifa * 0.5
        return self.horas * self.tarifa + extra


class Vendedor(Empleado):
    def __init__(self, nombre, salario_base, ventas, comision=0.05):
        super().__init__(nombre, salario_base)
        self.ventas = ventas
        self.comision = comision

    def calcular_pago(self):
        return super().calcular_pago() + self.ventas * self.comision


planilla = [Empleado("Ana", 900), PorHora("Luis", 4.5, 170), Vendedor("Eva", 500, 12000)]
for e in planilla:                                  # polimorfismo
    print(e)
print(f"Total planilla: ${sum(e.calcular_pago() for e in planilla):,.2f}")

Ana    Empleado    $   900.00
Luis   PorHora     $   787.50
Eva    Vendedor    $ 1,100.00
Total planilla: $2,787.50

super().__init__ reutiliza la inicialización; super().calcular_pago() en Vendedor reutiliza el cálculo base y le suma la comisión. El bucle final no sabe ni le importa qué tipo es cada empleado: eso es polimorfismo.

La tienda acepta efectivo, tarjeta (3.5 % de comisión) y transferencia ($0.75 si el monto es menor a $100). ¿Cómo cobrar sin un if por forma de pago?

El proceso de cobro es el mismo; lo que cambia es la comisión. La clase madre define cobrar usando self.comision(...), y cada hija redefine solo comision.

class MetodoPago:
    nombre = "genérico"

    def comision(self, monto):
        return 0

    def cobrar(self, monto):
        total = round(monto + self.comision(monto), 2)
        return f"{self.nombre:<13} cobra ${total:>7.2f} (comisión ${self.comision(monto):.2f})"


class Efectivo(MetodoPago):
    nombre = "efectivo"


class Tarjeta(MetodoPago):
    nombre = "tarjeta"

    def comision(self, monto):
        return round(monto * 0.035, 2)            # 3.5 % del banco


class Transferencia(MetodoPago):
    nombre = "transferencia"

    def comision(self, monto):
        return 0.75 if monto < 100 else 0          # cargo fijo en montos pequeños


for metodo in [Efectivo(), Tarjeta(), Transferencia()]:
    print(metodo.cobrar(80))

efectivo      cobra $  80.00 (comisión $0.00)
tarjeta       cobra $  82.80 (comisión $2.80)
transferencia cobra $  80.75 (comisión $0.75)

cobrar está escrito una sola vez, en la madre. Al llamarlo, self.comision usa la versión de la hija correspondiente. Para agregar “billetera electrónica” basta una clase nueva de 4 líneas.

¿Cómo modelo una factura donde cada línea sabe su subtotal y la factura sabe su total?

Tres clases con responsabilidades separadas: Producto (precio), Linea (producto + cantidad) y Factura (lista de líneas). La factura no calcula subtotales: se los pide a sus líneas.

class Producto:
    def __init__(self, codigo, nombre, precio):
        self.codigo = codigo
        self.nombre = nombre
        self.precio = precio


class Linea:
    def __init__(self, producto, cantidad):
        self.producto = producto           # una línea TIENE un producto
        self.cantidad = cantidad

    def subtotal(self):
        return self.producto.precio * self.cantidad


class Factura:
    def __init__(self, numero, cliente):
        self.numero = numero
        self.cliente = cliente
        self.lineas = []                   # una factura TIENE varias líneas

    def agregar(self, producto, cantidad):
        self.lineas.append(Linea(producto, cantidad))

    def total(self):
        return round(sum(l.subtotal() for l in self.lineas) * 1.13, 2)


aceite = Producto("A01", "Aceite 1 L", 12.50)
cafe = Producto("D03", "Café 400 g", 6.75)
f = Factura("F-0002", "Comedor Lupita")
f.agregar(aceite, 2)
f.agregar(cafe, 3)
for l in f.lineas:
    print(f"{l.cantidad} x {l.producto.nombre:<11} ${l.subtotal():.2f}")
print("Total:", f.total())

aceite.precio = 13.00                    # sube el precio del producto
print("Total después del cambio de precio:", f.total())

2 x Aceite 1 L  $25.00
3 x Café 400 g  $20.25
Total: 51.13
Total después del cambio de precio: 52.26

La última línea muestra un efecto de compartir objetos: la línea guarda una referencia al producto, no una copia. Si el precio cambia, las facturas abiertas lo ven. En un sistema real, la línea debería guardar el precio al momento de la venta. Esa es una decisión de diseño que debes poder defender.