Funktionen: def, Parameter, return

Sobald dein Python-Programm mehr als 30-40 Zeilen hat, wirst du anfangen Funktionen zu schreiben. Eine Funktion ist ein wiederverwendbarer Code-Block mit Namen – du schreibst sie einmal, rufst sie beliebig oft auf. Das hat zwei riesige Vorteile: dein Code wird kürzer (kein Copy&Paste mehr) und du kannst komplizierte Aufgaben in kleine verständliche Stücke zerlegen.

Python-Funktionen sind dabei besonders flexibel: Parameter können Default-Werte haben, du kannst sie per Name übergeben statt per Position, eine Funktion kann beliebig viele Argumente nehmen, und Rückgabewerte können auch mehrere Werte gleichzeitig sein. Wer aus Java-Methoden kommt, wird Python-Funktionen als eleganter und kürzer empfinden.

1) Eine Funktion definieren mit def

Funktionen werden mit dem Schlüsselwort def definiert. Danach kommt der Name, runde Klammern mit Parametern, ein Doppelpunkt – und der eingerückte Funktionskörper. Genau wie bei Kontrollstrukturen bestimmt die Einrückung was zum Funktionskörper gehört. Klicke die Teile der Signatur an, um sie zu erkunden:

Funktions-Signatur – Bestandteile

def begruesse (name, gruss="Hallo") -> str:
return f"{gruss}, {name}!"

← Klicke einen Teil der Signatur.

Eine Funktion wird mit ihrem Namen plus runden Klammern aufgerufen: begruesse("Anna"). Erst beim Aufruf wird der Code drin ausgeführt – die def-Zeile selbst „registriert" die Funktion nur. Anders als in Java brauchst du keine Klassen drumherum: Python-Funktionen können einfach so im Skript stehen.

2) return: Werte aus der Funktion zurückgeben

Eine Funktion kann mit return einen Wert zurückgeben – sie endet sofort an dieser Stelle. Wenn kein return da ist, liefert die Funktion automatisch None zurück (Pythons „nichts" – siehe L2):

def addiere(a, b): return a + b ergebnis = addiere(3, 5) print(ergebnis) # 8 # Funktion ohne return def begruesse(name): print(f"Hi {name}!") # kein return x = begruesse("Anna") print(x) # None

Eine besondere Python-Eigenschaft: mehrere Werte gleichzeitig zurückgeben. Technisch betrachtet wird daraus ein Tuple, das du beim Aufruf direkt unpacken kannst:

def min_max(zahlen): return min(zahlen), max(zahlen) kleinste, groesste = min_max([3, 1, 4, 1, 5, 9]) print(kleinste, groesste) # 1 9

3) Die vier Arten Parameter zu übergeben

Python kennt vier Modi für Parameter. Sie können sogar kombiniert werden – aber für den Anfang reicht es, jede einzeln zu verstehen:

Parameter-Modi im Vergleich

Positional

def f(a, b): ...

Standard: Reihenfolge entscheidet welcher Wert wohin geht. Pflicht-Argumente.

f(3, 5)

Default

def f(a, b=10): ...

Mit Standardwert. Kann weggelassen werden beim Aufruf.

f(3) → b=10

Keyword

def f(a, b): ...

Aufruf mit Namen: explizit welcher Parameter welchen Wert bekommt. Reihenfolge egal.

f(b=5, a=3)

*args

def f(*werte): ...

Beliebig viele positional Argumente landen als Tuple in werte.

f(1, 2, 3, 4)

**kwargs

def f(**opts): ...

Beliebig viele Keyword-Argumente landen als dict in opts.

f(x=1, y=2)

Die Reihenfolge in der Signatur ist streng: positional → default → *args → **kwargs. Ein häufiges Pattern: def f(a, b=10, *args, **kwargs) deckt fast alles ab. Die Sternchen-Syntax wirkt erstmal exotisch, ist aber sehr nützlich für flexible APIs – z.B. wenn eine Funktion Optionen an andere Funktionen weitergeben muss.

4) Keyword-Arguments in der Praxis

Keyword-Arguments machen Funktionsaufrufe lesbarer. Vergleich: was bedeutet create_user("Anna", 25, True, False, 5)? Keine Ahnung was die letzten drei Werte sollen. Aber:

create_user( name="Anna", alter=25, aktiv=True, admin=False, max_sessions=5 )

Sofort klar was passiert. Viele Python-Bibliotheken (z.B. pandas, matplotlib) nutzen das exzessiv. Faustregel: ab 3-4 Parametern oder wenn boolean-Argumente dabei sind, lieber keyword-Arguments verwenden. Bei vielen Default-Werten kannst du gezielt nur einen davon überschreiben:

def verbinde(host, port=5432, timeout=30, ssl=True): ... # Nur timeout überschreiben – andere Defaults bleiben verbinde("db.example.com", timeout=60)

5) Scope und die LEGB-Regel

Wenn du in einer Funktion eine Variable verwendest, woher weiß Python welche gemeint ist? Python sucht in einer festen Reihenfolge – der LEGB-Regel: Local → Enclosing → Global → Built-in. Stell dir das als geschachtelte Schalen vor:

LEGB – wo Python Variablen sucht

BBuilt-in (zuletzt durchsucht)

print · len · sum · range · max · min · int · str · True · False · None ...

GGlobal (Modul-Ebene)

PI = 3.14159 · globale Konstanten und top-level Variablen

EEnclosing (umgebende Funktion)

Bei geschachtelten Funktionen: Variablen der äußeren Funktion

LLocal (zuerst durchsucht)

Parameter der Funktion · innerhalb definierte Variablen

Python schaut zuerst L (in der aktuellen Funktion), dann E (in umgebenden Funktionen falls verschachtelt), dann G (auf Modul-Ebene), zuletzt B (Built-in Funktionen wie print). Erste Trefferin gewinnt. Wichtig: Variablen IN der Funktion sind lokal! Eine Funktion kann globale Variablen lesen, aber zum Ändern brauchst du global x – was du fast nie tun solltest. Lieber Werte als Parameter rein, Ergebnis als return raus.

6) Docstrings: Dokumentation direkt im Code

Wenn eine Funktion mit einem String startet (in dreifachen Anführungszeichen), wird der zur Dokumentation der Funktion. Tools, IDEs und Hilfsfunktionen können das nutzen. Eine Funktion ohne Docstring ist wie ein Buch ohne Klappentext – schwer zu verwenden:

def berechne_bmi(gewicht_kg, groesse_m): """Berechnet den Body-Mass-Index. Args: gewicht_kg (float): Gewicht in Kilogramm groesse_m (float): Körpergröße in Metern Returns: float: BMI-Wert (kg/m²) """ return gewicht_kg / (groesse_m ** 2) # Aufruf für Hilfe help(berechne_bmi) print(berechne_bmi.__doc__)

Docstrings werden auch automatisch von Tools wie pydoc oder Sphinx in HTML-Dokumentation umgewandelt. Bekannte Stile: Google Style (oben gezeigt), NumPy Style, reStructuredText. Wähle einen und bleib konsistent.

7) Lambda – kurze Funktionen ohne Namen

Für ganz kleine Funktionen die du nur einmal brauchst, gibt es Lambda-Ausdrücke – Funktionen in einer Zeile ohne Namen. Sie sind besonders nützlich als Argument für andere Funktionen wie sorted, map, filter:

# Klassische Funktion def quadrat(x): return x * x # Lambda – gleicher Effekt, eine Zeile quadrat = lambda x: x * x # Typische Anwendung: Sortierung nach Kriterium schueler = [ {"name": "Anna", "note": 2}, {"name": "Bob", "note": 1}, {"name": "Carla", "note": 3}, ] sortiert = sorted(schueler, key=lambda s: s["note"])

Lambda ist auf einen einzigen Ausdruck beschränkt – kein return, keine mehrzeilige Logik. Für alles Komplexere lieber ein normales def verwenden. Mehr zu funktionalen Konzepten in K41b – Python Fortgeschritten.

8) Pass-by-Reference – aber mit Twist

Python übergibt Werte „by reference" – aber das wirkt unterschiedlich je nach Datentyp. Listen und Dictionaries können in der Funktion verändert werden und die Änderung ist außen sichtbar. Bei Zahlen, Strings und Tupeln (immutable Typen) hingegen wirken Änderungen nur innen:

def verdopple(x): x = x * 2 # neue Variable lokal, original unverändert zahl = 10 verdopple(zahl) print(zahl) # 10 – unverändert def verdopple_alle(liste): for i in range(len(liste)): liste[i] *= 2 # Änderung an der gemeinsamen Liste zahlen = [1, 2, 3] verdopple_alle(zahlen) print(zahlen) # [2, 4, 6] – geändert!

Praktische Konsequenz: vorsichtig sein mit Mutable-Default-Werten. def f(items=[]) ist ein berüchtigter Anfänger-Bug – die Liste wird zwischen Aufrufen geteilt! Stattdessen: def f(items=None): if items is None: items = [].

Zusammenfassung

Funktionen mit def name(parameter): + Einrückung. return beendet und liefert Wert (oder mehrere als Tuple); ohne return → None. Parameter-Modi: positional, default (x=10), keyword (f(name=...)), *args für beliebig viele, **kwargs für Keyword-Beliebig. Reihenfolge: positional → default → *args → **kwargs. Scope nach LEGB: Local → Enclosing → Global → Built-in. Docstrings in """...""" direkt nach def. Lambda für Einzeiler. Mutable Argumente (list, dict) sind „geteilt" – immutable (int, str, tuple) wirken nur innen.