Summary
Recursion is a programming technique where a function implements code by calling itself with simpler inputs until a base case stops further calls, enabling complex problems to be broken down into smaller subproblems.

General domain of usage
processing tree structures

**Recursión** es una técnica de programación **donde una función se llama a sí misma** para resolver un problema en partes más pequeñas. Es especialmente útil para problemas con estructura repetitiva o subproblemas naturales.

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 proporciona 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

# Function call
print_message("Hello, Recursion!", 3)

Analizar **paso a paso** para comprender cómo funciona este programa recursivo:

1. **Verificación de condición:** si `times > 0`, la función continúa. En este caso, `times = 3`, por lo que la condición es verdadera;
2. **Impresión del mensaje:** la función imprime `"Hello, Recursion!"`;
3. **Llamada recursiva:** la función se llama a sí misma con `times - 1`;
4. **Repetición:** este proceso continúa hasta que `times` es igual a 0;
5. **Finalización:** cuando la condición `times > 0` ya no es verdadera, la recursión se detiene y el programa finaliza.

**Resultado**: El mensaje `"Hello, Recursion!"` se imprime __tres veces__.

### Comprensión del flujo:
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 rastrea las llamadas activas de funciones). La función sigue llamándose a sí misma con un valor de `times` menor. Una vez que alcanza el caso base (`times == 0`), se detiene. Luego, cada llamada previa se completa una por una en orden inverso. Este comportamiento de retroceso es esencial para el funcionamiento de la recursión.

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 TestFormatPhoneNumber(unittest.TestCase):
    def test_standard_format(self):
        """Checks that the function correctly formats a standard phone number."""
        try:
            import user_code
            result = user_code.format_phone_number("(123) 456-7890")
            expected_output = "1234567890"
            condition = result == expected_output
            failure_message = f"For input `(123) 456-7890`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `format_phone_number` is not defined."

        _dynamic_test(self, condition, "The function correctly formats a standard phone number.", failure_message)

    def test_number_with_country_code(self):
        """Checks that the function correctly handles a phone number with a country code."""
        try:
            import user_code
            result = user_code.format_phone_number("  +1-800-555-0199  ")
            expected_output = "18005550199"
            condition = result == expected_output
            failure_message = f"For input `  +1-800-555-0199  `, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `format_phone_number` is not defined."

        _dynamic_test(self, condition, "The function correctly handles a phone number with a country code.", failure_message)

    def test_number_with_dots(self):
        """Checks that the function correctly handles a phone number with dots."""
        try:
            import user_code
            result = user_code.format_phone_number("987.654.3210")
            expected_output = "9876543210"
            condition = result == expected_output
            failure_message = f"For input `987.654.3210`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `format_phone_number` is not defined."

        _dynamic_test(self, condition, "The function correctly handles a phone number with dots.", failure_message)

    def test_empty_string(self):
        """Checks that the function returns an empty string for an empty input."""
        try:
            import user_code
            result = user_code.format_phone_number("")
            expected_output = ""
            condition = result == expected_output
            failure_message = f"For input `''`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `format_phone_number` is not defined."

        _dynamic_test(self, condition, "The function correctly handles an empty string.", failure_message)

    def test_only_special_characters(self):
        """Checks that the function returns an empty string when input contains only special characters."""
        try:
            import user_code
            result = user_code.format_phone_number("!@#$%^&*()")
            expected_output = ""
            condition = result == expected_output
            failure_message = f"For input `'!@#$%^&*()'`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `format_phone_number` is not defined."

        _dynamic_test(self, condition, "The function correctly handles input with only special characters.", failure_message)

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

test_main.py

Adquiera una comprensión sólida de cómo las funciones estructuran la programación en Python. Domine la definición y llamada de funciones, el manejo de argumentos, la gestión de valores de retorno y la creación de código flexible y eficiente mediante recursión y expresiones lambda.

Explora qué son las funciones y por qué son esenciales en Python. Aprende a 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 de palabras clave para manejar tamaños de entrada variables. Aprender cómo estas técnicas hacen que las funciones sean más dinámicas y organizadas.

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

Descubra conceptos avanzados de funciones con recursión y funciones lambda. Aprenda 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?

Comprensión del flujo:

Solución