======Funktionen in Python====== Die Beispiele aus diesem Abschnitt können in einem Jupyternotebook nachvollzogen werden. Es muss zusammen mit den Bilddateien vorher entpackt werden. {{ :neuerlehrplan:klasse10:funktionen.zip |Notebook Funktionen}} Danach kann man das Notebook zusammen mit den Bildern z.B. bei https://jupyter.org/try -> JupyterLab hochladen und öffnen. =====Definition und Aufruf einer Funktion===== Zur Definition einer Funktion verwendet man in Python das Schlüsselwort ''%%def%%''. Danach steht der Funktionsname. Für ihn gelten dieselben Konventionen wie Variablennamen. Nach dem Namen folgt ein Paar Klammern ''%%()%%''. In diesen Klammern können Variablen stehen (Siehe unten!). Nach den Klammern steht ein Doppelpunkt ''%%:%%''. Der Quelltext, der nach der Funktion eingerückt wird, gehört zur Funktion. def meineFunktion(): ...Anweisungen... Im Quelltext kann dann die Funktion mit Hilfe ihres Namen im Quelltext aufgerufen werden: ...Anweisungen... meineFunktion() ...Anweisungen... **Beispiel:** In unserem Beispiel wird eine Funktion ''%%trennlinie()%%'' definiert, die die Zeichenkette "###############################################" ausgibt, um die Ein- und Ausgaben abzutrennen. def trennlinie(): print("###############################################") trennlinie() name = input("Dein Name: ") trennlinie() print("Hallo",name,"du hast einen schönen Namen") trennlinie() Die Ausführung des Programms sieht dann so aus: ############################################### Dein Name: Obiwan Kenobi ############################################### Hallo Obiwan Kenobi du hast einen schönen Namen ############################################### =====Lokale und globale Variablen===== Wir betrachten das folgende Pythonprogramm: def test(): i=3 print("Wert von i:",i) #Hauptprogramm i=5 print("Wert von i:",i) test() print("Wert von i:",i) bei der Ausgabe des Programms ergibt sich das Folgende: Wert von i: 5 Wert von i: 3 Wert von i: 5 Wie ist die Ausgabe des Programms zu erklären? Zunächst wird einer Variablen i ein Wert zugewiesen. Dieser Wert wird dann ausgegeben. Anschließend wurde die Funktion aufgerufen. Innerhalb der Funktion wird nun wieder einer Variablen i ein Wert zugewiesen. Da die Zuweisung innerhalb der Funktion (im lokalen Namensraum) erfolgt, ist i eine lokale Variable, die sich von der ersten Variable i, einer globalen Variable, unterscheidet. Nun wird i innerhalb der Funktion ausgegeben. Dazu wird i zunächst im lokalen Namensraum, also innerhalb der Funktion, gesucht. Es wird also auf das i innerhalb der Funktion zugegriffen und der entsprechende Wert ausgegeben. Würde i nicht im lokalen Namensraum existieren, so würde das Programm im globalen Namensraum danach suchen. Nach Beendigung der Funktion existiert die lokale Variable i nicht mehr. Im weiterem Programmverlauf wird aber nun erneut i ausgegeben. Hier wird nun wieder das ursprüngliche i verwendet, welches im globalen Namensraum definiert wurde. Der Wert einer globalen Variable darf aber im lokalen Namensraum nur verändert werden, wenn bei der Wertzuweisung vor ihr das Schlüsselwort ''%%global%%'' steht. **Globale Variable**: Variable, die im Hauptprogramm definiert wird. **Lokale Variable**: Variable, die in einer Funktion definiert wird. ==== Vor- und Nachteile lokaler und globaler Variablen ==== ^ ^**Vorteile** ^**Nachteile** ^ |**globale Variablen**|Speicherplätze werden nicht unnötig belegt.|Speicherplätze werden auf Dauer belegt. | |**lokale Variablen** |Variablen stehen überall zur Verfügung. |Variablen stehen nur in der Funktion zur Verfügung| =====Funktionen mit Parametern und Rückgabewerten===== ====Parameter==== Einer Funktion können beim Aufruf Werte übergeben werden. Dazu schreibt man bei der Definition der Funktion in die Klammer nach den Funktionsnamen sogenannte **formale Parameter**. Im Quelltext der Funktion werden diese behandelt, wie lokale Var 1iablen. **Beispiel:** Im folgenden Programm wird eine Funktion ''%%summe(a,b)%%'' mit den formalen Parametern ''%%a%%'' und ''%%b%%'' definiert. Diese Parameter werden in der Funktion wie lokale Variable verwendet. Beim Funktionsaufruf werden den Parametern konkrete Werte übergeben. Beim ersten Aufruf sind dies die Zahlen 3 und 4, beim zweiten die Werte 8 und 9, die zuvor den variablen x und y zugewiesen worden. def summe(a,b): print("Summe von",a,"und",b,":",a+b) summe(3,4) x=8 y=9 summe(x,y) Als Ausgabe des Programms ergibt sich: Summe von 3 und 4 : 7 Summe von 8 und 9 : 17 ====Rückgabewerte==== Funktionen können auch Werte haben zurück ans Hauptprogramm übergeben. Dies geschieht mit dem Schlüsselwort ''%%return%%''. Um die Verwendung von ''%%return%%'' zu erklären, wandeln wir unser obiges Beispiel ab: **Beispiel:** def summe(a,b): return a+b x = 3 y = 4 s = summe(x,y) print("Die Summe von",x,"und",y,"ist",s,".") n = 8 m = 9 print("Die Summe von",n,"und",m,"ist",summe(n,m),".") In diesem Beispiel wird von der Funktion die Summe der Parameter a und b an das Hauptprogramm zurückgegeben. Beim ersten Aufruf der Funktion ''%%s = summe(x,y)%%'' wird der Rückgabewert der Variablen ''%%s%%'' zugewiesen. ''%%s%%'' wird dann in der nachfolgenden **print**-Anweisung verwendet. Beim zweiten Aufruf ''%%summe(n,m)%%'' wird der Rückgabewert direkt in die **print**-Anweisung geschrieben. Als Ausgabe des Programms ergibt sich: Die Summe von 3 und 4 ist 7 . Die Summe von 8 und 9 ist 17 . ====Vorbelegung der Parameter==== Die Parameter einer Funktion lassen sich in der Definition vorbelegen. Dazu das folgende Beispiel: def summe(a = 0 ,b = 1): return a+b print(summe()) print(summe(3)) print(summe(3,4)) Die Parameter ''%%a%%'' und ''%%b%%'' sind mit den Werten 0 und 1 vorbelegt. Dadurch muss die Funktion nicht mehr mit allen Parametern aufgerufen werden. Beim ersten Aufruf ''%%summe()%%'' werden die Parameter mit den Werten 0 und 1 belegt. Beim zweiten Aufruf ''%%summe(3)%%'' wird der erste Parameter ''%%a%%'' mit 3 belegt, ''%%b%%'' bleibt mit 1 belegt. Beim dritten Aufruf ''%%summe(3,4)%%'' werden ''%%a%%'' und ''%%b%%'' die entsprechenden Werte übergeben. Als Ausgabe des Programms ergibt sich: 1 4 7 Es ist auch möglich in der Funktionsdefinition nur einige Parameter zu belegen. Diese müssen aber dann am Ende der Parameterliste stehen: def summe(a ,b = 1): return a+b print(summe(3)) print(summe(3,4)) Ausgabe: 4 7 =====Darstellung einer Funktion im Struktogramm===== Der Algorithmus einer Funktion wird in einem Extra-Struktogramm dargestellt. {{ :neuerlehrplan:klasse10:1_07_struktogramm_funktion.png?direct&600 |}} Im Hauptprogramm wird dann der Funktionsaufruf als Befehl angegeben. {{ :neuerlehrplan:klasse10:1_07_struktogramm_hauptprogramm.png?direct&600 |}} =====Vordefinierte Funktionen, Module===== Abgesehen von einigen grundlegenden Funktionen wie `print` oder `len` sind viele Funktionen nicht in der Python Standard Library enthalten sondern in Modulen ausgelagert. Mit der folgenden Syntax können wir ein Modul importieren, um auf die enthaltenen Funktionen zugreifen zu können: # Zugriff auf alle enthaltenden Funktionen import module module.function_name() #Aufruf der Funktion über Punktnotation from module import * function_name() #Aufruf der Funktion #Es auch nur einzelne Funktionen eines Moduls importieren: from module import function_name function_name() Neben den bekannten Standardbibliotheken kann man auch eigene Funktionen in Modulen speichern und importieren. Module in Python bieten eine flexible Möglichkeit, Code zu organisieren und zu strukturieren, was dazu beiträgt, den Entwicklungsprozess zu erleichtern und die Qualität des Codes zu verbessern. # Beispiel für ein einfaches Modul namens "mein_modul.py" def sag_hallo(name): print("Hallo, " + name + "!") # Anwendung des Moduls in einem anderen Skript import mein_modul mein_modul.sag_hallo("Python") ===== Übungen ===== Im folgenden Jupyternotebook finden sich einige Übungsaufgaben zum Thema. {{ :neuerlehrplan:klasse10:funktionen_uebungen.zip |Übungen}}