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.

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

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.

Erklärvideo zum Thema

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