Wiki zum Unterricht

Diese Seite ist nicht editierbar. Sie können den Quelltext sehen, jedoch nicht verändern. Kontaktieren Sie den Administrator, wenn Sie glauben, dass hier ein Fehler vorliegt.
======Funktionen in Python======
=====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>


**Erklärvideo zum Thema**

{{youtube>Nqaxu7M1HB0}}
=====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.


**Erklärvideo zum Thema**

{{youtube>l03PQYyb7Ds}}

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


**Erklärvideo zum Thema**

{{youtube>11xP-W-vi2o}}
=====Darstellung einer Funktion im Struktogramm====

Der Algorithmus einer Funktion wird in einem Extra-Struktogramm dargestellt. Im Unterschied zum Hauptprogramm hat das Rechteck abgerundete Ecken. (linkes Bild)

Im Hauptprogramm wird die Anweisung, in der die Funktion aufgerufen wird, mit senkrechten Strichen links und rechts gekennzeichnet. (rechtes Bild)   

<WRAP group>

<WRAP 30% column>
{{ :python:funcmod:funktion_summe.png?150 |}}
</WRAP>
<WRAP 60% column>
{{ :python:funcmod:funktionen.png?300 |}}
</WRAP>
</WRAP>
===== Vertiefung =====

Im Lehrbuch inf-Schule wird das Thema nochmal vertieft:
  * https://www.inf-schule.de/imperative-programmierung/python/konzepte/funktion
  * https://www.inf-schule.de/imperative-programmierung/python/konzepte/module
  * https://www.inf-schule.de/imperative-programmierung/python/konzepte/namensraeume


===== Aufgaben =====

**Aufgabe 1**

Gegeben ist das folgende Pythonprogramm:

<code python>
def test():
	i=3
	print("Wert von i+j",i+j)
        i=8
        
#Hauptprogramm
i=9
j=11
print("Wert von i+j:",i+j)
test()
print("Wert von i+j:",i+j)
</code>

Überlege dir, wie die Ausgabe des Programms aussehen muss. Teste danach das Programm und überprüfe, ob deine Überlegungen richtig sind.

**Aufgabe 2**

Aus dem Physikunterricht kennst du die Gleichung zur Berechnung der mechanischen Arbeit **W=F·s** (F konstant), wobei F die Kraft und s der zurückgelegte Weg ist. Wenn die Kraft in Newton und der Weg in Metern angegeben ist, ergibt sich die Arbeit in Joule (1J = 1Nm). Das folgende Pythonprogramm definiert eine Funktion ''%%arbeit(F,s)%%'' und testet diese in der **print-Anweisung**. 

<code python>
def arbeit(F,s):
    W = F * s
    return W

print(arbeit(8000,5))

</code>

  - Welche formalen Parameter und welcher Rückgabewert kommen im Programm vor?
  - Schreibe zwei weitere Funktionen ''%%kraft(W,s)%%'' und ''%%weg(F,W)%%'' und teste sie jeweils in einer **print**-Anweisung.




**Aufgabe 3 (Zusatzaufgabe)**

[[https://www.inf-schule.de/imperative-programmierung/python/konzepte/funktion/uebungen | Hier]] 
findet man weitere Übungen zu Funktionen.

\\

[[python:funcmod:rekit| >> Rekursion und Iteration]]



~~DISCUSSION | Hier können Fragen zum Inhalt der Seite gestellt werden. ~~