Recursividad

La recursividad es una técnica en la programación que consiste en que una función se llama a sí misma para resolver un problema. Este enfoque es útil cuando un problema puede descomponerse en subproblemas de la misma naturaleza.

¿Qué es una función recursiva?

Una función recursiva es aquella que:

• Se llama a sí misma en algún punto de su ejecución.
• Tiene una condición de salida o caso base, que es lo que detiene la recursión.

Sin una condición de salida, la función se ejecutaría infinitamente, provocando un error de recursión (RecursionError).

Sintaxis básica:

def funcion_recursiva(parametro):
    if condicion_de_salida:
        return resultado
    else:
        return funcion_recursiva(nuevo_parametro)

Ejemplo: Cálculo del factorial

El factorial de un número n (denotado como n!) se define como:

n! = n × (n - 1) × (n - 2) × ... × 1

Solución iterativa:

def factorial_iterativo(n):
    resultado = 1	
    for i in range(1, n + 1):
        resultado *= i
    return resultado

print(factorial_iterativo(5))  # Resultado: 120

Solución recursiva:

def factorial_recursivo(n):
    if n == 1:
        return 1
    else:
        return n * factorial_recursivo(n - 1)

print(factorial_recursivo(5))  # Resultado: 120

¿Cómo funciona internamente?

Llamar a factorial_recursivo(5) genera estas llamadas:

factorial_recursivo(5)
=> 5 * factorial_recursivo(4)
=> 5 * 4 * factorial_recursivo(3)
=> 5 * 4 * 3 * factorial_recursivo(2)
=> 5 * 4 * 3 * 2 * factorial_recursivo(1)
=> 5 * 4 * 3 * 2 * 1 = 120

Cada llamada queda en pausa esperando el resultado de la siguiente. Esto se pila de llamadas (call stack).

Importante: RecursionError y profundidad

Python limita la cantidad de llamadas recursivas para evitar un desbordamiento de pila (stack overflow). Si excedes ese límite, verás un error como:

RecursionError: maximum recursion depth exceeded

Puedes ver o modificar este límite con el módulo sys:

import sys
print(sys.getrecursionlimit())  # Por defecto: 1000