Summary
This chapter explains function recursion, showing how a function can call itself with a base case and a recursive case to break a problem into simpler subproblems and manage execution via the call stack.

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.

Function Recursion in Python

Why use recursion?

Understanding the flow:

解答