Python-Funktionen

Eine Funktion ist ein benannter, wiederverwendbarer Codeblock, der eine bestimmte Aufgabe ausführt. Funktionen ermöglichen es, Logik einmal zu schreiben und von überall im Programm aufzurufen — der Code wird dadurch kürzer, lesbarer und einfacher zu testen. Dieses Kapitel behandelt alles, was Sie für den sicheren Umgang mit Python-Funktionen benötigen: Definition, Parameter, Rückgabewerte, Standardargumente, *args und **kwargs, Geltungsbereich, Docstrings, Typhinweise, Rekursion und die Verwendung von Funktionen als First-Class-Objekte.

Eine Funktion definieren

Verwenden Sie das Schlüsselwort def, einen Namen, Klammern und einen Doppelpunkt. Der Funktionsrumpf wird um eine Ebene eingerückt.

def greet(name):
    print("Hello, " + name)

Die Funktion wird erst ausgeführt, wenn Sie sie aufrufen. Zum Zeitpunkt der Definition passiert nichts außer dass Python das Funktionsobjekt unter dem angegebenen Namen speichert.

Eine Funktion aufrufen

Übergeben Sie Argumente in den Klammern, die den Parameternamen in der Definition entsprechen.

Rückgabewerte

Eine Funktion kann mit der return-Anweisung ein Ergebnis an den Aufrufer zurückgeben. Ohne return gibt Python None zurück.

def add(a, b):
    return a + b

result = add(3, 5)
print(result)  # 8

Sobald return ausgeführt wird, stoppt die Funktion sofort — jeder nachfolgende Code im selben Funktionsrumpf ist unerreichbar.

Mehrere Werte zurückgeben

Python ermöglicht die Rückgabe mehrerer Werte als Tupel, das auf der Aufrufseite entpackt werden kann.

import math

def circle_stats(radius):
    area = math.pi * radius ** 2
    circumference = 2 * math.pi * radius
    return area, circumference

area, circ = circle_stats(5)
print(round(area, 2))   # 78.54
print(round(circ, 2))   # 31.42

Parameter und Argumente

Python unterstützt mehrere Möglichkeiten, Argumente zu übergeben.

Positionsargumente

Argumente werden der Reihe nach den Parametern zugeordnet.

def describe(name, age):
    print(name, "is", age, "years old")

describe("Bob", 25)   # Bob is 25 years old

Schlüsselwortargumente

Sie können Argumente nach Name in beliebiger Reihenfolge übergeben.

describe(age=25, name="Bob")   # Bob is 25 years old

Standardparameterwerte

Geben Sie einen Fallback-Wert an, der verwendet wird, wenn der Aufrufer das Argument weglässt.

def greet(name="World"):
    print("Hello, " + name)

greet()         # Hello, World
greet("Alice")  # Hello, Alice

Achtung: Verwenden Sie niemals ein veränderliches Objekt (Liste, dict) als Standardwert — es wird einmalig zum Zeitpunkt der Definition erstellt und über alle Aufrufe hinweg geteilt. Verwenden Sie stattdessen None als Standard und erstellen Sie das Objekt im Funktionsrumpf.

# Correct pattern for a mutable default
def append_item(item, lst=None):
    if lst is None:
        lst = []
    lst.append(item)
    return lst

Beliebig viele Positionsargumente (*args)

Stellen Sie einem Parameternamen * voran, um eine beliebige Anzahl von Positionsargumenten in einem Tupel zu sammeln.

def total(*numbers):
    return sum(numbers)

print(total(1, 2, 3))    # 6
print(total(10, 20))     # 30

Beliebig viele Schlüsselwortargumente (**kwargs)

Stellen Sie ** voran, um eine beliebige Anzahl von Schlüsselwortargumenten in einem Dictionary zu sammeln.

def describe_person(**info):
    for key, value in info.items():
        print(key + ": " + str(value))

describe_person(name="Alice", age=30, city="Paris")
# name: Alice
# age: 30
# city: Paris

Parametertypen kombinieren

Wenn Sie Parametertypen mischen, muss die Reihenfolge wie folgt sein: Positionsparameter, *args, nur-Schlüsselwort-Parameter, **kwargs.

def log(level, *messages, separator=" | ", **meta):
    print(level.upper(), separator.join(messages), meta)

log("info", "started", "ready", separator=" — ", version="1.0")
# INFO started — ready {'version': '1.0'}

Geltungsbereich von Variablen

Pythons Scoping-Regeln folgen der LEGB-Regel: Lokal → Umschließend → Global → Eingebaut.

Eine innerhalb einer Funktion definierte Variable ist lokal — sie ist außerhalb nicht zugänglich.

def my_func():
    x = 10          # local to my_func
    print(x)

my_func()
# print(x)  # NameError: name 'x' is not defined

Um eine globale Variable innerhalb einer Funktion zu lesen oder zu ändern, deklarieren Sie sie mit global.

x = 10

def change_x():
    global x
    x = 20

change_x()
print(x)   # 20

Verwenden Sie global sparsam — Funktionen, die auf globalem Zustand beruhen, sind schwieriger zu testen und wiederzuverwenden. Einen tieferen Einblick in den Geltungsbereich bieten Python Variables und Global Variables.

Docstrings

Ein Docstring ist ein Zeichenkettenliteral, das unmittelbar nach der def-Zeile steht. Er dokumentiert, was die Funktion tut, was sie akzeptiert und was sie zurückgibt. Python speichert ihn im __doc__-Attribut der Funktion, und Werkzeuge wie help() zeigen ihn an.

def add(a, b):
    """Return the sum of a and b.

    Args:
        a: First number.
        b: Second number.

    Returns:
        The sum as a number.
    """
    return a + b

print(add.__doc__)
# Return the sum of a and b.
# ...

Typhinweise

Typhinweise (PEP 484) ermöglichen die Annotation von Parameter- und Rückgabetypen. Python erzwingt sie zur Laufzeit nicht, aber Editoren, Linter und mypy nutzen sie, um Fehler frühzeitig zu erkennen.

def multiply(a: float, b: float) -> float:
    return a * b

print(multiply(3, 4))      # 12
print(multiply(2.5, 2.0))  # 5.0

Rekursion

Eine Funktion kann sich selbst aufrufen. Dies wird als Rekursion bezeichnet und ist nützlich für Probleme mit einer von Natur aus rekursiven Struktur (Bäume, Fakultäten usw.). Jede rekursive Funktion benötigt einen Basisfall, der die Rekursion beendet.

def factorial(n):
    if n == 0 or n == 1:   # base case
        return 1
    return n * factorial(n - 1)

print(factorial(5))   # 120
print(factorial(0))   # 1

Python begrenzt die Rekursionstiefe (Standard 1000), um Stack-Überläufe zu verhindern. Bei tiefer Rekursion ist ein iterativer Ansatz oder die Verwendung von sys.setrecursionlimit zu bevorzugen.

Funktionen als First-Class-Objekte

In Python sind Funktionen Objekte. Sie können in Variablen gespeichert, als Argumente übergeben und von anderen Funktionen zurückgegeben werden.

def apply(func, value):
    return func(value)

def double(n):
    return n * 2

print(apply(double, 7))   # 14

Dies ist die Grundlage für Lambda-Funktionen, Higher-Order-Funktionen und Dekoratoren.

Eingebaute Funktionen vs. benutzerdefinierte Funktionen

Python wird mit vielen eingebauten Funktionen geliefert — print(), len(), range(), sum(), sorted() — die ohne Import immer verfügbar sind. Benutzerdefinierte Funktionen sind die, die Sie mit def schreiben. Beide folgen identischer Aufrufsyntax.

Best Practices

• Funktionen als Verben benennen: calculate_tax() ist klarer als tax().
• Eine Sache tun: Eine Funktion, die validiert, speichert und eine E-Mail sendet, sind drei Funktionen, die darauf warten, geboren zu werden.
• Einen Docstring schreiben: Selbst ein einzelner Satz, der den Zweck beschreibt, ist wertvoll.
• Seiteneffekte möglichst vermeiden: Funktionen, die Werte zurückgeben und keinen globalen Zustand ändern, sind einfacher zu testen.
• Signaturen kurz halten: Mehr als drei oder vier Parameter sind ein Signal, zusammengehörige Daten in einer Klasse oder einem dict zu gruppieren.
• Typhinweise verwenden: Sie dienen als leichtgewichtige Dokumentation und ermöglichen statische Analyse.

Übungen