Python-Funktionen: So rufst und schreibst du Funktionen

Standardargumente

Standardargumente erhalten einen Vorgabewert, wenn beim Aufruf kein Wert übergeben wird. Du weist diesen Default-Wert mit dem Zuweisungsoperator = zu, wie im folgenden Beispiel:

Erforderliche Argumente

Wie der Name vermuten lässt, müssen erforderliche Argumente übergeben werden. Diese Argumente müssen beim Aufruf vorhanden sein und in der richtigen Reihenfolge – wie hier gezeigt:

Du brauchst Argumente, die auf die Parameter a und b abgebildet werden, sonst gibt es einen Fehler. Wenn du a und b vertauschst, ändert sich das Ergebnis hier nicht – wohl aber, wenn du plus() so abänderst:

Schlüsselwortargumente

Wenn du sicherstellen willst, dass die Parameter korrekt zugeordnet werden, nutze Schlüsselwortargumente im Funktionsaufruf. Dabei identifizierst du die Argumente über ihre Parameternamen. Das obige Beispiel macht es deutlicher:

Mit Schlüsselwortargumenten kannst du auch die Reihenfolge vertauschen und erhältst dennoch dasselbe Ergebnis:

Variable Anzahl an Argumenten

Wenn du die genaue Anzahl der zu übergebenden Argumente nicht kennst, kannst du die folgende Syntax mit *args verwenden:

Der Stern (*) steht vor dem Variablennamen, der alle nicht-schlüsselwortbasierten Argumente sammelt. Du könntest hier ebenso *varint, *var_int_args oder jeden anderen Namen mit Stern an plus() übergeben.

Tipp: Ersetze *args testweise durch einen anderen Namen mit Stern. Der Code funktioniert weiterhin!

Die obige Funktion nutzt die eingebaute Python-Funktion sum(), um alle übergebenen Argumente in plus() zu addieren. 

Globale vs. lokale Variablen

Variablen, die im Funktionskörper definiert werden, haben in der Regel lokalen Geltungsbereich; außerhalb definierte sind global. Das heißt: Lokale Variablen sind nur innerhalb der Funktion zugreifbar, globale können von allen Funktionen im Skript verwendet werden:

Du wirst eine NameError-Meldung erhalten, dass name 'total' is not defined, wenn du die lokale Variable total ausgeben willst, die innerhalb des Funktionskörpers definiert wurde. Die Variable init hingegen kann problemlos ausgegeben werden.

Nur positions- und nur schlüsselwortbasierte Parameter

Seit Python 3.8 kannst du mit zwei speziellen Markierungen in der Funktionssignatur (/ und *) stärker steuern, wie Argumente übergeben werden: Alles vor / darf nur positionell übergeben werden; alles nach * nur per Schlüsselwort.

def greet(name, /, greeting="Hello", *, punctuation="!"):
    print(f"{greeting} {name}{punctuation}")

 So wirkt sich das beim Aufruf aus:

greet("Alice")                          # works
greet("Alice", greeting="Hi")           # works
greet("Alice", "Hi", punctuation="?")   # works

greet(name="Alice")                     # TypeError: name is positional-only
greet("Alice", "Hi", "?")               # TypeError: punctuation is keyword-only

Warum ist das nützlich? Zwei Hauptgründe.

Erstens erlauben nur positionsbasierte Parameter, sie später umzubenennen, ohne fremden Code zu brechen — da niemand den Parameternamen als Schlüsselwort verwenden darf.

Zweitens erzwingen nur schlüsselwortbasierte Parameter explizite Aufrufe, was bei mehreren optionalen Flags oder Einstellungen die Lesbarkeit erhöht.

Kurz: Eine saubere Möglichkeit, Intentionen durchzusetzen.

Anonyme Funktionen in Python

Anonyme Funktionen heißen in Python Lambda-Funktionen, weil sie nicht mit dem Standard-Schlüsselwort def deklariert werden, sondern mit lambda.

Im obigen DataCamp-Light-Block ist lambda x: x*2 die anonyme bzw. Lambda-Funktion. x ist das Argument und x*2 der Ausdruck, der ausgewertet und zurückgegeben wird. Besonderheit: Die Funktion hat keinen Namen, anders als die Beispiele im ersten Teil dieses Tutorials. Als UDF sähe sie so aus:

def double(x):
  return x*2

Noch ein Beispiel für eine Lambda-Funktion mit zwei Argumenten:

Anonyme Funktionen nutzt du, wenn du zur Laufzeit kurzzeitig eine namenlose Funktion brauchst. Typische Einsatzfälle sind filter(), map() und reduce():

filter() filtert – wie der Name sagt – die Eingabeliste my_list anhand des Kriteriums >10. Mit map() wendest du eine Funktion auf alle Elemente von my_list an. Hier werden alle Elemente mit 2 multipliziert.

Beachte: reduce() ist Teil der Bibliothek functools. Es wendet die Funktion kumulativ von links nach rechts auf die Elemente von my_list an und reduziert die Sequenz in diesem Fall auf den einzelnen Wert 55.

main() als Funktion in Python verwenden

Wenn du Erfahrung mit anderen Sprachen wie Java hast, weißt du: Eine main-Funktion ist dort Pflicht. In Python ist das nicht notwendig, wie du gesehen hast. Dennoch kann eine main()-Funktion helfen, deinen Code logisch zu strukturieren – die wichtigsten Bestandteile stehen dann in dieser Funktion.

Du kannst eine main()-Funktion definieren und sie wie jede andere Funktion aufrufen:

So wie es jetzt ist, wird der Code deiner main()-Funktion allerdings auch beim Import als Modul ausgeführt. Damit das nicht passiert, rufst du main() nur auf, wenn __name__ == '__main__' ist.

Der obige Codeblock wird dann zu:

Hinweis: Neben __main__ gibt es auch __init__, das eine Instanz einer Klasse initialisiert. Einfach gesagt: Es fungiert als Konstruktor/Initializer und wird automatisch aufgerufen, wenn du eine neue Instanz erstellst. Das neu erzeugte Objekt wird dabei dem Parameter self zugewiesen, den du bereits gesehen hast. Beispiel:

class Dog:
    """A simple Dog class.

    Args:
        legs: Number of legs so that the dog can walk.
        color: The color of the fur.
    """

    def __init__(self, legs: int, color: str) -> None:
        self.legs = legs
        self.color = color

    def bark(self) -> str:
        return "bark" * 2

if __name__ == "__main__":
    dog = Dog(4, "brown")
    print(dog.bark())