Summary  
This chapter covers recursion, detailing how to define a base case and a recursive case so a function calls itself with simpler inputs, and explains how the call stack manages these nested calls.  

General domain of usage  
Processing tree data structures

Een **recursieve functie** is een functie die zichzelf aanroept om een probleem op te lossen door het op te splitsen in kleinere, eenvoudigere delen.



Definitie

De belangrijkste elementen van recursie zijn:
- **Basisgeval**: de voorwaarde die de recursie stopt;
- **Recursief geval**: het deel waar de functie zichzelf aanroept met een eenvoudiger invoer.

## Waarom recursie gebruiken?

Sommige problemen kunnen op een natuurlijke manier worden uitgedrukt in termen van kleinere deelproblemen. Recursie biedt een overzichtelijke en elegante manier om deze op te lossen door een functie zichzelf te laten aanroepen voor de eenvoudigere gevallen. Het wordt vaak gebruikt bij taken zoals het verwerken van bomen, het verkennen van paden of het opdelen van structuren (zoals lijsten, 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

print_message("Hello, Recursion!", 3)

Stap voor stap uitleggen hoe dit werkt:

1. `times = 3` → voorwaarde is waar, bericht wordt afgedrukt, aanroep `print_message(message, 2)`;
2. `times = 2` → voorwaarde is waar, bericht wordt afgedrukt, aanroep `print_message(message, 1)`;
3. `times = 1` → voorwaarde is waar, bericht wordt afgedrukt, aanroep `print_message(message, 0)`;
4. `times = 0` → voorwaarde is onwaar, recursie stopt.

**Resultaat**: het bericht wordt drie keer afgedrukt.



## De aanroepstack

Elke keer dat de functie zichzelf aanroept, wordt er een nieuw frame toegevoegd aan de **aanroepstack** — een geheugenstructuur die actieve functieaanroepen bijhoudt. Zodra het basisgeval is bereikt, wordt elke vorige aanroep één voor één in omgekeerde volgorde afgerond.

Elke recursieve functie moet een basisgeval hebben. Zonder dit blijft de functie zichzelf oneindig aanroepen en veroorzaakt een `RecursionError`.

Opmerking

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 TestListSum(unittest.TestCase):

    def test_list_sum_basic(self):
        import user_code
        try:
            result = user_code.list_sum([1, 2, 3, 4, 5])
            expected = 15
            condition = result == expected
            failure_message = f"Expected `{expected}` for `[1, 2, 3, 4, 5]`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `list_sum` is not defined."
        _dynamic_test(self, condition, f"The `list_sum` returns `15` for `[1, 2, 3, 4, 5]`.", failure_message)

    def test_list_sum_another_list(self):
        import user_code
        try:
            result = user_code.list_sum([10, 20, 30])
            expected = 60
            condition = result == expected
            failure_message = f"Expected `{expected}` for `[10, 20, 30]`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `list_sum` is not defined."
        _dynamic_test(self, condition, f"The `list_sum` returns `60` for `[10, 20, 30]`.", failure_message)

    def test_list_sum_empty(self):
        import user_code
        try:
            result = user_code.list_sum([])
            expected = 0
            condition = result == expected
            failure_message = f"Expected `{expected}` for an empty list, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `list_sum` is not defined."
        _dynamic_test(self, condition, "The `list_sum` correctly returns `0` for an empty list.", failure_message)

    def test_recursion_used(self):
        import user_code
        import inspect
        try:
            source = inspect.getsource(user_code.list_sum)
            condition = "list_sum(" in source.split("def list_sum")[1]
            failure_message = "Expected `list_sum` to call itself recursively."
        except AttributeError:
            condition = False
            failure_message = "The function `list_sum` is not defined."
        _dynamic_test(self, condition, "The `list_sum` 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, werken met argumenten, 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 je functies maakt, argumenten definieert, returnwaarden afhandelt en ingebouwde functies effectief gebruikt.

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

Begrijpen hoe te werken met willekeurige en keyword-argumenten om variabele invoergroottes te verwerken. Leren hoe deze technieken uw functies dynamischer en georganiseerder maken.

Ontdek hoe returnwaarden de output van een functie vertegenwoordigen. Leer hoe je één of meerdere waarden retourneert, gebruikmaakt van None, en verken generators voor geavanceerdere controle over gegevensstromen.

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

Recursie

Waarom recursie gebruiken?

Een eenvoudig voorbeeld

De aanroepstack

Oplossing