Recall that a recursive function solves a problem by calling itself with a simpler input, until it reaches the base case that stops the recursion:





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

Notice how each recursive call works on a **smaller version** of the input — in this case, the list without its first element. The same approach applies when processing strings character by character.


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

Gain a solid understanding of how functions shape Python programming. Master defining and calling functions, working with arguments, and handling return values, including generator functions that yield values lazily. Explore recursion and lambda expressions to write flexible, efficient code.


Explore the essentials of Python functions, from defining and calling them with the def keyword to passing arguments and returning values. Learn to use built-in functions like print, len, and sum in your own code.


Discover how to work with positional and optional arguments in Python. Build functions with default parameter values and combine required and optional inputs to create flexible, readable code.

Discover how to handle variable-length input using *args and **kwargs in Python. Build functions that accept any number of positional or keyword arguments and process them dynamically.

Discover how to return single or multiple values from a function, use None to signal missing results, and build generator functions with yield for memory-efficient, on-demand data flows.

Discover how to solve problems using recursive functions and write concise lambda expressions for inline logic. Learn best practices for naming and structuring functions so your code stays maintainable.

Challenge: Formatting a Phone Number

Challenge: Formatting a Phone Number

Solution