Gut verschnürt

Welcher Sysadmin, welche Programmiererin kennt das nicht? Das bißchen Code, das ein Problem erstmal prima löste, beginnt zu wuchern und dadurch den Blick zu verstellen. Damit die Übersicht nicht verloren geht, ist Aufräumen angesagt: Programmcode, der mehrfach in ähnlicher Form zum Einsatz kommt, gewinnt – ausgegliedert in allgemeinere Funktionen – an Vielseitigkeit und damit Wiederverwendbarkeit. Das verkürzt den Code meist schon um einiges.

Mit einer Sammlung von tausend und einer Funktion ist es aber nicht getan – zusammengehörige Funktionen bündeln Sie in Modulen. Blicken Sie auch hier aufgrund der Anzahl nicht mehr durch, verstauen Sie Modulgruppen in Pakete. Wie Ihnen Python beim Aufräumen hilft, erfahren Sie in diesem Artikel.

Funktionen

Funktionen werden in Python üblicherweise mit dem Schlüsselwort def erstellt:

def addiere(a, b):
    """Gib a plus b zurueck."""
    return a + b
# gibt 5 aus
print addiere(2, 3)

Auf def folgt der Name der zu definierenden Funktion, danach in Klammern die Argumente der Funktion. Dann folgt ein Doppelpunkt. Den darunter folgenden Funktionsrumpf schreiben Sie eingerückt. Alles, was von der ersten Zeile der Funktion mindestens diese Einrücktiefe hat, gehört also noch zur Funktionsdefinition.

Üblicherweise folgt als erster Bestandteil des Funktionsrumpfes eine Zeichenkette, die als Funktionsname .__doc__ abfragbar ist und allgemein Docstring heißt. Dokumentationswerkzeugen wie Pydoc [1] werten diese aus und erstellen daraus einfacher zu lesende Dokumente (Abbildung 1).

Abbildung 1: Von Pydoc [1] generierte HTML-Ausgabe für das Modul pprint. Die Python-Distribution enthält Pydoc. Hier bildet es die Grundlage für den help-Befehl im interaktiven Interpreter.

Anders als zum Beispiel in Perl verlangt Python, dass Funktionen Ergebnisse explizit mit der Anweisung return zurückgeben. Folgt auf das Schlüsselwort return kein Ausdruck, ist der Rückgabewert None, ebenso, wenn in der Funktion gar keine return-Anweisung auftaucht.

Besteht der Funktionsrumpf wie oben nur aus einem Ausdruck, dürfen Sie die Funktion auch als anonyme Funktion mit dem Schlüsselwort lambda definieren. Im Ausdruck addiere = lambda a, b: a + b fehlt die return-Anweisung; der nach dem Doppelpunkt stehende Ausdruck ist der Rückgabewert. Der Docstring taucht hier ebenfalls nicht auf, Python setzt ihn implizit auf None.

Vorgabeargumente

Mit der folgenden Syntax definieren Sie Vorgabeargumente (Default-Argumente), die bei fehlenden Argumenten im Funktionsaufruf einspringen:

def addiere(a, b=2):
    """
    Gib a plus b zurueck. Wird b
    weggelassen, ist es 2.
    """
    return a + b
# ergibt 5
print addiere(2, 3)
# ergibt 4
print addiere(2)

In der Funktionsdefinition folgen Argumente mit Vorgabewerten immer nach Argumenten ohne Vorgabewerte. Hier noch ein paar Beispiele zu Vorgabewerten:

def demo(a, b="b", c="c"):
    """Zeige a, b und c."""
    print a, b, c
demo(1, 2, 3)  # 1, 2, 3
demo(1, 2)     # 1, 2, c
demo(1)        # 1, b, c
# Fehler! a hat keinen
# Vorgabewert
demo()

Wenn Sie als Vorgabewert ein veränderliches Objekt verwenden (siehe Teil der Python-Reihe in Heft LinuxUser 09/2006), wie zum Beispiel eine Liste oder ein Dictionary, wertet Python dieses nur bei der Definition der Funktion aus, nicht bei jedem Aufruf:

def sammle(x, L=[]):
    "Sammle x in einer Liste L."
    L.append(x)
    print L
sammle(1)       # [1]
sammle(2)       # [1, 2] !
sammle(3, [5])  # [5, 3]

Wünschen Sie bei Abwesenheit des Arguments tatsächlich jedesmal eine leere Liste als Vorgabe, hilft dieses Idiom:

def immer_neu(x, L=None):
    "Sammle x in einer Liste L."
    if L is None:
        L = []
    L.append(x)
    print L