Summary
Recursion is a technique where a function defines a base case to stop and a recursive case that calls itself with simpler input to solve problems.

General domain of usage
processing trees

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 (bijvoorbeeld 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 uitleg om te begrijpen hoe dit werkt:

1. `times = 3` → voorwaarde is waar, bericht wordt afgedrukt, roept `print_message(message, 2)` aan;
2. `times = 2` → voorwaarde is waar, bericht wordt afgedrukt, roept `print_message(message, 1)` aan;
3. `times = 1` → voorwaarde is waar, bericht wordt afgedrukt, roept `print_message(message, 0)` aan;
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 zal de functie zichzelf oneindig blijven aanroepen en een `RecursionError` veroorzaken.

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

Krijg een grondig begrip van hoe functies de Python-programmering vormgeven. Beheers het definiëren en aanroepen van functies, het werken met argumenten, het afhandelen van 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 aangemaakt, argumenten worden gedefinieerd, returnwaarden worden afgehandeld en ingebouwde functies effectief worden gebruikt.

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

Inzicht in het werken met willekeurige en keyword-argumenten om variabele invoergroottes te verwerken.
Begrip van 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, None gebruikt en generatoren toepast voor geavanceerdere gegevensstroomcontrole.

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