Funktionen mit Input

Die obige Funktion ermöglicht uns es Code zwar schön zu verpacken und immer wieder zu verwenden, die Funktion führt aber tatsächlich immer exakt den gleichen Code aus. Um Funktionen nicht nur als starre Code-Pakete zu verwenden, sondern auch situationsspezifisch einsetzen und kontrollieren zu können, können wir einen variablen Input festlegen.

Wenn die Funktion einen Input haben soll, dann können wir innerhalb der runden Klammern eine beliebige Zahl von beliebig gewählten Namen für die “Input-Variablen”, welche man auch “Parameter” oder “Argumente” nennt, eintragen. Allgemein sieht das dann so aus:

def FUNCTION_NAME(INPUT1, INPUT2, ...):
    DO_SOMETHING_WITH_INPUT

Die Namen der Input-Variablen sind Platzhalter für die bei Verwendung der Funktion tatsächlich als Input eingebenen Werte. So wie das x bei der uns typischerweise aus der Schule bekannten Funktion f(x) ein abstrakter Platzhalter für einen konkret eingegebenen Wert ist.

Wir könnten nun z.B. eine Funktion schreiben, die statt einem unpersönlichen "hello world" eine jeweils bestimmte Person grüßt. Im Folgenden definiere ich die Funktion say_hello_to(), wobei ich festlege, dass ein Input namens name erwartet wird.

Wie du in der untigen Funktionsdefinition sehen kannst, taucht der Input name nicht nur in den runden Klammern auf, sondern auch darunter im eigentlich Code der Funktion. Dort legen wir fest, was mit dem als name eingegebenen Input innerhalb der Funktion gemacht wird.

Aber nicht vergessen: Den Namen der Input-Variable name haben wir hier “willkürlich” festgelegt und er hat nichts mit dem Wert zu tun, den wir später tatsächlich eingeben. name steht einfach für das, was auch immer da als Input kommen mag. Man kann sich den Input auch als eine “funktions-interne” Variable vorstellen, die bei Aufruf der Funktion den entsprechenden eingegebenen Wert zugewiesen bekommt.

def say_hello_to(name):
    print("Hello", name, "!")

Nachdem die Funktion definiert ist, rufe ich die Funktion mit einem String als Input auf. Diesen Input setze ich an die Stelle, wo in der Funktionsdefinition name steht. Letztlich weise ich damit der funktions-internen Variable name temporär den Wert "Monty" zu.

say_hello_to("Monty")

Hello Monty !

Ein weiteres Beispiel: In der Funktion say_hello_twice wurde per For-Loop zwei mal "hello world" angezeigt. Unten erweitere ich die Funktion um einen Input bzw. Parameter namens n, mit welchem die Wiederholungszahl des For-Loops individuell festlegt werden kann.

def say_hello_several_times(n):
    for i in range(n):
        print("hello world")

say_hello_several_times(2)

hello world
hello world

say_hello_several_times(5)

hello world
hello world
hello world
hello world
hello world

Funktionen mit mehreren Inputs

Wir können eine beliebige Anzahl an Inputs einer Funktion festlegen. Ich kombiniere nun z.B. die Funktionalität der Funktion say_hello_to() mit der Funktionalität der Funktion say_hello_several_times, sodass mithilfe von zwei Inputs sowohl die zu begrüßende Person als auch die Häufigkeit der Begrüßung festgelegt werden kann.

def say_hello_several_times_to(name, n):
    for i in range(n):
        print("Hello", name, "!")

say_hello_several_times_to("Monty", 4)

Hello Monty !
Hello Monty !
Hello Monty !
Hello Monty !

Hat eine Funktion mehrere Inputs, dann ist es sehr wichtig darauf zu achten, in welcher Reihenfolge die Inputs erfolgen müssen. Steht in der Funktionsdefinition der Input name an erster Stelle innerhalb der runden Klammer, dann muss bei der Ausführung der Funktion der entsprechende Wert, welcher für name eingesetzt werden soll, auch an erster Stelle kommen. Steht der Input n an zweiter Stelle, dann muss der entsprechend eingesetzt Wert an zweiter Stelle eingesetzt werden. Werden die Inputs allein anhand der Position in der runden Klammer zugeordnet, dann nennt man diese (auf Englisch) “positional arguments”.

Vor allem wenn eine Funktion viele Inputs erwartet, kann es relativ schnell relativ kompliziert werden, die genaue Reihenfolge der Inputs einzuhalten. Schnell kann es dazu kommen, dass man die eingegebenen Werte an eine falsche Stelle setzt und somit falschen Inputvariablen zuordnet. Eine Lösung für das Problem kann sein, sogenannte “keyword arguments” zu verwenden.

Input mittels keyword arguments

Der Input jeder Funktion kann immer auch über “keyword arguments” zugewiesen werden. Das bedeutet, dass die eingegebenen Werte nicht über die Position in den runden Klammern zugeordnet werden, sondern man weist innerhalb der runden Klammern den eingegebenen Wert mittels Gleichheitszeichen dem entsprechenden Argument/Platzhalter zu, wie man hier sieht:

say_hello_several_times_to(name="Monty", n=4)

Hello Monty !
Hello Monty !
Hello Monty !
Hello Monty !

Nun ist die Reihenfolge irrelevant und man kann die Inputs in beliebiger Reihenfolge eingeben. Unten tausche ich beispielhaft die Reihenfolge der Funktionsinputs:

say_hello_several_times_to(n=4, name="Monty")

Hello Monty !
Hello Monty !
Hello Monty !
Hello Monty !