Wie ein Computer denkt

Der Call Stack 🥞

Wie sich ein Computer merkt, was er gerade tut — und wie er den Weg zurückfindet.

Klick dich mit den Pfeiltasten durch →   ·   Es gibt was zum Ausprobieren.

Erst mal: was ist eine Funktion?

Eine Funktion ist ein kleiner Auftrag, den du dem Computer gibst — mit einem Namen.

def begrüße():
    print("Hallo!")

„begrüße()" heißt dann: Mach diesen Auftrag jetzt. Der Computer springt rein, erledigt ihn, und kommt dahin zurück, wo er losgesprungen ist.

🤔 Und genau das ist die spannende Frage: Woher weiß der Computer, wohin er zurückspringen muss?

Das Problem: Aufträge rufen Aufträge

Ein Auftrag ruft oft mitten drin einen anderen auf:

def pizza_machen():
    teig_machen()      # ← hier springt er weg …
    belegen()          # ← … und muss GENAU hierher zurück

Und teig_machen() ruft vielleicht wieder zutaten_mischen() … Es wird schnell verschachtelt.

Der Computer braucht ein Gedächtnis, das sich jede offene Stelle merkt. 🧠

Die Idee: ein Stapel Teller 🥞

Stell dir einen Stapel Teller vor:

  • Neuer Auftrag → neuer Teller oben drauf.
  • Auftrag fertig → obersten Teller runter.
  • Du kommst immer nur an den obersten ran.
Das nennt man LIFO: Last In, First Out — wer zuletzt draufkam, geht zuerst wieder runter. Wie beim echten Tellerstapel.
zutaten_mischen() zuletzt drauf
teig_machen()
pizza_machen() zuerst drauf

Probier's aus! 🎮

Ruf Aufträge auf und lass sie fertig werden — schau, wie der Stapel wächst und schrumpft.

Der Stapel ist leer. Ruf den ersten Auftrag auf! 🍕

Tipp: erst mehrmals „aufrufen", dann „fertig" — wie beim echten Programm.

Der Trick-Fall: die Funktion ruft sich selbst

Das heißt Rekursion. Beispiel — die Fibonacci-Zahlen (jede ist die Summe der zwei davor):

def fib(n):
    if n <= 1:
        return n        # ← die STOPP-Regel
    return fib(n-1) + fib(n-2)

Jeder Aufruf legt wieder einen Teller drauf — der Stapel wächst tief nach unten, bis die Stopp-Regel greift. Dann werden die Teller von oben abgeräumt und die Zahlen zusammengezählt.

fib(4) → fib(3)+fib(2) → … → unten stehen nur 0 und 1 → wieder hochzählen: 3

Warum die Stopp-Regel so wichtig ist

Der Auftrag muss bei jedem Selbst-Aufruf kleiner werden und irgendwann aufhören, sich selbst zu rufen:

if n <= 1:
    return n   # Hier hört das Rufen auf!
  • Mit Stopp: der Stapel wächst runter bis zum Boden, dann räumt er sich sauber wieder ab. ✅
  • Ohne Stopp: jeder Aufruf ruft den nächsten … und den nächsten … für immer. 😱

💥 Stack Overflow

Wenn der Turm aus Tellern zu hoch wird, fällt er um.

Der Stapel hat eine Höhengrenze (bei Python ungefähr 1000 Teller). Vergisst man die Stopp-Regel, stapelt der Computer immer weiter, bis:

RecursionError: maximum
recursion depth exceeded

Frei übersetzt: „Der Tellerturm ist zu hoch geworden — ich kann nicht mehr!"

Was du dir merken kannst 🎒

  • Der Call Stack ist das Gedächtnis des Computers dafür, was gerade offen ist.
  • Neuer Aufruf → Teller drauf. Fertig → Teller runter. (LIFO 🥞)
  • Der unterste Teller wird als Allerletztes fertig.
  • Ruft sich eine Funktion selbst → Rekursion. Sie braucht immer eine Stopp-Regel.
  • Keine Stopp-Regel → Turm zu hoch → 💥 Stack Overflow.

Fertig! Geh zurück zu Folie 5 und spiel nochmal mit dem Stapel — jetzt weißt du, was da passiert. 🦀