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

**Recursion** is a programming technique **where a function calls itself** to solve a problem in smaller parts. It's especially useful for problems with repetitive structure or natural sub-problems.

Definition

The key elements of **recursion** are:
- **Base case**: the condition that stops the recursion;
- **Recursive case**: the part where the function calls itself with a simpler input.

### Why use recursion?

Some problems can be naturally expressed in terms of smaller subproblems. Recursion provides a clean and elegant way to solve these by having a function call itself to handle the simpler cases. It is commonly used in tasks like processing trees, exploring paths, or breaking down structures (e.g., lists, strings).

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)

Go **step by step** to understand how this recursive program works:

1. **Condition Check:** if `times > 0`, the function proceeds. In this case, `times = 3`, so the condition is true;
2. **Print Message:** the function prints `"Hello, Recursion!"`;
3. **Recursive Call:** the function calls itself with `times - 1`;
4. **Repetition:** this process continues until `times` equals 0;
5. **Termination:** when the condition `times > 0` is no longer true, the recursion stops, and the program completes.

**Result**: The message `"Hello, Recursion!"` is printed __three times__.

### Understanding the flow:
Each time the function calls itself, it adds a new frame to the **call stack** (a memory structure that keeps track of active function calls). The function keeps calling itself with a smaller `times` value. Once it reaches the base case (`times == 0`), it stops. Then, each previous call completes one by one in reverse order. This backtracking behavior is essential to how recursion works.

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

Gain a solid understanding of how functions shape Python programming. Master defining and calling functions, working with arguments, handling return values, and creating flexible, efficient code using recursion and lambda expressions.

Explore what functions are and why they're essential in Python. Learn how to create functions, define arguments, handle return values, and use built-in functions effectively.

Learn how positional and optional arguments work in Python. Build adaptable functions that handle different inputs and improve flexibility in your code.

Understand how to work with arbitrary and keyword arguments to handle variable input sizes. Learn how these techniques make your functions more dynamic and organized.

Discover how return values represent a function's output. Learn to return single or multiple values, use None, and explore generators for more advanced data flow control.

Unlock advanced function concepts with recursion and lambda functions. Learn how recursion solves repetitive problems and how lambda expressions create concise, one-line functions.

Recursion

Why use recursion?

Understanding the flow:

Solution