Modularización, funciones y ámbito

Alguien resolvió la facturación de tres clientes copiando y pegando el cálculo. Funciona… casi. ¿Qué tiene de malo y cómo se arregla?

# factura_plana.py — el "código espagueti" en pequeño
subtotal_1 = 12.50 * 3
if subtotal_1 >= 50:
    subtotal_1 = subtotal_1 * 0.9
total_1 = subtotal_1 * 1.13
print(f"Cliente Ana:   ${total_1:.2f}")

subtotal_2 = 8.00 * 5
if subtotal_2 >= 50:
    subtotal_2 = subtotal_2 * 0.9
total_2 = subtotal_2 * 1.13
print(f"Cliente Luis:  ${total_2:.2f}")

subtotal_3 = 6.25 * 8
if subtotal_3 > 50:
    subtotal_3 = subtotal_3 * 0.9
total_3 = subtotal_3 * 1.13
print(f"Cliente Marta: ${total_3:.2f}")

Cliente Ana:   $42.37
Cliente Luis:  $45.20
Cliente Marta: $56.50

• Error escondido: en la tercera copia dice > 50 en lugar de >= 50. Marta compró exactamente $50 y se quedó sin descuento: pagó $56.50 en vez de $50.85.
• Números mágicos: 0.9, 1.13, 50 repetidos. Si cambia el IVA, hay que encontrar y cambiar cada uno.
• No se puede probar el cálculo sin ejecutar todo el script y leer lo que imprime.
• Receta de refactorización: (1) identifica lo que se repite, (2) nombra cada paso con un verbo, (3) conviértelo en función con parámetros, (4) reemplaza las copias por llamadas, (5) comprueba que el resultado no cambió (salvo el error que corriges).

TASA_IVA = 0.13
TASA_DESCUENTO = 0.10
MINIMO_DESCUENTO = 50


def calcular_subtotal(precio_unitario, cantidad):
    """Devuelve el precio unitario multiplicado por la cantidad."""
    return precio_unitario * cantidad


def aplicar_descuento(subtotal):
    """Aplica el descuento por volumen si el subtotal llega al mínimo."""
    if subtotal >= MINIMO_DESCUENTO:
        return subtotal * (1 - TASA_DESCUENTO)
    return subtotal


def calcular_total(precio_unitario, cantidad):
    """Calcula el total a pagar con descuento por volumen e IVA.

    Args:
        precio_unitario: precio de una unidad, en dólares.
        cantidad: número de unidades (entero no negativo).

    Returns:
        Total a pagar, redondeado a 2 decimales.
    """
    subtotal = calcular_subtotal(precio_unitario, cantidad)
    base = aplicar_descuento(subtotal)
    return round(base * (1 + TASA_IVA), 2)


print(f"Cliente Ana:   ${calcular_total(12.50, 3):.2f}")
print(f"Cliente Luis:  ${calcular_total(8.00, 5):.2f}")
print(f"Cliente Marta: ${calcular_total(6.25, 8):.2f}")

Cliente Ana:   $42.37
Cliente Luis:  $45.20
Cliente Marta: $50.85

Marta ahora recibe su descuento: la regla vive en un solo lugar y no puede quedar distinta entre clientes. Añadir un cuarto cliente es una línea. Cada función hace una cosa y su nombre lo dice.

Ana y Luis pagan lo mismo que antes: una refactorización no debe cambiar resultados, salvo el error que corriges a propósito. Por eso se guarda la salida del script original y se compara.

Una cooperativa quiere calcular la cuota fija mensual de un préstamo (sistema francés). La mayoría de préstamos son a 12 meses, pero puede cambiar. También hay préstamos promocionales al 0 %.

• Fórmula: cuota = monto × i / (1 − (1 + i)^−n), con i = tasa anual / 12 y n = meses.
• meses tiene un valor típico → valor por defecto meses=12.
• Caso borde: con tasa 0 la fórmula divide 0 entre 0. Se trata aparte: cuota = monto / meses.

def calcular_cuota(monto, tasa_anual, meses=12):
    """Calcula la cuota mensual fija de un préstamo (sistema francés).

    Args:
        monto: capital prestado, en dólares.
        tasa_anual: tasa nominal anual como fracción (0.12 = 12 %).
        meses: plazo en meses; 12 por defecto.

    Returns:
        Cuota mensual redondeada a 2 decimales.
    """
    if tasa_anual == 0:
        return round(monto / meses, 2)
    i = tasa_anual / 12
    cuota = monto * i / (1 - (1 + i) ** -meses)
    return round(cuota, 2)


def desglosar_total(total_con_iva, tasa=0.13):
    """Separa un total con IVA en base imponible e IVA."""
    base = round(total_con_iva / (1 + tasa), 2)
    iva = round(total_con_iva - base, 2)
    return base, iva


print(calcular_cuota(5000, 0.12))                       # posicionales, meses por defecto
print(calcular_cuota(5000, 0.12, 24))                   # meses explícito
print(calcular_cuota(meses=36, monto=10000, tasa_anual=0.18))  # nombrados
print(calcular_cuota(5000, 0))                          # caso borde: tasa 0

base, iva = desglosar_total(113)
print(f"Base: {base}, IVA: {iva}")

444.24
235.37
361.52
416.67
Base: 100.0, IVA: 13.0

Alargar el plazo de 12 a 24 meses baja la cuota de $444.24 a $235.37, pero el total de intereses sube de $330.88 (444.24 × 12 − 5000) a $648.88. La función permite comparar escenarios con una línea cada uno: eso es valor para quien decide.

desglosar_total devuelve dos valores separados por coma, y la llamada los recibe en dos variables. (Técnicamente devuelve una tupla; la estudias la próxima semana.)

El valor de una inversión dentro de n años es el valor dentro de n − 1 años, multiplicado por (1 + tasa). Y dentro de 0 años es el capital. ¿Puede una función expresar eso literalmente?

Toda función recursiva tiene dos partes: el caso base (se responde sin llamarse otra vez: 0 años → el capital) y el caso recursivo (se llama con un problema más pequeño: anios - 1).

def valor_futuro(capital, tasa, anios):
    """Valor futuro con interés compuesto anual, calculado recursivamente."""
    if anios == 0:                                   # caso base
        return capital
    anterior = valor_futuro(capital, tasa, anios - 1)  # caso recursivo
    return round(anterior * (1 + tasa), 2)


print(valor_futuro(1000, 0.10, 3))

1331.0

La llamada con 3 años “espera” a la de 2, que espera a la de 1, que espera a la de 0. La de 0 responde 1000 y las respuestas regresan multiplicándose: 1100 → 1210 → 1331. Esa pila de llamadas en espera es lo que trazas en la traza 2.

Corregimos el error de > vs >=. ¿Cómo garantizamos que, si alguien lo vuelve a introducir dentro de tres semanas, lo sepamos en segundos?

Una prueba unitaria llama a una función con una entrada conocida y compara con el resultado esperado. Las mejores pruebas atacan los casos borde de la matriz: justo en la frontera, justo debajo, cero.

Paso 1: con assert (pruebas “artesanales”, sin instalar nada):

from facturacion import aplicar_descuento, calcular_total

assert aplicar_descuento(49.99) == 49.99, "debajo del mínimo no hay descuento"
assert calcular_total(10, 4) == 45.2
assert calcular_total(30, 2) == 61.02
print("Todas las pruebas pasaron")

Todas las pruebas pasaron

Instálalo una vez con python -m pip install pytest. Crea el archivo de pruebas junto a facturacion.py:

import pytest

from facturacion import aplicar_descuento, calcular_total


def test_sin_descuento_bajo_el_minimo():
    assert calcular_total(10, 4) == 45.2


def test_descuento_en_la_frontera_exacta():
    assert aplicar_descuento(50) == pytest.approx(45)


def test_justo_debajo_de_la_frontera():
    assert aplicar_descuento(49.99) == 49.99


def test_descuento_sobre_el_minimo():
    assert calcular_total(30, 2) == 61.02


def test_cantidad_cero():
    assert calcular_total(12.50, 0) == 0

Y en la terminal, desde esa carpeta: python -m pytest

collected 5 items

test_facturacion.py .....                                   [100%]

============================== 5 passed in 0.01s ==============================

Ahora sabotea a propósito: cambia >= por > en aplicar_descuento y vuelve a correr.

test_facturacion.py .F...                                   [100%]

___________________ test_descuento_en_la_frontera_exacta ___________________

    def test_descuento_en_la_frontera_exacta():
>       assert aplicar_descuento(50) == pytest.approx(45)
E       assert 50 == 45 ± 4.5e-05

FAILED test_facturacion.py::test_descuento_en_la_frontera_exacta
1 failed, 4 passed in 0.02s

Cada punto es una prueba que pasó; la F es la que falló, y pytest dice cuál, en qué línea, y qué valor obtuvo (50) frente al esperado (45). La prueba de la frontera exacta detectó el error en segundos. Las otras cuatro pasaron, lo cual demuestra por qué probar solo casos “normales” no basta.

pytest.approx compara flotantes con una tolerancia, porque 50 * 0.9 podría no ser exactamente 45 en binario.