Funktionen
Die Strukturierungseinheit, ohne die Programmierung sehr schnell unangenehm wird.
Viele Python-Befehle, die du bisher benutzt hast — print(), input(), range(), len() — sind Funktionen, die jemand anderes geschrieben hat. Funktionen sind der grundlegende Baustein jedes Programms: Sie nehmen Eingaben entgegen, erledigen Arbeit und liefern ein Ergebnis zurück.
In diesem Artikel lernst du, eigene Funktionen zu bauen, verstehst, warum sie Code kürzer und sicherer machen, und entdeckst Scope — die unsichtbaren Regeln, die verhindern, dass Variablen aus Funktionen austreten und Chaos verursachen.
Was ist eine Funktion?
Du verwendest bereits seit deiner ersten Python-Zeile Funktionen. Hier sind acht, die du schon kennst:
Definition
Funktion
Analogie
Definition
Die Saftpressen-Analogie passt gut für Input/Output und Abstraktion. Aber eine Saftpresse kann nur pressen — eine Funktion kann beliebige Logik enthalten, inklusive Verzweigungen, Schleifen und Aufrufe anderer Funktionen. Manche Funktionen nehmen keine Eingabe entgegen, und manche liefern kein sinnvolles Ergebnis zurück.
Merke
So läuft ein Funktionsaufruf ab
- 1. Python sieht den Aufruf greet("Ada") — greet ist definiert als def greet(name): return f"Hello, {name}!"
- 2. Das Argument "Ada" wird an den Parameter name gebunden
- 3. Der Funktionskörper wird ausgeführt: f"Hello, {name}!"
- 4. return sendet den Wert "Hello, Ada!" zurück
- 5. Der Aufrufer erhält den String und kann ihn weiterverwenden
Zeigt Text auf dem Bildschirm an, gibt aber None zurück. Das Ergebnis kann nicht in einer Variable gespeichert oder weiterverwendet werden. Geeignet zum Anzeigen, nicht zum Rechnen.
Sendet einen Wert an den Aufrufer zurück. Das Ergebnis kann in einer Variable gespeichert, weiterverarbeitet oder an eine andere Funktion übergeben werden. So gibt man Daten aus einer Funktion heraus.
Achtung
Häufiger Fehler: print() statt return
Anfänger verwechseln print() und return häufig. Eine Funktion, die nur print() benutzt, zeigt zwar etwas an — aber der Aufrufer erhält None statt eines brauchbaren Werts.
def verdopple(x):
print(x * 2) # Zeigt 10 an...
ergebnis = verdopple(5)
print(ergebnis) # ...aber ergebnis ist None!Richtig wäre: return x * 2 — dann enthält ergebnis den Wert 10 und kann weiterverwendet werden.
Warum Funktionen? DRY und Modularisierung
Definition
DRY-Prinzip
Analogie
Definition
Die Wegbeschreibungs-Analogie passt gut: Wiederholte Teilrouten werden ausgelagert, der Name dient als Referenz, und eine Änderung wirkt sich überall aus. Im echten Leben kann man auf implizites Wissen setzen ("du kennst den Weg") — im Code muss jede Anweisung explizit sein.
Beispiel: Bruttopreis-Berechnung
Ohne Funktion — dieselbe Formel dreimal kopiert:
preis1 = 100 * 1.19 # 119.0
preis2 = 250 * 1.19 # 297.5
preis3 = 49.90 * 1.19 # ≈ 59.381 (Python zeigt 59.38099999999999)Mit Funktion — die Formel existiert nur einmal:
def brutto(netto):
return netto * 1.19
preis1 = brutto(100) # 119.0
preis2 = brutto(250) # 297.5
preis3 = brutto(49.90) # ≈ 59.381 (Python zeigt 59.38099999999999)Ändert sich der Steuersatz von 19% auf 16%, aktualisierst du eine einzige Zeile statt das gesamte Programm zu durchsuchen.
Modularisierung bedeutet, ein großes Problem in kleine, benannte Funktionen aufzuteilen. Jede Funktion hat eine klare Aufgabe: daten_laden(), validieren(), verarbeiten(), anzeigen(). Die Funktionsnamen wirken wie eine Gliederung — man kann den Programmablauf lesen, ohne jeden einzelnen Schritt zu verstehen.
Achtung
Irrtum: Funktionen braucht man erst bei großen Programmen
Schon ein 20-Zeilen-Skript profitiert von Struktur. Wenn du dieselbe Logik zweimal schreibst, ist das ein Zeichen: Extrahiere sie in eine Funktion. Und Copy-Paste mit kleinen Anpassungen ist keine Lösung — parametrisiere die Unterschiede stattdessen.
Scope — Wo Variablen leben und sterben
Definition
Scope (Gültigkeitsbereich)
Analogie
Definition
Die Hotel-Analogie passt gut: öffentlicher Raum (global) vs. privater Raum (lokal), und beim Auschecken verschwindet der Inhalt. Aber im Hotel kann man Gegenstände aus dem Zimmer in die Lobby tragen — in Python ist der saubere Weg, Werte per return zurückzugeben und außerhalb zuzuweisen.
Beispiel: Gleicher Name, verschiedener Scope
nachricht = "Ich bin global"
def zeige_nachricht():
nachricht = "Ich bin lokal"
print(nachricht) # "Ich bin lokal"
zeige_nachricht()
print(nachricht) # "Ich bin global"Innerhalb der Funktion existiert eine eigene Variable nachricht, die die globale "überschattet". Die globale Variable bleibt unverändert — genau das ist gewollt. Scope hält Funktionen voneinander unabhängig.
Merke
Fehler: Zugriff außerhalb des Scope
def berechne():
x = 42
berechne()
print(x) # NameError: name 'x' is not definedDie Variable x existiert nur innerhalb der Funktion berechne(). Nach dem Aufruf ist sie verschwunden — wie ein Hotelzimmer nach dem Auschecken.
Achtung
Warnung: Globale Variablen in Funktionen ändern
Mit dem Schlüsselwort global kann eine Funktion globale Variablen direkt verändern. Das funktioniert — ist aber fast immer eine schlechte Idee, weil es Funktionen von ihrer Umgebung abhängig macht und Fehler schwer auffindbar werden.
zaehler = 0
def erhoehe():
global zaehler
zaehler += 1
erhoehe()
print(zaehler) # 1Bevorzuge return statt global. Die saubere Variante: den neuen Wert zurückgeben und außerhalb zuweisen.
Interaktiv: Funktionsaufruf Schritt für Schritt
Du hast gelernt, dass lokale Variablen nur innerhalb ihrer Funktion existieren. Aber WO genau leben sie? Klicke dich durch die Schritte eines Funktionsaufrufs und beobachte den Call Stack — die interne Datenstruktur, in der Python für jeden Aufruf einen eigenen Rahmen (Frame) anlegt. Achte darauf, wie Variablen im Frame erscheinen und beim Return wieder verschwinden.
def greet(name): msg = f"Hello, {name}!" return msgresult = greet("Ada")print(result)Python trifft auf die Zeile result = greet("Ada"). Es erkennt einen Funktionsaufruf und bereitet sich darauf vor, die Funktion greet auszuführen.
Parameter können Standardwerte haben. Wird beim Aufruf kein Argument übergeben, greift der Standard:
def begruessung(name="Welt"):
return f"Hallo, {name}!"
print(begruessung()) # "Hallo, Welt!"
print(begruessung("Ada")) # "Hallo, Ada!"Mit Keyword-Argumenten kannst du Parameter beim Namen ansprechen: begruessung(name="Ada"). Bei mehreren Parametern macht das den Code lesbarer, weil die Reihenfolge egal wird.
Vorsicht: Verwende niemals eine leere Liste als Standardwert (def f(items=[])). Python erstellt den Standardwert nur einmal — die Liste sammelt Einträge über mehrere Aufrufe hinweg an. Verwende stattdessen items=None und erstelle die Liste im Funktionskörper.
Die wahre Stärke von Funktionen zeigt sich, wenn der Rückgabewert einer Funktion als Eingabe für die nächste dient — eine Pipeline aus kleinen, spezialisierten Bausteinen:
def laden(datei):
with open(datei, encoding="utf-8") as f:
return f.read()
def bereinigen(text):
return text.strip().lower()
def zaehlen(text):
return len(text.split())
# Pipeline: laden -> bereinigen -> zaehlen
inhalt = laden("daten.txt")
sauber = bereinigen(inhalt)
anzahl = zaehlen(sauber)
print(f"{anzahl} Wörter")In späteren Artikeln wirst du dieses Muster in der Datenverarbeitung und in Machine-Learning-Workflows wiederfinden.
Merke
Das Wichtigste auf einen Blick
- Eine Funktion wird mit def definiert, nimmt Parameter als Eingabe und nutzt return, um ein Ergebnis zurückzugeben. Ohne return gibt die Funktion None zurück.
- print() zeigt Text auf dem Bildschirm an, gibt aber None zurück. return übergibt einen Wert an den Aufrufer zur Weiterverwendung. Die beiden sind nicht austauschbar.
- Das DRY-Prinzip: Logik einmal schreiben, überall aufrufen. Bei Änderungen wird nur eine Stelle aktualisiert.
- Modularisierung bedeutet, ein großes Problem in kleine, benannte Funktionen aufzuteilen. Jede Funktion hat eine klare Aufgabe.
- Variablen innerhalb einer Funktion sind lokal — sie existieren nur während der Ausführung und sind außerhalb unsichtbar. Diese Isolation macht Funktionen wiederverwendbar und schützt vor ungewollten Seiteneffekten.
Prüfen
Quiz: Funktionen
Was gibt eine Funktion zurück, wenn sie kein return-Statement enthält?
Wähle eine Antwort
1. Was gibt eine Funktion zurück, wenn sie kein return-Statement enthält?
2. Was ist der Wert von ergebnis nach diesem Code? def verdopple(x): print(x * 2) ergebnis = verdopple(5)
3. Was gibt print(x) am Ende aus? x = "global" def test(): x = "lokal" test() print(x)
4. Du hast dieselbe Berechnung an 5 Stellen in deinem Code. Die Formel ändert sich. Was ist die beste Vorgehensweise?
Prüfen
Checkpoint
Kannst du das in eigenen Worten erklären? Hake ab, was sitzt.
0 von 3 sitzen