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

Erklärvideo zum Thema

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.

Erklärvideo zum Thema

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

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 .

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

Erklärvideo zum Thema

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)

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

Aufgabe 1

Gegeben ist das folgende Pythonprogramm:

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)

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

def arbeit(F,s):
    W = F * s
    return W
 
print(arbeit(8000,5))

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

Aufgabe 3 (Zusatzaufgabe)

Hier findet man weitere Übungen zu Funktionen.

>> Rekursion und Iteration