Ejercicio resuelto: ticket con clases, herencia y métodos especiales en Python

La solución se apoya en tres ideas. La primera es una clase base abstracta que concentra todo el comportamiento común. La segunda son dos subclases mínimas que solo aportan el cálculo del importe y el texto del detalle. La tercera es un contenedor, Ticket, que se comporta como una colección de Python gracias a __len__ e __iter__. El dinero se trata siempre en céntimos enteros, y solo se convierte a texto en la función euros, en el último momento.

Si quieres repasar antes los conceptos básicos de clase, constructor y herencia, en el blog tienes el mismo tema explicado en Java en el ejercicio de herencia, constructores y super. La traducción a Python es casi directa, salvo por super() y por los métodos especiales.

import sys
from abc import ABC, abstractmethod


def euros(centimos):
    """Convierte céntimos enteros (>= 0) al formato 14,62."""
    return f"{centimos // 100},{centimos % 100:02d}"


class Linea(ABC):
    TIPO = "?"

    def __init__(self, nombre, precio, cantidad):
        if precio <= 0 or cantidad <= 0:
            raise ValueError("precio y cantidad deben ser positivos")
        self.nombre = nombre
        self.precio = precio
        self.cantidad = cantidad

    @abstractmethod
    def importe(self):
        """Importe de la línea en céntimos."""

    @abstractmethod
    def detalle(self):
        """Texto entre el nombre y el signo igual."""

    def __eq__(self, otro):
        if not isinstance(otro, Linea):
            return NotImplemented
        return (type(self) is type(otro)
                and self.nombre == otro.nombre
                and self.precio == otro.precio)

    def __hash__(self):
        return hash((type(self), self.nombre, self.precio))

    def __add__(self, otro):
        if not isinstance(otro, Linea):
            return NotImplemented
        if self != otro:
            raise ValueError("no se pueden sumar productos distintos")
        return type(self)(self.nombre, self.precio,
                          self.cantidad + otro.cantidad)

    def clave_orden(self):
        return (-self.importe(), self.nombre, self.TIPO, self.precio)

    def __str__(self):
        return f"{self.nombre} {self.detalle()} = {euros(self.importe())}"


class LineaUnidad(Linea):
    TIPO = "U"

    def importe(self):
        return self.precio * self.cantidad

    def detalle(self):
        return f"{self.cantidad} x {euros(self.precio)}"


class LineaPeso(Linea):
    TIPO = "P"

    def importe(self):
        # precio en céntimos/kg, cantidad en gramos; mitades hacia arriba
        return (self.precio * self.cantidad + 500) // 1000

    def detalle(self):
        return f"{self.cantidad} g a {euros(self.precio)}/kg"


class Ticket:
    def __init__(self):
        self._lineas = []

    def agregar(self, linea):
        for i, existente in enumerate(self._lineas):
            if existente == linea:
                self._lineas[i] = existente + linea
                return
        self._lineas.append(linea)

    def __len__(self):
        return len(self._lineas)

    def __iter__(self):
        return iter(sorted(self._lineas, key=Linea.clave_orden))

    def total(self):
        return sum(linea.importe() for linea in self._lineas)

    def __str__(self):
        filas = [str(linea) for linea in self]
        filas.append(f"Lineas: {len(self)}")
        filas.append(f"TOTAL: {euros(self.total())}")
        return "\n".join(filas)


TIPOS = {"U": LineaUnidad, "P": LineaPeso}


def main():
    ticket = Ticket()
    for texto in sys.stdin:
        partes = texto.split()
        if not partes:
            continue
        clase = TIPOS[partes[0]]
        ticket.agregar(clase(partes[1], int(partes[2]), int(partes[3])))
    print(ticket)


main()

La clase base. Linea hereda de ABC y declara importe y detalle como métodos abstractos. Con eso, Linea("x", 1, 1) lanza TypeError, y cualquier subclase que olvide uno de los dos métodos tampoco se podrá instanciar. El constructor valida que precio y cantidad sean positivos. El enunciado garantiza entradas válidas, pero un objeto no debería poder nacer en un estado imposible. El atributo de clase TIPO sirve para el desempate en la ordenación, y cada subclase lo redefine.

Igualdad y hash. __eq__ devuelve NotImplemented si el otro operando no es una línea. Así Python puede intentar la comparación inversa y, si tampoco funciona, acaba devolviendo False. La comparación usa type(self) is type(otro) y no isinstance, porque una línea de peso y otra de unidad con el mismo nombre y precio no son el mismo producto. Al redefinir __eq__, Python pone __hash__ a None. Por eso lo redefinimos con la misma tupla de campos que la igualdad. Objetos iguales tienen así el mismo hash, que es lo que exigen set y dict.

Fusión con +. __add__ reutiliza la igualdad (self != otro) para rechazar productos distintos y construye el resultado con type(self)(...). Ese detalle es lo que permite escribir la fusión una sola vez en la base: si self es una LineaPeso, el resultado es una LineaPeso. Los operandos no se modifican. Se devuelve un objeto nuevo, como hace + con números y cadenas. Eso evita sorpresas si alguien guarda una referencia a la línea original.

Las subclases. LineaUnidad.importe multiplica sin más. LineaPeso.importe calcula (self.precio * self.cantidad + 500) // 1000, que es el redondeo con las mitades hacia arriba en aritmética entera. El caso «redondeo y fusión a granel» lo pone a prueba. Una línea de 1 g de nueces a 15,00/kg vale 1,5 céntimos y se imprime como 0,02. Las dos líneas de 2 g de uvas, al fusionarse, suman 4 g y valen 1 céntimo, no 2. El método __str__ de la base compone la línea llamando a detalle() e importe(), que se resuelven por enlace dinámico en la subclase.

El contenedor. Ticket.agregar recorre la lista y, si encuentra una línea igual (existente == linea), la sustituye por existente + linea. Si no, añade la nueva al final. __len__ permite escribir len(ticket). __iter__ devuelve un iterador sobre la lista ordenada con key=Linea.clave_orden, cuya tupla (-importe, nombre, TIPO, precio) codifica el criterio del enunciado. El importe va cambiado de signo para que quede de mayor a menor. Finalmente, __str__ recorre self con un for, lo que invoca __iter__, y añade el recuento y el total.

Comprobación con los tests. En el ejemplo, el queso aparece dos veces (250 g y 130 g) y se fusiona en una línea de 380 g que vale 7,18. Los cafés se fusionan en 3 unidades. El caso «mismo nombre, distinto producto» tiene tres líneas de pan que no se fusionan entre sí: dos por unidades con precios distintos y una a granel. También tiene un empate a 3,00 entre pan a granel y zumo, que se resuelve por nombre. La entrada vacía imprime Lineas: 0 y TOTAL: 0,00, porque sum de una secuencia vacía es 0. El caso de importes grandes muestra que euros no necesita separador de miles.