Onthoud dat een recursieve functie een probleem oplost door zichzelf aan te roepen met een eenvoudigere invoer, totdat het de basisgeval bereikt dat de recursie stopt:





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

Let op hoe elke recursieve aanroep werkt op een **kleinere versie** van de invoer — in dit geval de lijst zonder het eerste element. Dezelfde aanpak geldt bij het verwerken van strings teken voor teken.


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

Verkrijg een grondig begrip van hoe functies de Python-programmering vormgeven. Beheers het definiëren en aanroepen van functies, het werken met argumenten, het omgaan met returnwaarden en het creëren van flexibele, efficiënte code met behulp van recursie en lambda-expressies.

Ontdek wat functies zijn en waarom ze essentieel zijn in Python. Leer hoe functies worden gemaakt, argumenten worden gedefinieerd, returnwaarden worden afgehandeld en ingebouwde functies effectief worden gebruikt.

Leer hoe positionele en optionele argumenten werken in Python. Ontwikkel aanpasbare functies die verschillende invoer verwerken en de flexibiliteit van uw code verbeteren.

Inzicht in het werken met willekeurige en sleutelwoordargumenten om variabele invoergroottes te verwerken. Begrijpen hoe deze technieken functies dynamischer en georganiseerder maken.

Ontdek hoe returnwaarden de output van een functie vertegenwoordigen. Leer hoe u één of meerdere waarden retourneert, gebruikmaakt van None en generatoren inzet voor geavanceerdere beheersing van gegevensstromen.

Ontgrendel geavanceerde functiethema's met recursie en lambda-functies. Begrijp hoe recursie herhalende problemen oplost en hoe lambda-expressies beknopte, eenregelige functies creëren.

Challenge: Het Opmaken van een Telefoonnummer

Oplossing