Código Python: comparar PEPS, UEPS y promedio ponderado con los mismos datos

Código Python: comparar PEPS, UEPS y promedio ponderado con los mismos datos

Tres personas del mismo negocio pueden dar tres costos distintos para la misma venta y ninguna se equivocó. La culpa no es de la calculadora: está en el método con el que se decide qué compra se descarga cuando sale mercancía. Si el 5 de marzo salieron 90 bultos de cemento, ¿salieron de la compra de 100 bultos a 18 000 del 2 de marzo, o de la compra de 60 bultos a 20 000 del 9 de marzo, que ese día aún no había llegado a la bodega? Contablemente las dos respuestas existen: PEPS dice que salió primero lo primero que entró, UEPS dice que salió primero lo último que entró, y el promedio ponderado reparte el costo entre todo lo que había disponible.

Este programa pone los tres métodos a trabajar sobre exactamente los mismos diez movimientos y las mismas 360 unidades vendidas. Al final imprime una sola tabla con el costo de ventas de cada método, el inventario final en unidades y en valor, la utilidad bruta y cuánto se aparta cada método del promedio. Está escrito para el dueño de la pyme que quiere entender por qué el informe del contador no coincide con su cálculo de cabeza; para el contador que necesita mostrar el efecto de un cambio de método sin armar una hoja de cálculo desde cero; y para el almacenista o auxiliar contable que revisa facturas contra el kardex del sistema y sospecha que algo no cuadra.

No hace falta saber programar. Se descomprime la carpeta, se abre la terminal y se ejecuta un comando. El programa usa solo la biblioteca estándar de Python, así que no hay que instalar absolutamente nada más, y funciona igual en Windows, Linux y Mac.

Qué hace el programa

1. Lee datos/movimientos.csv, con las columnas producto, fecha, tipo, detalle, cantidad y costo_unitario.
2. Lee datos/precios.csv (producto y precio_venta): solo lo necesita para calcular la utilidad bruta de cada método sobre la misma venta neta.
3. Calcula el método PEPS: cada compra abre un lote con su cantidad y su costo unitario, y cada venta consume el lote más antiguo.
4. Calcula el método UEPS: la misma venta, pero consumiendo el lote más reciente.
5. Calcula el promedio ponderado: recalcula el costo promedio después de cada compra y valora cada venta al promedio vigente en ese momento.
6. Suma los tres resultados, obtiene la utilidad bruta y la diferencia de cada método contra el promedio.
7. Imprime la tabla comparativa, el saldo final por método y una conclusión, y guarda la misma tabla en salida/comparacion.csv para abrirla en Excel.

Cómo ejecutarlo

Lo único que hay que tener instalado es Python 3.11 o superior. Si no está seguro de la versión, escríbalo en la terminal:

python --version

Después descomprima el ZIP en una carpeta cómoda, abra la terminal y entre a esa carpeta. En Windows puede escribir:

cd C:\ruta\a\la\carpeta\descomprimida

Y el programa se ejecuta con una sola línea:

python comparar_metodos.py

Eso es todo. No hay que crear un entorno virtual, no hay que instalar pandas ni nada parecido y no se necesita conexión a internet: el programa se apoya únicamente en csv, decimal y pathlib, que vienen con Python. Si el archivo de movimientos está en su sitio, la tabla aparece en pantalla en menos de un segundo y el CSV queda guardado en la carpeta salida.

El código, explicado

Todo el programa cabe en unas doscientas líneas. Estos son los pedazos que explican por qué el mismo negocio da tres costos distintos.

1. Qué hace y con qué. El encabezado lo dice sin adornos:

# ==========================================================================
#  PEPS · UEPS · PROMEDIO PONDERADO
#  Código Python didáctico para inventarios · Kardex Tauro · kardex-tauro.muisca.co
#  Qué hace: valora las MISMAS salidas con PEPS (FIFO), UEPS (LIFO) y promedio
#  ponderado, compara los tres resultados y los guarda en salida/comparacion.csv
#  Probado con Python 3.11. Solo biblioteca estándar: no hay que instalar nada.
# ==========================================================================

Fíjese en la última línea: solo biblioteca estándar. Por eso se descarga, se ejecuta y funciona sin pelear con instalaciones, versiones ni permisos.

2. Cada compra crea un lote. Aquí está el corazón del asunto. El programa no guarda un costo único del producto: guarda una lista de lotes, y cada lote es una bolsa con su cantidad y su costo unitario.

def por_lotes(movimientos: list[dict], ultimo_primero: bool) -> dict:
    """Motor de lotes: la venta consume el lote más antiguo (PEPS) o el más reciente (UEPS)."""
    estado = {}
    for movimiento in movimientos:
        producto = movimiento["producto"]
        cuenta = estado.setdefault(producto, {"lotes": [], "cantidad": CERO, "valor": CERO,
                                              "vendidas": CERO, "costo_ventas": CERO})
        cantidad = Decimal(movimiento["cantidad"])
        if movimiento["tipo"] == TIPO_ENTRADA:
            # # Cada compra crea un lote con su cantidad y su costo unitario
            costo = Decimal(movimiento["costo_unitario"])
            cuenta["lotes"].append({"cantidad": cantidad, "costo": costo})
            cuenta["cantidad"] += cantidad
            cuenta["valor"] += redondear(cantidad * costo)

Esa lista de lotes es la memoria que permite que el costo de una venta dependa de qué compra se descargue. Sin lotes no hay PEPS ni UEPS: habría un solo costo y un solo resultado.

3. La venta consume lotes, y ahí se decide todo. Cuando llega una venta, el programa va tomando lotes hasta despachar la cantidad pedida. Puede que una sola venta necesite parte de un lote y parte de otro, y por eso hay un ciclo while: la venta no se detiene porque se acabe un lote, sigue con el siguiente.

        elif movimiento["tipo"] == TIPO_SALIDA:
            # # Una venta puede consumir VARIOS lotes, con costos distintos
            indice = -1 if ultimo_primero else 0
            pendiente, costo_total = cantidad, CERO
            while pendiente > 0:
                lote = cuenta["lotes"][indice]
                toma = min(pendiente, lote["cantidad"])
                costo_total += redondear(toma * lote["costo"])
                lote["cantidad"] -= toma
                pendiente -= toma
                if lote["cantidad"] == 0:
                    cuenta["lotes"].pop(indice)
            cuenta["cantidad"] -= cantidad
            cuenta["valor"] -= costo_total

Lea con calma la primera línea de este pedazo. Toda la diferencia entre PEPS y UEPS vive ahí: en el índice del lote que se toma. Con el índice cero se toma el lote más antiguo, es decir PEPS. Con el índice menos uno se toma el último que entró, es decir UEPS. Todo lo demás es idéntico. Por eso los dos métodos venden las mismas 360 unidades y solo cambia el costo: lo que cambia es de dónde sale la mercancía, no cuánta salió.

4. Dos nombres para el mismo motor. Las funciones públicas de PEPS y UEPS son casi un chiste: llaman al mismo motor de lotes con un interruptor en falso o en verdadero.

def peps(movimientos: list[dict]) -> dict:
    """Método PEPS (FIFO): primero en entrar, primero en salir."""
    # # PEPS: la venta agota primero el lote MÁS ANTIGUO (cola FIFO)
    return por_lotes(movimientos, False)


def ueps(movimientos: list[dict]) -> dict:
    """Método UEPS (LIFO): último en entrar, primero en salir."""
    # # UEPS: la venta agota primero el lote MÁS RECIENTE (pila LIFO)
    return por_lotes(movimientos, True)

Esto es lo que mucha gente no ve cuando discute métodos de inventario: no son dos programas distintos, son la misma mecánica con un criterio distinto sobre cuál lote sale primero.

5. El promedio ponderado no usa lotes. Usa un solo cajón por producto: suma cantidades y valores, y valora cada venta al promedio vigente antes de descontarla.

        elif movimiento["tipo"] == TIPO_SALIDA:
            # Cada venta se valora al promedio vigente ANTES de descontarla.
            vigente = redondear(cuenta["valor"] / cuenta["cantidad"]) if cuenta["cantidad"] else CERO
            costo = redondear(cantidad * vigente)
            cuenta["cantidad"] -= cantidad
            cuenta["valor"] -= costo
            cuenta["vendidas"] += cantidad
            cuenta["costo_ventas"] += costo

Ese detalle de antes de descontarla importa: si el programa descontara primero y promediara después, cada venta alteraría el costo con el que se valora ella misma. Y hay una segunda consecuencia que conviene advertir: este es un promedio móvil, se recalcula con cada compra. Si su contador usa un promedio del mes o un promedio periódico, las cifras no van a coincidir céntimo a céntimo, y no es que uno esté mal: son dos formas distintas de promediar.

6. La conclusión, sin números escritos a mano. El programa no imprime un texto fijo: busca entre los resultados el inventario más caro y el más barato, y muestra la diferencia.

    # # Con costos al alza PEPS deja el inventario más caro y UEPS el más barato; el promedio reparte.
    # # Cuál se puede usar NO lo decide el programa: lo manda la norma contable local.
    caro = max(filas, key=lambda fila: fila["inv_val"])
    barato = min(filas, key=lambda fila: fila["inv_val"])
    diferencia = redondear(caro["inv_val"] - barato["inv_val"])

El comentario del código lo explica mejor que cualquier manual, y vale la pena repetirlo: con costos al alza PEPS deja el inventario al costo más reciente, que es el más caro, y el costo de ventas más bajo; UEPS hace lo contrario; el promedio queda en el medio. Y cierra con la advertencia más honesta de todo el programa: cuál método se puede usar no lo decide el programa, lo manda la norma contable de su país y la política interna de la empresa.

Qué vas a ver en pantalla

Con los datos de ejemplo (dos productos, diez movimientos, 360 unidades vendidas y 190 en bodega) la tabla sale así:

El bloque de cierre de la pantalla lo dice sin rodeos:

CONCLUSIÓN
  Inventario más caro: PEPS (FIFO) = 1.042.500,00
  Inventario más barato: UEPS (LIFO) = 970.500,00
  Diferencia (es solo de método, no dinero perdido): 72.000,00

Vale la pena detenerse en la última línea. Entre el inventario más caro y el más barato hay una diferencia de 72 000, y no es dinero perdido ni ganado: cuando se venda ese saldo de 190 unidades, la diferencia se revierte. Lo que el método decide es en qué mes aparece el costo, no cuánto cuesta la mercancía en total. Por eso conviene mirar la utilidad de un período largo y no la de un mes aislado cuando se compara un método contra otro. El mismo resultado queda en salida/comparacion.csv en formato plano, listo para la hoja de cálculo: 3240000.00 de costo de ventas en PEPS, 3312000.00 en UEPS y 3276397.70 en promedio, con inventarios finales de 1042500.00 y 970500.00 y una diferencia de 72000.00.

Errores comunes y consejos

• No mezcle nombres de producto mal escritos. El programa separa los saldos por el nombre del producto. Si en una línea escribió Cemento gris 50 kg y en otra Cemento Gris 50 Kg, para el programa son dos productos distintos y los saldos quedan partidos.
• Las ventas van sin costo unitario. En el archivo de ejemplo la columna queda vacía en las ventas, y así debe quedar: el costo lo calcula el programa según el método que se esté evaluando.
• Si una venta supera el saldo, el programa se detiene con un error. Es a propósito: significa que falta registrar una compra o que hay una venta duplicada. Revise el archivo antes de seguir, no lo tape.
• Cargue los movimientos en orden de fecha. Los tres métodos dependen del orden: PEPS y UEPS porque consumen lotes en un sentido o en otro, y el promedio porque se recalcula al vuelo. Un archivo desordenado da un resultado que no significa nada.
• Los centavos del promedio son normales. El promedio ponderado casi nunca da cifras redondas, y por eso el programa trabaja con centavos y los arrastra. Si compara contra un sistema que redondea al peso, va a encontrar diferencias pequeñas.
• No compare métodos distintos entre meses. El efecto del método solo se ve con los mismos movimientos: si cambia el método y también el período, nunca sabrá qué causó la diferencia.
• Guarde el CSV de cada prueba. La tabla comparativa es la evidencia de su decisión. Si más adelante alguien pregunta por qué se usa un método y no otro, ese archivo responde.

Cuándo esto no alcanza

Este programa es un laboratorio de escritorio: lee un CSV, calcula y termina. No identifica usuarios, no registra quién editó un movimiento, no maneja varias bodegas, no cruza órdenes de compra con facturas y no deja rastro para una auditoría. Cuando el inventario ya no cabe en una hoja de cálculo y un script —porque hay varios bodegueros, cientos de referencias y movimientos todos los días— lo razonable es pasar a un software de inventario que sostenga el kardex solo. Kardex Tauro es un programa gratuito que hace justamente eso: ordena el inventario y lleva los saldos sin que usted tenga que tocar archivos de datos. Este código sirve para lo de antes: entender la lógica, probar el efecto de los tres métodos y saber qué está mirando cuando el sistema le muestre un costo.

Descargue el ZIP, córralo con los datos de ejemplo y después cambie el archivo por sus propios movimientos. Cuando vea los tres costos uno al lado del otro va a entender de una vez por qué el método de inventario es una decisión contable y no un simple cálculo: la mercancía es la misma, las unidades vendidas son las mismas y, aun así, la utilidad del mes cambia.