6.2 Funktionen mit Parameter und Rückgabe#
Vorgefertigte Funktionen haben wir schon mit Argument und Rückgabewert aufgerufen. In diesem Kapitel geht es darum, selbst eine Funktion zu implementieren, die Argumente entgegennimmt, diese verarbeitet und dann Rückgabewerte liefert.
Lernziele#
Lernziel
Sie können eine Funktion mit Parametern und Rückgabewerten selbst implementieren.
Sie können zwischen Parametern und Argumenten einer Funktion unterscheiden.
Definition von Funktionen mit Parametern#
Meistens haben Funktionen Argumente, um Eingaben entgegennehmen und verarbeiten zu können. Das Argument wird bei der Implementierung der Funktion mit einer Variablen eingeführt.
Die allgemeine Syntax zur Definition einer eigenen Funktion mit Parametern sieht wie folgt aus:
def meine_funktion(para1, para2, ..., paran):
anweisung01
anweisung02
...
Funktionen werden mit dem Schlüsselwort def
gefolgt vom Funktionsnamen und
einer Aufzählung von Parametern in Klammern definiert. Die Code-Anweisungen der
Funktion werden eingerückt.
Als Beispiel betrachten wir erneut die Funktion, die Grüße ausrichtet. Doch jetzt erweitern wir die Funktion. Die modifizierte Variante soll konkret eine Person grüßen.
def gruesse_ausrichten_mit_parameter(name):
print(f'Ich grüße {name}!')
Der Aufruf einer Funktion ohne passende Argumente führt nun zu einer Fehlermeldung. Entfernen Sie in der nächsten Code-Zelle das Kommentarzeichen.
# gruesse_ausrichten_mit_parameter()
Daher müssen wir die modifizierte Funktion nun mit einem Argument aufrufen:
gruesse_ausrichten_mit_parameter('Anna')
Ich grüße Anna!
Hinweis: Bei Funktionen unterscheiden wir zwischen einem Parameter einer
Funktion und einem Argument. Die formalen Parameter sind die Variablennamen
in der Funktionsdefinition (z.B. name
in def gruesse_ausrichten_mit_parameter(name):
). Sie dienen als Platzhalter für die
Werte, die beim Funktionsaufruf übergeben werden. Die aktuellen Argumente sind
dagegen die konkreten Werte, die beim Aufruf der Funktion übergeben werden (z.B.
'Anna'
in gruesse_ausrichten_mit_parameter('Anna')
). Der formale Parameter
name
nimmt also beim Funktionsaufruf den Wert des Arguments 'Anna'
an und
steht innerhalb der Funktion als Variable zur Verfügung.
Die Funktion gruesse_ausrichten_mit_parameter()
hat aber keinen Rückgabewert.
Das können wir wie folgt testen:
x = gruesse_ausrichten_mit_parameter('Alice')
type(x)
Ich grüße Alice!
NoneType
x
ist vom Typ NoneType
. Das bedeutet, dass in der Variablen x
der
spezielle Python-Wert None
gespeichert ist. None
ist ein eigener Datentyp in
Python und repräsentiert die Abwesenheit eines Wertes oder ein ‘nichts’.
Funktionen, die keinen expliziten Rückgabewert mit return
angeben, geben
automatisch None
zurück.
Sind Funktionen ohne Rückgabewert sinnvoll? Ja, denn so können Python-Programme vereinfacht werden. Sollte in einem Programm ein Block von Anweisungen mehrmals ausgeführt werden, lohnt es sich, diesen in eine Funktion auszulagern, um diese einfach aufrufen zu können.
Mini-Übung
Schreiben Sie eine Funktion, die mit Turtle ein Rechteck zeichnet. Die beiden Seitenlängen des Rechtecks sollen als Argumente der Funktion übergeben werden. Testen Sie Ihre Funktion auch.
# Geben Sie nach diesem Kommentar Ihren Code ein:
Lösung
import ColabTurtlePlus.Turtle as turtle
turtle.clearscreen()
def zeichne_rechteck(seite1, seite2):
rechteck = turtle.Turtle()
for i in range(2):
rechteck.forward(seite1)
rechteck.left(90)
rechteck.forward(seite2)
rechteck.left(90)
a = 100
b = 30
zeichne_rechteck(a,b)
Das folgende Video fasst Funktionen mit Parametern in Python zusammen.
Video “Funktionen mit Parametern” von Programmieren Starten
Funktionen mit Parametern und Rückgabewerten#
In der Regel jedoch haben Funktionen einen Rückgabewert. Die allgemeine Syntax zur Definition einer eigenen Funktion mit Parametern und Rückgabewert sieht wie folgt aus:
def meine_funktion(para1, para2, ..., paran):
anweisung01
anweisung02
...
return rueckgabewert1, rueckgabewert2, ...
An der Definitionszeile ändert sich nichts. Zuerst wird das Schlüsselwort def
verwendet, dann folgt der Funktionsname und zuletzt werden die Parameter in
Klammern aufgelistet. Der Rückgabewert der Funktion wird dann durch das
Schlüsselwort return
im Inneren der Funktion, also im eingerückten Teil
definiert. Die Funktion kann einen oder mehrere Rückgabewerte zurückliefern. Bei
mehreren Rückgabewerten werden diese einfach durch Komma getrennt.
Für Experten: Bei mehreren Rückgabewerten erzeugt Python intern ein sogenanntes Tupel, das all diese Werte enthält. Daher kann man das Ergebnis einer solchen Funktion auch direkt einer einzelnen Variablen zuweisen und erhält dann ein Tupel, oder man kann die Werte durch Kommas getrennt mehreren Variablen zuweisen (Unpacking).
Schauen wir uns ein Beispiel an. Die folgende Funktion nimmt einen Parameter entgegen und gibt einen Rückgabewert zurück.
def berechne_quadratzahl(zahl):
return zahl * zahl
Jetzt können wir die Funktion ausprobieren.
for x in range(1,11):
y = berechne_quadratzahl(x)
print(f'{x} mal {x} ist {y}')
1 mal 1 ist 1
2 mal 2 ist 4
3 mal 3 ist 9
4 mal 4 ist 16
5 mal 5 ist 25
6 mal 6 ist 36
7 mal 7 ist 49
8 mal 8 ist 64
9 mal 9 ist 81
10 mal 10 ist 100
Als nächstes kommt ein Beispiel mit zwei Rückgabewerten. Nicht nur die Quadratzahl, sondern auch die Kubikzahl soll berechnet werden.
def berechne_quadrat_kubik(zahl):
quadrat = zahl**2
kubik = zahl**3
return quadrat, kubik
Und erneut testen wir die Funktion.
for x in range(1,6):
x_hoch_2, x_hoch_3 = berechne_quadrat_kubik(x)
print(f'x = {x}, x^2 = {x_hoch_2}, x^3 = {x_hoch_3}')
x = 1, x^2 = 1, x^3 = 1
x = 2, x^2 = 4, x^3 = 8
x = 3, x^2 = 9, x^3 = 27
x = 4, x^2 = 16, x^3 = 64
x = 5, x^2 = 25, x^3 = 125
Wenn eine Funktion mehrere Werte zurückgibt, haben wir verschiedene
Möglichkeiten, diese zu verarbeiten. Meist weisen wir jedem Rückgabewert eine
eigene Variable zu, wie in x_hoch_2, x_hoch_3 = berechne_quadrat_kubik(x)
. Man
muss jedoch nicht immer alle Rückgabewerte verwenden. Benötigt man zum Beispiel
nur den ersten Rückgabewert, kann man schreiben: x_hoch_2, _ = berechne_quadrat_kubik(x)
. Der Unterstrich _
ist eine Konvention in Python,
die signalisiert, dass dieser Wert ignoriert wird.
Alternativ kann man auch alle Rückgabewerte als Tupel einer einzelnen Variable
zuweisen: ergebnis = berechne_quadrat_kubik(x)
. Dann greift man über den Index
auf die einzelnen Werte zu: ergebnis[0]
für das Quadrat und ergebnis[1]
für
den Kubikwert.
Mini-Übung
Schreiben Sie ein Programm, das mit Turtle ein Rechteck zeichnet, wobei die beiden Seitenlängen als Argumente der Funktion übergeben werden. Die Funktion soll den Umfang des Rechtecks und den Flächeninhalt zurückgeben. Lassen Sie anschließend Umfang und Flächeninhalt ausgeben.
# Geben Sie nach diesem Kommentar Ihren Code ein:
Lösung
import ColabTurtlePlus.Turtle as turtle
turtle.clearscreen()
def zeichne_rechteck(seite1, seite2):
# Zeichnung des Rechecks
rechteck = turtle.Turtle()
for i in range(2):
rechteck.forward(seite1)
rechteck.left(90)
rechteck.forward(seite2)
rechteck.left(90)
# Berechnung Umfang und Flächeninhalt
umfang = 2 * seite1 + 2 * seite2
flaeche = seite1 * seite2
# Rückgabe
return umfang, flaeche
# Test der Funktion
a = 100
b = 30
U,A = zeichne_rechteck(a,b)
print(f'Der Umfang ist {U:.2f} Längeneinheiten, der Flächeninhalt des Rechtecks ist {A:.2f} Flächeneinheiten.')
Auch zu dem Thema Funktionen mit Rückgabe gibt es ein Video.
Video “Funktionen mit Rückgabewert” von Programmieren Starten
Zusammenfassung und Ausblick#
Funktionen mit Parametern und Rückgabewerten ermöglichen flexible Eingaben und die Rückgabe von Ergebnissen, was unsere Programme modular und wiederverwendbar macht. Im nächsten Kapitel lernen wir, wie Variablen unterschiedliche Gültigkeitsbereiche haben können - entweder nur innerhalb einer Funktion (lokal) oder im gesamten Programm (global).