======Funktionen in Python======

Die Beispiele aus diesem Abschnitt können in einem Jupyternotebook nachvollzogen werden. Es muss zusammen mit den Bilddateien vorher entpackt werden.

<WRAP center round download 60%>
{{ :neuerlehrplan:klasse10:funktionen.zip  |Notebook Funktionen}}
</WRAP>

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.

<code python>
def meineFunktion():
    ...Anweisungen...
</code>

Im Quelltext kann dann die Funktion mit Hilfe ihres Namen im Quelltext aufgerufen werden:

<code python>
...Anweisungen...
meineFunktion()
...Anweisungen...
</code>

**Beispiel:**

In unserem Beispiel wird eine Funktion ''%%trennlinie()%%'' definiert, die die Zeichenkette "###############################################" ausgibt, um die Ein- und Ausgaben abzutrennen.

<code python>
def trennlinie():
    print("###############################################")

trennlinie()
name = input("Dein Name: ")
trennlinie()
print("Hallo",name,"du hast einen schönen Namen")
trennlinie()
</code>

Die Ausführung des Programms sieht dann so aus:

<code>
###############################################
Dein Name: Obiwan Kenobi
###############################################
Hallo Obiwan Kenobi du hast einen schönen Namen
###############################################
</code>


=====Lokale und globale Variablen=====

Wir betrachten das folgende Pythonprogramm:

<code python>
def test():
    i=3
    print("Wert von i:",i)

#Hauptprogramm
i=5
print("Wert von i:",i)
test()
print("Wert von i:",i)
</code>

bei der Ausgabe des Programms ergibt sich das Folgende:

<code>
Wert von i: 5
Wert von i: 3
Wert von i: 5
</code>

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.


=====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.

<code python>
def summe(a,b):
    print("Summe von",a,"und",b,":",a+b)

summe(3,4)
x=8
y=9
summe(x,y)
</code>

Als Ausgabe des Programms ergibt sich:

<code>
Summe von 3 und 4 : 7
Summe von 8 und 9 : 17
</code>

====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:**

<code python>
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),".")
</code>

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:

<code>
Die Summe von 3 und 4 ist 7 .
Die Summe von 8 und 9 ist 17 .
</code>

====Vorbelegung der Parameter====

Die Parameter einer Funktion lassen sich in der Definition vorbelegen. Dazu das folgende Beispiel:

<code python>
def summe(a = 0 ,b = 1):
    return a+b

print(summe())
print(summe(3))
print(summe(3,4))
</code>

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:

<code>
1
4
7
</code>

Es ist auch möglich in der Funktionsdefinition nur einige Parameter zu belegen. Diese müssen aber dann am Ende der Parameterliste stehen:

<code python>
def summe(a ,b = 1):
    return a+b

print(summe(3))
print(summe(3,4))
</code>

Ausgabe:

<code>
4
7
</code>

=====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 |}}

===== Übungen =====

Im folgenden Jupyternotebook finden sich einige Übungsaufgaben zum Thema.

<WRAP center round download 60%>
{{ :neuerlehrplan:klasse10:funktionen_uebungen.zip |Übungen}}
</WRAP>