Recuerda que una función recursiva resuelve un problema llamándose a sí misma con una entrada más simple, hasta que alcanza el caso base que detiene la recursión:





def list_sum(numbers):
    if not numbers:                            # Base case
        return 0
    return numbers[0] + list_sum(numbers[1:]) # Recursive case

Observa cómo cada llamada recursiva trabaja sobre una **versión más pequeña** de la entrada — en este caso, la lista sin su primer elemento. El mismo enfoque se aplica al procesar cadenas de texto carácter por carácter.


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_parentheses_and_spaces(self):
        import user_code
        try:
            result = user_code.format_phone_number("(123) 456-7890")
            expected = "1234567890"
            condition = result == expected
            failure_message = f"Expected `{expected}` for `'(123) 456-7890'`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `format_phone_number` is not defined."
        _dynamic_test(self, condition, f"The `format_phone_number` correctly handles parentheses and spaces.", failure_message)

    def test_dashes_and_plus(self):
        import user_code
        try:
            result = user_code.format_phone_number("  +1-800-555-0199  ")
            expected = "18005550199"
            condition = result == expected
            failure_message = f"Expected `{expected}` for `'  +1-800-555-0199  '`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `format_phone_number` is not defined."
        _dynamic_test(self, condition, "The `format_phone_number` correctly handles dashes and plus signs.", failure_message)

    def test_dots(self):
        import user_code
        try:
            result = user_code.format_phone_number("987.654.3210")
            expected = "9876543210"
            condition = result == expected
            failure_message = f"Expected `{expected}` for `'987.654.3210'`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `format_phone_number` is not defined."
        _dynamic_test(self, condition, "The `format_phone_number` correctly handles dots.", failure_message)

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

    def test_recursion_used(self):
        import user_code
        import inspect
        try:
            source = inspect.getsource(user_code.format_phone_number)
            condition = "format_phone_number(" in source.split("def format_phone_number")[1]
            failure_message = "Expected `format_phone_number` to call itself recursively."
        except AttributeError:
            condition = False
            failure_message = "The function `format_phone_number` is not defined."
        _dynamic_test(self, condition, "The `format_phone_number` 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 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 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.

Desafío: Formatear un Número de Teléfono

Solución