Proceso iterativo — Python: Funciones

• ¿Cómo funciona un proceso recursivo?
• Introducción al proceso iterativo
  • Implementación de factorial() con un proceso iterativo
  • Paso a paso: factorial(3) con iteración
• Resumen
• Claves del proceso iterativo

La recursión se puede utilizar de diferentes maneras. En el tema anterior, vimos el proceso recursivo, donde los cálculos se posponen hasta el final.

En este tema, veremos otro enfoque: el proceso iterativo recursivo.

¿Cómo funciona un proceso recursivo?

Un proceso recursivo aplaza los cálculos hasta alcanzar el caso base. Tomemos la función factorial como ejemplo:

def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n - 1)

Si ejecutamos factorial(3), el programa almacena cada operación en memoria hasta que se resuelve el caso base:

factorial(3)           
# No se resuelve, espera el resultado de factorial(2)
3 * factorial(2)       
# No se resuelve, espera el resultado de factorial(1)
3 * 2 * factorial(1)   
# No se resuelve, espera el resultado de factorial(0)
3 * 2 * 1              
# Ahora sí, comienza la multiplicación
3 * 2
6

🤔 Problema: Para calcular factorial(100), la memoria almacenará 100 llamadas a la función, lo que puede ser ineficiente.

Introducción al proceso iterativo

En lugar de aplazar los cálculos, podemos realizarlos en cada paso.

La clave del proceso iterativo es que el programa no acumula estados en memoria, sino que mantiene solo dos valores fijos en cada paso.

Implementación de factorial() con un proceso iterativo

def factorial(n):
    if n == 0:
        return 1

    def iter(counter, acc):
        if counter == 1:
            return acc
        return iter(counter - 1, counter * acc)

    return iter(n, 1)

Diferencias clave:

• Se eliminan los cálculos aplazados.

• iter() recibe un acumulador (acc) que almacena el resultado parcial.

• Cada llamada pasa solo dos valores (counter y acc), evitando crecimiento de memoria.

Paso a paso: factorial(3) con iteración

iter(3, 1)   # iter(3 - 1, 3 * 1)
iter(2, 3)   # iter(2 - 1, 2 * 3)
iter(1, 6)   # counter == 1, return 6
6

En cada paso:

• counter disminuye en 1.
• accumulator almacena la multiplicación acumulada.
• Cuando counter == 1, devuelve el resultado final.

✅ Ventaja: Solo dos valores se almacenan en memoria en cualquier momento.

Resumen

El proceso iterativo es más eficiente porque no almacena múltiples llamadas en memoria.

Claves del proceso iterativo

1️⃣ Definir el estado inicial

Se inicia con iter(n, 1), donde n es el número a procesar y 1 es el valor inicial del acumulador.

2️⃣ Verificar el caso base

Si counter == 1, se retorna el valor acumulado (acc).

3️⃣ Actualizar el estado en cada paso

• Se reduce counter en 1.
• Se multiplica acc por el nuevo valor de counter.

4️⃣ Repetir hasta alcanzar el caso base

Este enfoque mantiene un consumo de memoria constante y mejora el rendimiento, especialmente con valores grandes de n.