Hieronder is een klassiek voorbeeld: een recursieve implementatie van de faculteitsfunctie, die het product retourneert van alle positieve integers tot x.

Voorbeeld van een Recursieve Functie

def factorial(x):
    """Recursief de faculteit berekenen van een positief integer."""
    if x == 1:
        return 1
    return x * factorial(x - 1)
num = 3
print("De faculteit van", num, "is", factorial(num))

Output

De faculteit van 3 is 6

Hier is factorial() een recursieve functie omdat het zichzelf aanroept tot de base case x == 1 bereikt is.

Wanneer aangeroepen met een positief integer, roept de functie zichzelf herhaaldelijk aan met een gedecrementeerde waarde:

factorial(3) # 1e aanroep met 3
3 * factorial(2) # 2e aanroep met 2
3 * 2 * factorial(1) # 3e aanroep met 1
3 * 2 * 1 # return van 3e aanroep
3 * 2 # return van 2e aanroep
6 # return van 1e aanroep

Hieronder is een visuele representatie van dit stap-voor-stap proces:

De recursie terminaalt wanneer de invoerwaarde de basisvoorwaarde bereikt (in dit geval x == 1). Elke recursieve functie moet zo'n stopcriterium bevatten; anders zou het oneindig doorgaan en uiteindelijk de call stack opvullen.

Python dwingt een maximale recursiediepte (standaard 1000) af om oneindige recursie de interpreter te laten crashen. Het overschrijden van deze limiet geeft een RecursionError:

def recursor():
    recursor()
recursor()

Output

Traceback (most recent call last):
File "<string>", line 3, in <module>
File "<string>", line 2, in a
File "<string>", line 2, in a
File "<string>", line 2, in a
[Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded

Je kunt de recursielimiet programmatisch aanpassen met sys.setrecursionlimit(), maar doe dit met voorzichtigheid om stack overflow te voorkomen.

Voordelen van Recursie

1. Recursieve oplossingen zijn vaak beknopter en leesbaarder, vooral voor problemen die van nature recursief uitgedrukt worden.
2. Ze laten elegante decompositie van complexe taken in eenvoudigere sub-problemen toe.
3. Sequentiegeneratie (bijv. Fibonacci, permutaties) is met recursie eenvoudiger dan met geneste loops.

Nadelen van Recursie

1. Recursieve logica kan lastiger te volgen en te redeneren zijn voor beginners.
2. Elke recursieve aanroep verbruikt stack-ruimte; diepe recursies kunnen geheugen-intensief en langzamer zijn dan iteratieve alternatieven.
3. Debuggen van recursie kan uitdagend zijn door de gelaagde call stack.

In de praktijk kies je voor recursie als het leidt tot duidelijkere, beter onderhoudbare code en de invoergrootte matig is. Voor zeer grote invoeren kunnen iteratieve benaderingen of tail-recursie-optimalisaties (wanneer ondersteund) preferabel zijn.