Python Funktion

Python Funktion einfach erklärt

Eine neue Funktion (engl. python function) definierst du mit dem Schlüsselwort def. Dahinter kommt der Name deiner Funktion und zwei runde Klammern mit einem Doppelpunkt (Zeile 1). Vergiss nicht, alle Zeilen einzurücken, die in deine Funktion gehören (Zeilen 2 & 3)! Nachdem du deine Funktion definiert hast, kannst du sie mit ihrem Namen und runden Klammeren jederzeit aufrufen und dein Pythonprogramm führt die Befehle in deiner Funktion aus (Zeilen 5 & 7). 

1 def beispiel_funktion():
2    print("Diese Funktion kannst du oft wiederverwenden.")
3    print("Du kannst in deine Funktion so viele Befehle schreiben, wie du magst.")
 
4 print("Start")
5 beispiel_funktion()
6 print("Ende")
7 beispiel_funktion()

Falls du einen Fehler in deiner Funktion hast, musst du ihn dann nur an einer Stelle korrigieren und kannst die Funktion so oft wiederverwenden, wie du magst. Außerdem helfen dir Funktionen dein Python Programm übersichtlich zu gestalten, indem du einzelne Aufgaben in eigene Funktionsblöcke verpackst.

Was ist ein Parameter?

Auf den ersten Blick wirken Python Funktionen (engl. python function) sehr unflexibel. Was tust du, wenn sich deine Funktion bei jedem Aufruf ein bisschen anders verhalten soll? Du könntest zum Beispiel eine Funktion schreiben, die den Benutzer mit seinem Namen begrüßt.

Das schaffst du, indem du beim Funktionsaufruf eine Variable – einen sogenannten Parameter – übergibst. Dafür musst du bei der Definition (python def) der Funktion angeben, welchen Namen der Parameter haben soll. Hier heißt er name (Zeile 1). Innerhalb der Funktion kannst du ihn dann wie eine normale Variable benutzen. Bei jedem Funktionsaufruf musst du dann in runden Klammern einen Wert für deinen Parameter angeben (Zeile 3).

1 def gruss(name):
2    print(f"Hallo, {name}! Wie geht es Dir?")

3 gruss("Max Mustermann")
4 gruss("Peter Pan")

Ausgabe:

Hallo, Max Mustermann! Wie geht es Dir?
Hallo, Peter Pan! Wie geht es Dir?

Aber aufgepasst! Jetzt musst du globale von lokalen Variablen unterscheiden. Funktionsparameter sind sogenannte lokale Variablen, weil du sie nur innerhalb der Funktion benutzen kannst (engl. scope of variables). Variablen, die du außerhalb einer Funktion definierst, sind sogenannte globale Variablen. Du kannst sie an jeder Stelle deines Python Programms benutzen. Sogar innerhalb deiner Funktionen.

Schaue dir das am besten an einem Beispiel an: Die Variablen a und b sind global (Zeile 1). Der Parameter c ist lokal (Zeile 2). In Zeile 4 druckt dein Programm also die Zahlen 10 5 1 auf deinen Monitor, weil deine Funktion die globalen Variablen a und b kennt und du ihr die lokale Variable c beim Funktionsaufruf übergeben hast. In Zeile 5 wird dein Programm einen Fehler ausgeben. Python kennt die Variable c nämlich nicht mehr, weil du sie eine lokale Variable ist und nur innerhalb der Funktion func benutzt werden darf. 

1 def func(c):
2    print(f"{a} {b} {c}")
3 a, b = 10, 5

4 func(1)
5 print(f"{a} {b} {c}")

Was ist ein Rückgabewert?

Funktionen sind sogar noch vielseitiger – sie können auch einen Rückgabewert haben. Das ist eine Variable, die deine Funktion deinem Pythonprogramm zurückgibt. So kannst du zum Beispiel Rechenergebnisse aus deiner Funktion im restlichen Programm benutzen.

Dafür benutzt du den Befehl return. Alles, was du hinter return schreibst, gibt deine Funktion dem Pythonprogramm zurück. Du kannst alle Datentypen zurückgeben, die du kennst (z.B. Listen, Tupel, Zahlen, Text, sogar andere Funktionen, …). Hier gibt die Funktion eine Zahl zurück (Zeile 2). Wenn du deine Funktion dann aufrufst, kannst du sie wie eine Variable benutzen und ihren Rückgabewert einem neuen Variablennamen zuweisen (Zeile 3).

1 def quadrat(a):
2    return a**2

3 zahl = quadrat(5)
4 print(zahl)

Ausgabe: 25

Wichtig: return ist das Ende deiner Funktion. Sobald Python diesen Befehl in deiner Funktion ausführt, ist die Funktion zu Ende und alle restlichen Zeilen in der Funktion werden ignoriert!

Mehrere Parameter übergeben

Wenn deine Funktion noch flexibler sein muss, kannst du auch mehrere Parameter übergeben. Du musst die einzelnen Parameter bei der Definition und dem Aufruf deiner Python Funktion nur mit einem Komma trennen (Zeilen 1 & 3). Die Anzahl der Parameter ist nicht beschränkt.

1 def summe(a, b, c):
2    return a + b + c

3 print(summe(1, 2, 3))

Ausgabe: 6

Standardwerte für Funktionsparameter

Zuletzt gibt es noch einen Trick, der dir hilft, deine Funktionen perfekt auf dein Programm zuzuschneiden: Optionale Parameter. Das sind Parameter, die du beim Funktionsaufruf nicht angeben musst. Wenn du einen optionalen Parameter nicht übergibst, benutzt Python einfach einen Standardwert (engl. default value). Aber wie weiß Python, welchen Standardwert es verwenden muss?

Das schauen wir uns an einem Beispiel an: Zuerst definierst du dir eine Python Funktion mit den Parametern ende und schrittweite. Gleichzeitig weist du deinem Parameter schrittweite einen Wert zu (Zeile 1). Das ist der Standardwert, den Python benutzt, wenn du keinen Wert für schrittweite übergibst. Sobald du einen Standardwert angibst, ist der Parameter optional. Wenn du ihn nicht übergibst (Zeile 6), dann tut Python so, als ob du den Standardwert 1 übergeben hättest. Ansonsten benutzt Python den Wert, den du angibst (Zeile 8).

Der erste Parameter ende hat keinen Standardwert (Zeile 1). Es ist ein sogenannter obligatorischer Parameter. Du musst ihn also bei jedem Funktionsaufruf übergeben. In den vorherigen Beispielen waren alle Parameter obligatorische Parameter.

1 def zaehlen(ende, schrittweite=1):
2    i = 0
3    while ende > i:
4       print(i)
5       i = i + schrittweite

6 zaehlen(3)
7 print("----")
8 zaehlen(4, 2)

Ausgabe:

0
1
2
----
0
2

Aber aufgepasst! Python kann auch ganz schnell durcheinander kommen, wenn du obligatorische und optionale Parameter vermischst. In diesem Beispiel weiß Python in Zeile 3 nicht, welcher Wert zu welchem Parameter gehört. Python denkt, dass du nur Werte für a und b übergibst und c bleibt dann undefiniert. Dein Programm stürzt deshalb ab.

1 def nachricht(a="Hallo", b, c):
2    print(f"{a} {b} {c}")

3 nachricht("Max", "Mustermann")

Darum schreibst du bei der Definition deiner Python Funktionen immer die obligatorischen Parameter zuerst und die optionalen zuletzt (Zeile 1). Dein Beispiel sieht dann so aus:

1 def nachricht(b, c, a="Hallo"):
2     print(f"{a} {b} {c}")

3 nachricht("Max", "Mustermann")

Ausgabe: Hallo Max Mustermann

Wenn du mehrere optionale Parameter hast, kann es auch zu unübersichtlich werden. Im Zweifel kannst du beim Funktionsaufruf immer dazuschreiben, welcher Wert zu welchem Parameter gehört (Zeile 3). Du darfst nämlich beim Funktionsaufruf den Parametern ihren richtigen Wert zuweisen.

1 def nachricht(b, c="Mustermann", a="Hallo"):
2    print(f"{a} {b} {c}")

3 nachricht("Max", a="Guten Tag")

Ausgabe: Guten Tag Max Mustermann

for-Schleife

Du hast gesehen, dass Funktionen praktisch sind, wenn du denselben Code wieder benutzen willst. Eine andere Möglichkeit, einen Teil deines Programms zu wiederholen ist die for-Schleife . Schaue gleich mal in unser Video dazu rein!