Summary  
This chapter covers recursion, detailing how to define a base case and a recursive case so a function calls itself with simpler inputs, and explains how the call stack manages these nested calls.  

General domain of usage  
Processing tree data structures

Una **función recursiva** es una función que se llama a sí misma para resolver un problema dividiéndolo en partes más pequeñas y simples.



Definición

Los elementos clave de la recursión son:
- **Caso base**: la condición que detiene la recursión;
- **Caso recursivo**: la parte donde la función se llama a sí misma con una entrada más simple.

## ¿Por qué usar recursión?

Algunos problemas pueden expresarse de forma natural en términos de subproblemas más pequeños. La recursión ofrece una manera clara y elegante de resolverlos haciendo que una función se llame a sí misma para manejar los casos más simples. Es comúnmente utilizada en tareas como el procesamiento de árboles, la exploración de rutas o la descomposición de estructuras (por ejemplo, listas, cadenas).



def print_message(message, times):
    if times > 0:                              # Base case: stop when times is 0
        print(message)
        print_message(message, times - 1)     # Recursive case

print_message("Hello, Recursion!", 3)

Analizar paso a paso para comprender cómo funciona:

1. `times = 3` → la condición es verdadera, imprime el mensaje, llama a `print_message(message, 2)`;
2. `times = 2` → la condición es verdadera, imprime el mensaje, llama a `print_message(message, 1)`;
3. `times = 1` → la condición es verdadera, imprime el mensaje, llama a `print_message(message, 0)`;
4. `times = 0` → la condición es falsa, la recursión se detiene.

**Resultado**: el mensaje se imprime tres veces.



## La pila de llamadas

Cada vez que la función se llama a sí misma, agrega un nuevo marco a la **pila de llamadas** — una estructura de memoria que realiza un seguimiento de las llamadas activas a funciones. Una vez que se alcanza el caso base, cada llamada previa se completa una por una en orden inverso.

Toda función recursiva debe tener un caso base. Sin él, la función se llamará a sí misma indefinidamente y provocará un `RecursionError`.

Nota

import unittest

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

class TestListSum(unittest.TestCase):

    def test_list_sum_basic(self):
        import user_code
        try:
            result = user_code.list_sum([1, 2, 3, 4, 5])
            expected = 15
            condition = result == expected
            failure_message = f"Expected `{expected}` for `[1, 2, 3, 4, 5]`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `list_sum` is not defined."
        _dynamic_test(self, condition, f"The `list_sum` returns `15` for `[1, 2, 3, 4, 5]`.", failure_message)

    def test_list_sum_another_list(self):
        import user_code
        try:
            result = user_code.list_sum([10, 20, 30])
            expected = 60
            condition = result == expected
            failure_message = f"Expected `{expected}` for `[10, 20, 30]`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `list_sum` is not defined."
        _dynamic_test(self, condition, f"The `list_sum` returns `60` for `[10, 20, 30]`.", failure_message)

    def test_list_sum_empty(self):
        import user_code
        try:
            result = user_code.list_sum([])
            expected = 0
            condition = result == expected
            failure_message = f"Expected `{expected}` for an empty list, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `list_sum` is not defined."
        _dynamic_test(self, condition, "The `list_sum` correctly returns `0` for an empty list.", failure_message)

    def test_recursion_used(self):
        import user_code
        import inspect
        try:
            source = inspect.getsource(user_code.list_sum)
            condition = "list_sum(" in source.split("def list_sum")[1]
            failure_message = "Expected `list_sum` to call itself recursively."
        except AttributeError:
            condition = False
            failure_message = "The function `list_sum` is not defined."
        _dynamic_test(self, condition, "The `list_sum` function uses recursion.", failure_message)

if __name__ == '__main__':
    unittest.main()

test_main.py

Adquirir una comprensión sólida de cómo las funciones estructuran la programación en Python. Dominar la definición y llamada de funciones, el trabajo con argumentos, la gestión de valores de retorno y la creación de código flexible y eficiente utilizando recursión y expresiones lambda.

Explora qué son las funciones y por qué son esenciales en Python. Aprende cómo crear funciones, definir argumentos, manejar valores de retorno y utilizar funciones integradas de manera efectiva.

Aprende cómo funcionan los argumentos posicionales y opcionales en Python. Crea funciones adaptables que gestionen diferentes entradas y mejoren la flexibilidad en tu código.

Comprender cómo trabajar con argumentos arbitrarios y argumentos de palabras clave para manejar tamaños de entrada variables. Aprender cómo estas técnicas hacen que tus funciones sean más dinámicas y organizadas.

Descubre cómo los valores de retorno representan la salida de una función. Aprende a retornar valores únicos o múltiples, utilizar None y explorar generadores para un control de flujo de datos más avanzado.

Descubre conceptos avanzados de funciones con recursión y funciones lambda. Aprende cómo la recursión resuelve problemas repetitivos y cómo las expresiones lambda crean funciones concisas de una sola línea.

Recursión

¿Por qué usar recursión?

Un ejemplo sencillo

La pila de llamadas

Solución