Recursión: casos base y pila en Python

La recursión en Python aparece cuando una función se llama a sí misma para resolver una versión más pequeña del mismo problema. Es útil en árboles, directorios, estructuras anidadas y algoritmos definidos naturalmente por subproblemas, pero exige una condición de parada clara.

En esta guía aprenderás el caso base, la llamada recursiva, el comportamiento de la pila, ejemplos con factorial y estructuras anidadas, memoización, límites y situaciones donde un bucle resulta más sencillo. Conviene dominar primero las funciones en Python.

Las dos partes esenciales

• Caso base: devuelve un resultado sin volver a llamar a la función.
• Paso recursivo: reduce el problema y realiza una nueva llamada.

def cuenta_atras(numero):
    if numero <= 0:
        print("Fin")
        return

    print(numero)
    cuenta_atras(numero - 1)


cuenta_atras(5)

Sin el caso base, las llamadas continuarían hasta superar el límite de recursión.

Factorial recursivo

def factorial(numero):
    if numero < 0:
        raise ValueError("El número debe ser no negativo")

    if numero in {0, 1}:
        return 1

    return numero * factorial(numero - 1)

Para factorial(4), las llamadas esperan hasta alcanzar el caso base y después se resuelven en sentido inverso.

factorial(4)
4 * factorial(3)
4 * 3 * factorial(2)
4 * 3 * 2 * factorial(1)
4 * 3 * 2 * 1

La pila de llamadas

Cada llamada conserva sus argumentos, variables locales y punto de retorno. La recursión profunda consume memoria porque mantiene muchos marcos activos. La documentación oficial de sys.getrecursionlimit() explica el límite utilizado para proteger la pila del intérprete.

Versión iterativa del factorial

def factorial_iterativo(numero):
    if numero < 0:
        raise ValueError("El número debe ser no negativo")

    resultado = 1
    for valor in range(2, numero + 1):
        resultado *= valor

    return resultado

Para operaciones lineales simples, un bucle suele ser más fácil de leer y evita llamadas adicionales. La guía de bucles en Python explica for, while, break y continue.

Sumar una lista de forma recursiva

def sumar(valores):
    if not valores:
        return 0

    return valores[0] + sumar(valores[1:])

El ejemplo es didáctico, pero crea un nuevo slice en cada llamada. Para una lista grande, sum(valores) o un bucle son más eficientes.

Procesar estructuras anidadas

La recursión destaca cuando los datos pueden contener niveles del mismo tipo.

def contar_numeros(elemento):
    if isinstance(elemento, (int, float)):
        return 1

    if isinstance(elemento, list):
        return sum(
            contar_numeros(valor)
            for valor in elemento
        )

    return 0


datos = [1, [2, 3], [4, [5, 6]], "texto"]
print(contar_numeros(datos))

Recorrer un árbol

arbol = {
    "nombre": "raiz",
    "hijos": [
        {"nombre": "A", "hijos": []},
        {
            "nombre": "B",
            "hijos": [
                {"nombre": "B1", "hijos": []},
            ],
        },
    ],
}


def mostrar_nodos(nodo, nivel=0):
    print("  " * nivel + nodo["nombre"])

    for hijo in nodo.get("hijos", []):
        mostrar_nodos(hijo, nivel + 1)


mostrar_nodos(arbol)

Diccionarios y listas representan cada nodo y sus hijos. La guía de diccionarios en Python ayuda a trabajar con estas estructuras.

Recorrer directorios

from pathlib import Path


def listar_archivos(ruta):
    ruta = Path(ruta)

    for elemento in ruta.iterdir():
        if elemento.is_dir():
            yield from listar_archivos(elemento)
        else:
            yield elemento

En aplicaciones reales, considera enlaces simbólicos, permisos y posibles ciclos. La guía de pathlib en Python explica operaciones seguras con rutas.

Fibonacci y el problema de repetir trabajo

def fibonacci(numero):
    if numero < 2:
        return numero

    return fibonacci(numero - 1) + fibonacci(numero - 2)

Esta versión recalcula los mismos valores muchas veces. La memoización guarda resultados ya obtenidos.

from functools import lru_cache

@lru_cache(maxsize=None)
def fibonacci(numero):
    if numero < 2:
        return numero

    return fibonacci(numero - 1) + fibonacci(numero - 2)

La referencia oficial de functools.lru_cache() describe el almacenamiento de resultados. La guía para acelerar Python con lru_cache muestra casos prácticos.

RecursionError

Un caso base ausente, una reducción incorrecta o una entrada demasiado profunda pueden producir RecursionError.

def repetir(numero):
    return repetir(numero + 1)

No aumentes el límite como primera solución. Revisa la lógica y considera una versión iterativa. La guía para corregir RecursionError reúne las causas comunes.

Probar funciones recursivas

def test_factorial():
    assert factorial(0) == 1
    assert factorial(1) == 1
    assert factorial(5) == 120

Incluye casos base, valores normales, entradas inválidas y estructuras vacías. Para excepciones específicas, revisa try y except en Python.

Cuándo usar recursión

• Árboles y estructuras jerárquicas.
• Directorios y datos anidados.
• Algoritmos de divide y vencerás.
• Problemas cuya definición ya es recursiva.

Cuándo preferir un bucle

• Contadores y recorridos lineales.
• Entradas potencialmente muy profundas.
• Procesos donde una pila explícita es más controlable.
• Casos donde la versión iterativa es claramente más legible.

Conclusión

La recursión en Python funciona cuando cada llamada reduce el problema y existe un caso base alcanzable. Es especialmente expresiva para árboles y estructuras anidadas, pero no debe utilizarse automáticamente. Compara la claridad, el consumo de memoria y la profundidad posible antes de elegir entre una solución recursiva y una iterativa.