Python-Funktionen meistern: Definition, Aufruf, Einrückung, Argumente & Rückgabewerte

Python-Funktionen meistern: Definition, Aufruf, Einrückung, Argumente & Rückgabewerte

Funktionen sind die Bausteine jeder Python-Anwendung. Sie kapseln wiederverwendbare Logik, halten den Code DRY (Don't Repeat Yourself) und machen Programme leichter lesbar, testbar und wartbar. In diesem Leitfaden gehen wir jeden Schritt durch, den Sie benötigen, um Funktionen in Python 3 zu schreiben, aufzurufen und Fehler zu beheben – dabei berühren wir auch die Unterschiede zu Python 2.

Was ist eine Funktion in Python?

Eine Python-Funktion ist ein in sich geschlossener Codeblock, der ausgeführt wird, wenn Sie ihn aufrufen. Sie können sie sich als Miniaturprogramm vorstellen, das eine einzelne, klar definierte Aufgabe ausführt und überall wiederverwendet werden kann. Während Python zahlreiche eingebaute Funktionen mitbringt (z. B. print(), input()), sind Sie frei, Ihre eigenen zu erstellen – was Ihrem Code die Macht gibt, sich weiterzuentwickeln und zu skalieren.

Definieren und Aufrufen einer Funktion

Funktionen werden mit dem Schlüsselwort def deklariert, gefolgt vom Funktionsnamen und einer in Klammern gesetzten Parameterliste. Der Funktionskörper beginnt mit einem Doppelpunkt und muss eingerückt sein.

def begruessen():
    print("Hallo, Python!")

# Funktion aufrufen
begruessen()

Ausgabe: Hallo, Python!

Warum Einrückung wichtig ist

Python verwendet keine geschweiften Klammern oder explizite begin/end-Anweisungen. Stattdessen definiert die Einrückung den Gültigkeitsbereich. Jeder Codeblock – Funktionen, Schleifen, Bedingungen – muss eine konsistente Einrückungsebene haben.

1. Mindestens eine Einrückungsebene (üblicherweise vier Leerzeichen) ist nach einer Funktionsdefinition erforderlich.
2. Alle Anweisungen innerhalb dieser Funktion müssen die gleiche Einrückung verwenden.
3. Das Mischen von Tabs und Leerzeichen oder variierende Einrückungstiefen löst einen IndentationError aus.

Beispiel für korrekte Einrückung:

def demo():
    print("Zeile 1")
    print("Zeile 2")

Und ein häufiger Fehler:

def demo():
print("Ups")

Der folgende Fehler wird ausgelöst: IndentationError: expected an indented block

Verwendung von Return-Anweisungen

Das Schlüsselwort return sendet einen Wert an den Aufrufer zurück. Wenn eine Funktion das Ende erreicht, ohne auf ein return zu stoßen, gibt sie implizit None zurück.

def quadrat(x):
    return x * x

print(quadrat(4))  # 16

Ohne return:

def quadrat(x):
    x * x

print(quadrat(4))  # None

Zusätzlich zeigt das Drucken des Funktionsobjekts selbst (z. B. print(quadrat)) dessen Speicheradresse an, was im Anwendungscode selten nützlich ist.

Argumente an Funktionen übergeben

Argumente liefern die Daten, die eine Funktion zum Arbeiten benötigt. Parameter sind die Platzhalter, die in der Funktionssignatur definiert sind.

def multiplizieren(x, y=1):
    return x * y

print(multiplizieren(4))        # 4 (y hat Standardwert 1)
print(multiplizieren(4, 2))     # 8
print(multiplizieren(y=3, x=2)) # 6 (Keyword-Argumente erlauben Umordnung)

Variabel-lange Argumente (*args und **kwargs)

Manchmal benötigen Sie eine Funktion, die eine beliebige Anzahl von Argumenten akzeptiert. Verwenden Sie *args für Positionsargumente und **kwargs für Keyword-Argumente.

def zusammenfassen(*werte, **optionen):
    gesamt = sum(werte)
    print(f"Gesamt: {gesamt}")
    if optionen.get("details_anzeigen"):
        print("Werte:", werte)

zusammenfassen(1, 2, 3, 4, 5, details_anzeigen=True)

Python 2 vs. Python 3: Wichtige Unterschiede

• Print-Syntax: print "text" in Python 2 vs. print("text") in Python 3.
• Funktionen-Überladen (mehrere Signaturen mit demselben Namen) wird in Python 2 nicht unterstützt, ist aber in Python 3 über functools.singledispatch oder durch Prüfung der Argumenttypen verfügbar.
• Ganzzahldivision: 5/2 ergibt 2 in Python 2 und 2.5 in Python 3 (verwenden Sie // für Ganzzahldivision in beiden Versionen).

Best Practices für Funktionsdesign

• Halten Sie Funktionen fokussiert: Eine Funktion sollte eine klare Aufgabe ausführen.
• Dokumentieren Sie mit einem Docstring in der ersten Zeile innerhalb der Funktion.

  def addieren(a, b):
      """Gibt die Summe von a und b zurück."""
      return a + b

• Verwenden Sie Type Hints (Python 3.5+), um erwartete Argumenttypen und Rückgabetypen zu klären.

  def addieren(a: int, b: int) -> int:
      return a + b

• Bevorzugen Sie Keyword-Argumente für optionale Parameter, um die Lesbarkeit zu erhöhen.

Vollständiges Beispiel

# Beispiel für ein umfassendes Python-3-Skript
def begruessen():
    """Gibt eine freundliche Begrüßung aus."""
    print("Hallo, Python!")

def quadrat(x: int) -> int:
    """Gibt das Quadrat von x zurück."""
    return x * x

def multiplizieren(x: int, y: int = 1) -> int:
    """Gibt das Produkt von x und y zurück, wobei y standardmäßig 1 ist."""
    return x * y

# Demonstration
if __name__ == "__main__":
    begruessen()
    print(quadrat(4))        # 16
    print(multiplizieren(4)) # 4
    print(multiplizieren(4, 2))      # 8
    print(multiplizieren(y=2, x=4))  # 8

Für detailliertere Anleitungen verweisen Sie auf die offizielle Python-Dokumentation zu Funktionsdefinitionen.