Funktionen in Python

Eigentlich kennen wir bereits Funktionen und haben diese auch verwendet. Die Print-Funktion ist -Oh wunder!- eine Funktion genauso wie es auch range ist.
Aber was ist den nun eine Funktion?
Eine Funktion ist allgemein gesagt ein Programmbereich, welcher abgekapselt definiert wird und im Programm selbst dann aufgerufen werden kann. Aber ein Beispiel sollte hier eher helfen:

def machWas():
   print("Ich wurde in der Funktion aufgerufen")

Wir können die Funktion grob in zwei Teile aufteilen. Funktionskopf, sowie Funktionsrumpf oder -körper.
Der Kopf ist die erste Zeile, also das Keyword “def”, welches ankündigt, dass wir nun eine Funktion definieren. Danach steht der Name der Funktion und in runden Klammern geben wir die Parameter an. In unseren Fall also erstmal nichts. Abgeschlossen wird der Kopf mit Doppelpunkten. 

Nun müssen wir genauso wie bei den Schleifen und bei den if-Abfragen den eigentlichen Rumpf also den Inhalt der Funktion, durch Einrücken, kenntlich machen.
In diesen geben wir dann mit der uns bekannten Print-Funktion einen Text aus.

Wenn wir diesen Code jetzt so ausführen, was passiert wohl?
Garnichts! Aber warum? Wir haben die Funktion jetzt erstmals nur definiert, aber noch nicht aufgerufen. Dieser Aufruf sieht in unseren Fall dann so aus:

machWas()

Folglich konnten wir somit den Print-Befehl ausführen und in unserer Konsole steht “ich wurder in der Funktion aufgerufen”.

Mit Parametern:

Die Funktionen die wir bis jetzt kennen lernen durften hatten immer etwas in den Klammern stehen. Können wir das auch? Natürlich:

def rechneMirWasAus(zahl1, zahl2):
   print("das ergebnis ist " + str(zahl1 + zahl2))
rechneMirWasAus(3,5)

Hier definieren wir eine Funktion namens rechneMirWasAus. Vielleicht nicht der gängigste Name, aber das soll uns für das Beispiel nicht stören.

Anders als bei dem Beispiel zuvor sind aber die runden Klammern nicht leer. Wir schreiben hier zwei Parameter rein, also Variabeln welche vom Aufrufer der Funktion definiert werden und wir nachher in der Funktion verwenden wollen. Wir rechnen die beiden Zahlen zusammen und geben das Ergebnis mit Print aus. Da wir die Funktion danach mit den Parametern 3 und 5 aufrufen werden, wird wie erwartet, “das Ergebnis ist 8” ausgegeben.

Mit Return Wert:

Aber was ist wenn ich das Rechenergebnis wirklich ausgegeben haben möchte oder mit diesem dann noch weitere Rechnungen durchführen möchte, ohne das Ergebnis vorher auszugeben? Die Range-Funktion hat uns ja auch was zurückgegeben. Auch das können wir folgendermaßen durchführen:

def rechneMirWasAus(zahl1, zahl2):
   return zahl1 + zahl2

Wir sagen quasi “das was bei rechneMirWasAus mit den parametern 3 und 5 rauskommt, das übergibst du an Print”, sprich gebe es in der Konsole aus.

Mehrere Return Werte:

Da wir mehrere Parameter übergeben können, kommt vielleicht auch die Frage auf, ob wir mehrere return Werte zurückgeben können, und ja können wir!:

def test():
   return 3,5
print(test())

Das Ergebnis sieht vielleicht ein wenig merkwürdig aus. (3,5).Die Funktion gibt uns nun ein Tupel zurück, welches die beiden Return Werte in sich hat. Aber was ein Tupel genau ist und wie man mit diesen arbeiten kann, wird zukünftig noch ein Beitrag folgen =)

Globale Variabeln:

Wir nehmen mal an wir haben folgenden oder ähnlichen Code:

zahl = 10
def funktion():
   zahl = 5
funktion()
print(zahl)

Welchen Wert wird die Variable nach dem Aufruf der Funktion “funktion” haben, 10 oder 5?

Durch das Ausführen des Codes bemerken wir, dass 10 als Ergebnis rauskommt. Das Ändern der Variable innerhalb der Funktion hat also keinen Einfluss. Das liegt daran, dass wir in der Funktion nicht die außerhalb der Funktion definierte Variable der Zahl überschreiben, sondern eine neue Variable mit dem gleichen Namen definieren. Bei der “zahl” in der Funktion reden wir von einer lokalen Variable, die außerhalb der Funktion ist eine globale Variable. Die lokale “zahl” existiert nur solange, wie die Funktion läuft. In dem Moment, wo sie zu Ende ist, gibt es die Variable auch nicht mehr. Die globale Variable hingegen existiert bis zum Ende des Programms. Aber was ist wenn wir nun in der Funktion auf die globale Variable zugreifen wollen? Wenn wir die globale Variable nur lesen wollen, aber nicht verändern, dann können wir das ganz einfach. Der nachfolgende Code funktioniert ohne Problem und gibt einfach die global definierte Zahl aus:

zahl = 10
def funktion():
   holder = zahl
   print(holder)
funktion()

Aber was ist wenn wir nun in der Funktion die Zahl verändern wollen? Dann kommt das Keyword global zum Einsatz:

zahl = 10
def funktion():
   global  zahl
   zahl = 5
funktion()
print(zahl)

Wir sagen am Anfang der Funktion mit dem Keyword “global”, dass wir die globale Variable auch ändern wollen, der Print am Ende gibt somit 5 und nicht 10 aus.

Wie man Funktionen “richtig” schreibt:

• Funktionen dürfen genauso wie auch Variablen nicht irgendwie heißen. Sie dürfen nicht mit Zahlen anfangen und auch ansonsten gelten die gleichen Regeln wie beim Definieren von Variablen.
• Außerdem muss die Variable zuerst definiert und erst dann aufgerufen werden, anders herum ergibt es einen Fehler.
• Zwar ist es möglich auf globale Variablen mit dem Keyword “global” zuzugreifen und zu verändern, aber das sollte eher die Ausnahme sein da andernfalls der Code verwirrend werden kann.
• Funktionen wie auch Variablen werden häufig in der sogenannten Schreibart camelcase geschrieben. Also werden die Wörter zusammengeschrieben, das erste Wort klein, alle anderen groß. So wird aus “Rechne mir mal aus” → “rechneMirMallAus”. Ich würde nicht sagen, dass man camelcase zwangsläufig schreiben muss. Es ist nur wichtig eine einheitliche Notation zu haben und nicht jede Funktion und Variable in einem anderen Stil zu schreiben

Das wars auch wieder für heute. Du hast nun endlich das Geheimnis hinter Funktionen kennen gelernt und kannst nun eigene definieren und aufrufen!
Vielen dank fürs Lesen und bis zum nächsten Mal.