In diesem Beitrag möchte ich dir aufzeigen was Funktionsparameter sind und was du mit diesen machen kannst.
Im Beitrag Python #9: Funktionen habe ich dir bereits vorgestellt was eine Funktion ist und wie du diese in deine Programme verwenden kannst. An diesen Beitrag möchte ich nun gerne anknüpfen und die Parameter einer Funktion (auch Funktionsparameter genannt) behandeln.
Was sind Funktionsparameter?
Nehmen wir zunächst eine einfache Funktion “f” dieser möchten wir nun um Funktionsparameter erweitern damit wir einen Text x mal auf der Konsole ausgeben können.
Als ersten Parameter übergeben wir die Variable für die Anzahl der Wiederholung und als zweiten Wert den Text.
def f(count, text):
for i in range(0, count):
print(text)
f(6, "Hallo Welt!")
Für den Aufruf der Funktion MÜSSEN wir nun die beiden Funktionsparameter befüllen. Sollte ein Funktionsparameter fehlen so wird ein Fehler auf der Konsole aufgegeben.
Traceback (most recent call last):
File "C:\xyz\FunktionsparameterTest.py", line 6, in <module>
f("Hallo Welt!")
TypeError: f() missing 1 required positional argument: 'text'
Ein Problem kann auftreten wenn die Reihenfolge der Funktionsparameter falsch ist.
f("Hallo Welt!",6)
Traceback (most recent call last):
File "C:\xyz\FunktionsparameterTest.py", line 6, in <module>
f("Hallo Welt!",6)
File "C:\xyz\FunktionsparameterTest.py", line 3, in f
for i in range(0, count):
Für diesen Fehlerfall können wir die Funktionsparameter auch benennen, d.h. wir übergeben in dem Aufruf der Funktion den genauen Parameternamen inkl. des zugewiesenen Wertes.
f(text = "Hallo Welt!", count = 6)
Die Ausgabe ist dann wie gewünscht 6x der Text “Hallo Welt!” auf der Konsole.
Defaultwerte an Funktionsparameter
Wenn man eine Funktion wiederholt verwendet so kann es sein das der Wert an einem Parameter mehrmals verwendet wird bzw. immer gleich ist. Hier kann man Defaultwerte definieren. Diese Defaultwerte werden an der Definition der Parameter gesetzt. Wenn man nun die Funktion “f” ohne Parameter aufruft wird der Text “Hallo Welt!” vier mal auf der Konsole ausgegeben.
def f(count=4, text="Hallo Welt!"):
for i in range(0, count):
print(text)
f()
Überschreiben eines Funktionsparameters
Den Defaultwert eines Funktionsparameters kann man auch überschreiben. Im nachfolgenden Aufruf der Funktion “f” wird der Text “Hallo Welt!” sieben mal auf der Konsole ausgegeben.
f(7)
Wenn nun zusätzlich den Text überschreiben möchte, gibt man als weiteren Parameter den gewünschten Text ein.
f(7, "Test")
Beim überschreiben von den Defaultwerten muss man jedoch beachten das man die Reihenfolge der Funktionsparameter beachtet.
f(8, "Test")
Oder man nutzt den Namen der Funktionsparameter und benennt die Parameter welche man überschreiben möchte.
f(text="Test")
Variable Funktionsparameter
aufrufen einer Funktion mit variablen Funktionsparameter
Nehmen wir einmal an wir haben eine Funktion welche 3 Funktionsparameter enthält.
def f(vorname, nachname, alter):
print(vorname, nachname, alter)
Die Werte dazu liegen in einer einfachen Liste.
person = ["Max", "Mustermann", 34]
Wir können nun der Funktion “f” die Werte aus der Liste mit dem Index übergeben.
f(person[0], person[1], person[2])
Auf der Konsole wird dann wie erwartet die Ausgabe “Max Mustermann 34” erfolgen.
Jedoch ist diese Schreibweise etwas lang und nicht gerade dynamisch, d.h. wenn zbsp. die Adresse in die Liste aufgenommen wird müssen wir wieder etwas ändern und der Aufruf der Funktion wird immer länger.
Hier können wir mit einem variablen Funktionsparameter arbeiten und sehr viel Schreibarbeit sparen. Die aufzurufende Funktion bleibt dabei unberührt!
def f(vorname, nachname, alter):
print(vorname, nachname, alter)
person = ["Max", "Mustermann", 34]
f(*person)
Wir müssen “nur” ein Sternchen vor den Variablennamen der Liste tätigen und Python entpackt dann die Werte in die jeweiligen Funktionsparameter.
Jedoch müssen die Anzahl der Funktionsparameter und die Werte in der Liste übereinstimmen, d.h. wenn die Funktion 3 Funktionsparameter enthält dann muss auch die Liste genau 3 Werte enthalten. Wenn dieses nicht so ist erhält man einen Fehler.
//hier die Fehlermeldung aus jupiterNotebook
definieren einer Funktion mit variablen Funktionsparameter
Zunächst haben wir eine Funktion mit variablen Funktionsparameter aufgerufen, nun möchten wir eine neue Funktion mit variablen Funktionsparameter definieren. Zunächst wollen wir die Daten einer Person aus einer Liste auf der Konsole ausgeben dazu definieren wir eine Liste mit dem variablen Funktionsparameter “value”. Diesem Funktionsparameter setzen wir ein Sternchen an und somit definieren wir einen variablen Funktionsparameter. Wir können nun die Funktion mit wie bereits erwähnt aufrufen.
def f(*values):
print(values)
person = ["Max", "Mustermann", 34]
f(*person)
Und erhalten auf der Konsole die Ausgabe der Daten aus der Liste. Dieses mal jedoch als Tupel. Das liegt daran das wir die Funktion mit einer beliebigen Anzahl an Parameter aufrufen.
berechnen eines Maximalen Wertes aus einer dynamischen Liste
Erstellen wir uns nun eine Funktion welcher wir eine dynamische Liste mit Zahlen übergeben können und erhalten als Rückgabewert den maximalen Wert. Zunächst definieren wir eine Funktion “max” mit dem variablen Funktionsparameter “values”. Damit wir ein Tupel mit allen Zahlen aus unserer Liste erhalten müssen wir diese Liste bei der Übergabe entpacken.
def max(*values):
result = values[0]
for zahl in values:
if zahl > result:
result = zahl
return result
zahlen = [1,6,4,5,8,9,2,4]
print(max(*zahlen))
Auf der Konsole wird die Zahl “9” ausgegeben.
übergeben von Key / Value basierenden Funktionsparameter
Im Abschnitt zuvor habe ich dir gezeigt wie man eine Liste an variablen Funktionsparameter an eine Funktion übergeben kann. Dabei mussten wir jedoch immer “irgendwie” prüfen das die Anzahl der Funktionsparameter übereinstimmt. Hier möchte ich dir nun zeigen wie du mit einem Key / Value basierenden Funktionsparameter arbeitest und dir somit noch etwas mehr Freiheit in der Deklaration der variablen Funktionsparameter holst.
Zunächst zeige ich dir an einem kleinen Beispiel wie dieses Funktioniert:
Wir definieren zunächst eine Funktion mit einem variablen Funktionsparameter, jedoch dieses mal mit zwei Sternchen.
def f(**params): pass
Im Aufruf der Funktion wird nun Key/Value basiert die Werte eingegeben.
f(vorname="Stefan", nachname="Draeger", alter="40")
Wenn wir uns zunächst einmal nur das Objekt “params” auf der Konsole ausgeben, so sehen wir das wir ein Dictionary erzeugt haben.
{'vorname': 'Stefan', 'nachname': 'Draeger', 'alter': '40'}
Somit können wir in unserer Funktion “f” wie bei einem Dictionary gewohnt mit dem Key auf den Wert zugreifen.
def f(**params):
print(params)
print(params["vorname"])
print(params["nachname"])
print(params["alter"])
Wozu benötigen wir das?
Im Beitrag Python #11: Diagramme zeichnen mit matplotlib habe ich dir gezeigt wie man mit Python sehr einfach Diagramme zeichnen kann. Die Funktion “plot” erhält dabei alle Parameter welche zum zeichnen des Diagramms benötigt werden. Diese können jedoch je nach Anwendungsfall variable sein, zbsp. die Farbe, die Linienstärke oder der Style der Linie.
Das nachfolgende Beispiel habe ich aus der offiziellen Dokumentation zu Matplotlib entnommen.
import matplotlib.pyplot as plt
def drawPlot():
plt.plot([1, 2, 3, 4])
plt.ylabel('some numbers')
plt.show()
drawPlot()
Wenn wir dieses Beispiel in Eclipse ausführen dann wird ein zusätzliches Fenster geöffnet und dort das Diagramm gezeichnet.
Der Funktion “plot” kann man diverser Parameter übergeben “matplotlib.pyplot.plot(*args, scalex=True, scaley=True, data=None, **kwargs)” (siehe https://matplotlib.org/api/_as_gen/matplotlib.pyplot.plot.html#matplotlib.pyplot.plot). Wenn wir uns die Liste der Parameter anschauen, dann sehen wir als letzten Parameter “**kwargs”. Dieses ist der Parameter welcher ein Dictionary enthalten kann und für die Parameter des Diagrams dienen.
plt.plot([1, 2, 3, 4],[5,6,7,8], color="g", linewidth=3, linestyle="dotted")
Die Eigenschaften
- Farbe – color
- Linienstärke – linewidth
- Linientyp – linestyle
können wir nun auch als Dictionary wie folgt übergeben:
import matplotlib.pyplot as plt
from matplotlib.lines import lineStyles
def drawPlot(**params):
plt.plot([1, 2, 3, 4],[5,6,7,8], **params)
plt.ylabel('some numbers')
plt.show()
drawPlot(color="g", linewidth=3, linestyle="dotted")
In dem englischsprachigen Beitrag auf https://www.tutorialspoint.com/python/python_functions.htm findest du weitere Informationen zu Funktionen in Python3.