Funktionen I: Grundlagen
Einführung
In einem Programm kann es vorkommen, dass gewisse Arbeitsschritte an verschiedenen Stellen nötig sind. In solchen Situationen kopiert man dann ganz gerne einen Teil des Programmtextes und fügt ihn an anderer Stelle noch einmal ein. Dadurch wird der Programmtext aber insgesamt sehr lang und auch schnell unübersichtlich. Daher schauen wir uns nun eine elegantere Möglichkeit an.
Die Idee ist, dass man sogenannte Funktionen verwendet. Als Beispiel stellen wir uns vor, wir wollen für verschiedene Parameter zahl jeweils die Summe $1+2+3+\cdots+\mathtt{zahl}$ ausrechnen und anzeigen lassen. Sagen wir, einmal für $\mathtt{zahl}=10$, dann für $\mathtt{zahl}=100$ und schließlich für $\mathtt{zahl}=1000$. Dies könnte man (sehr ungeschickt) so erledigen:
ergebnis = 0
zaehler = 1
while zaehler <= 10:
ergebnis = ergebnis+zaehler
zaehler=zaehler+1
print ("Die Summe der Zahlen von 1 bis 10 lautet: "+str(ergebnis))
ergebnis = 0
zaehler = 1
while zaehler <= 100:
ergebnis = ergebnis+zaehler
zaehler=zaehler+1
print ("Die Summe der Zahlen von 1 bis 100 lautet: "+str(ergebnis))
ergebnis = 0
zaehler = 1
while zaehler <= 1000:
ergebnis = ergebnis+zaehler
zaehler=zaehler+1
print ("Die Summe der Zahlen von 1 bis 1000 lautet: "+str(ergebnis))
Wir sehen schon, wie sich der Programmtext mit leichter Variation mehrmals wiederholt. Diesen Programmtext lagern wir nun in eine Funktion aus. Das geschieht so:
def summe(n):
ergebnis = 0
zaehler = 1
while zaehler <= n:
ergebnis = ergebnis+zaehler
zaehler = zaehler+1
print ("Die Summe der Zahlen von 1 bis "+str(n)+" lautet: "+str(ergebnis))
Diese Funktion können wir nun von unserem Programm aus starten. Die einfachste Variante (aber nicht die beste), sieht so aus:
def summe(n):
ergebnis = 0
zaehler = 1
while zaehler <= n:
ergebnis = ergebnis+zaehler
zaehler = zaehler+1
print ("Die Summe der Zahlen von 1 bis "+str(n)+" lautet: "+str(ergebnis))
summe(10)
summe(100)
summe(1000)
Hier wird diese Funktion dreimal aufgerufen. Beachte, dass diese Aufrufe nach der Definition der Funktion stehen müssen.
Warum diese Variante nicht die beste ist, ist nicht auf den ersten Blick zu erkennen. Dies wird erst deutlich, wenn wir ein Programm erstellen, das mit mehreren Dateien arbeitet. Dies soll erst später vertieft werden. Wir sehen uns dies hier aber zum besseren Verständnis kurz an.
Wir arbeiten nun einerseits mit der Datei Funktionen_Summe.py, die den Programmcode von oben enthält:
# Datei Funktionen_Summe.py
def summe(n):
ergebnis = 0
zaehler = 1
while zaehler <= n:
ergebnis = ergebnis+zaehler
zaehler = zaehler+1
print ("Die Summe der Zahlen von 1 bis "+str(n)+" lautet: "+str(ergebnis))
summe(10)
summe(100)
summe(1000)
Andererseits arbeiten wir mit einer zweiten Datei, die wir zum Beispiel Import_Test.py nennen können:
# Datei Import_Test.py
from Funktionen_Summe import *
summe(99)
In dieser Datei sollen die in der ersten Datei bereitgestellten Funktionen importiert werden, so dass wir sie von hier aus starten können. Bei größeren Programmiervorhaben ist dies ein gängiges Verfahren. Eigentlich möchten wir hier ausschließlich die Funktion summe mit dem Argument 99aufrufen, jedoch erhalten wir folgende Ausgabe:
Die Summe der Zahlen von 1 bis 10 lautet: 55
Die Summe der Zahlen von 1 bis 100 lautet: 5050
Die Summe der Zahlen von 1 bis 1000 lautet: 500500
Die Summe der Zahlen von 1 bis 99 lautet: 4950
Die drei Aufrufe mit den Argumenten 10, 100 und 1000 finden also auch noch statt.
Möchten wir dies unterbinden, so müssen wir die Datei Funktionen_Summe.py wie folgt modifizieren:
# Datei Funktionen_Summe.py
def summe(n):
ergebnis = 0
zaehler = 1
while zaehler <= n:
ergebnis = ergebnis+zaehler
zaehler = zaehler+1
print ("Die Summe der Zahlen von 1 bis "+str(n)+" lautet: "+str(ergebnis))
if __name__ == "__main__":
summe(10)
summe(100)
summe(1000)
Starten wir jetzt die Datei Import_Test.py, so wird nur die Summe von 1 bis 99 berechnet. Starten wir Funktionen_Summe.py, so werden nach wie vor die drei dort angegebenen Summen berechnet. Die if-Abfrage prüft also (vereinfacht gesagt), ob wir die vorliegende Datei als Einstiegspunkt unseres Programms gewählt haben.
Parameter mit Standardwerten
Es gibt die Möglichkeit, für Parameter Standardwerte festzulegen, die immer dann verwendet werden, wenn beim Aufruf kein Wert angegeben wird:
def summe(n=100):
ergebnis = 0
zaehler = 1
while zaehler <= n:
ergebnis = ergebnis+zaehler
zaehler = zaehler+1
print ("Die Summe der Zahlen von 1 bis "+str(n)+" lautet: "+str(ergebnis))
if __name__ == "__main__":
summe(10)
summe()
Als Ausgabe erhalten wir:
Die Summe der Zahlen von 1 bis 10 lautet: 55
Die Summe der Zahlen von 1 bis 100 lautet: 5050
Verschiedene Anzahlen von Parametern
Unsere Beispielfunktion summe besitzt genau einen Parameter durch den man angeben kann, bis zu welcher Zahl aufsummiert werden soll. Sehen wir uns nun je ein Beispiel für eine Funktion ohne Parameter und für eine Funktion mit zwei Parametern an:
def hallo():
print("Lasst uns ein paar Summen berechnen!")
def summe(bis, von):
ergebnis = 0
zaehler = von
while zaehler <= bis:
ergebnis = ergebnis+zaehler
zaehler = zaehler+1
print ("Die Summe der Zahlen von "+str(von)+" bis "+str(bis)+" lautet: "+str(ergebnis))
if __name__ == "__main__":
hallo()
summe(10,1)
summe(10,5)
summe(10,9)
Die Funktion hallo benötigt keinen Parameter, da sie nur einen kleinen Text ausgeben soll. Beachte, dass man aber immer die leeren Klammern schreiben muss, um erkennbar zu machen, dass diese Funktion gemeint ist. Die hier verwendete Funktion summebesitzt im Gegensatz zu oben zwei Parameter. Neben dem letzten Summanden kann nun zusätzlich angegeben werden, wo mit dem Addieren begonnen werden soll.
Variable Anzahl von Parametern
Die Verwendung von Standardwerten liefert eine Möglichkeit, die Anzahl der Parameter einer Funktion variabel zu halten. Das soll bedeuten, dass sie mit verschieden vielen Argumenten aufgerufen werden kann.
def summe(bis, von=None):
ergebnis = 0
if von != None:
zaehler = von
else:
zaehler = 1
von = 1
while zaehler <= bis:
ergebnis = ergebnis+zaehler
zaehler = zaehler+1
print ("Die Summe der Zahlen von "+str(von)+" bis "+str(bis)+" lautet: "+str(ergebnis))
if __name__ == "__main__":
summe(10)
summe(10,2)
Dabei steht Nonevereinfacht gesagt dafür, dass das Argument oder die Variable von gar nicht existiert.
Eine weitere Möglichkeit bietet der Sternchen-Operator. Wird dieser eingesetzt, markiert er, dass ein optionales Argument als Tupel behandelt werden soll:
def summe(bis, *weitere_werte):
ergebnis = 0
if len(weitere_werte) > 0:
zaehler = weitere_werte[0]
von = weitere_werte[0]
else:
zaehler = 1
von = 1
while zaehler <= bis:
ergebnis = ergebnis+zaehler
zaehler = zaehler+1
print ("Die Summe der Zahlen von "+str(von)+" bis "+str(bis)+" lautet: "+str(ergebnis))
if __name__ == "__main__":
summe(10)
summe(10,5)
Dies bietet uns weitere Flexibilität:
def summe(bis, *weitere_werte):
ergebnis = 0
schrittweite = 1
if len(weitere_werte) > 0:
zaehler = weitere_werte[0]
von = weitere_werte[0]
if len(weitere_werte)>1:
schrittweite = weitere_werte[1]
else:
zaehler = 1
von = 1
while zaehler <= bis:
ergebnis = ergebnis+zaehler
zaehler = zaehler+schrittweite
print ("Die Summe der Zahlen von "+str(von)+" bis "+str(bis)+" in "+str(schrittweite)+"er-Schritten lautet: "+str(ergebnis))
if __name__ == "__main__":
summe(10)
summe(10,5)
summe(10,1,2)
Wir erhalten diese Ausgabe:
Die Summe der Zahlen von 1 bis 10 in 1er-Schritten lautet: 55
Die Summe der Zahlen von 5 bis 10 in 1er-Schritten lautet: 45
Die Summe der Zahlen von 1 bis 10 in 2er-Schritten lautet: 25
Funktionsaufruf mit Liste von Parametern
Sollten wir eine Liste von Werten vorliegen haben, die wir als Parameter übergeben möchten, können wir dies mit dem Sternchen beim Funktionsaufruf erreichen:
if __name__ == "__main__":
liste = (10,1,2)
summe(*liste)
Schlüsselwortparameter
Die Verwendung von Standardwerten liefert uns auch die Möglichkeit, sogenannte Schlüsselwortparameter zu verwenden:
def summe(bis=100, von=1, schrittweite=1):
ergebnis = 0
zaehler = von
while zaehler <= bis:
ergebnis = ergebnis+zaehler
zaehler = zaehler+schrittweite
print ("Die Summe der Zahlen von "+str(von)+" bis "+str(bis)+" in "+str(schrittweite)+"er-Schritten lautet: "+str(ergebnis))
if __name__ == "__main__":
summe(von=99)
summe(bis=5)
summe(bis=100, schrittweite=5)
Methoden mit Rückgabewert
Alle bisher betrachteten Methoden waren Methoden ohne Rückgabewert. Möchten wir beispielsweise mit der berechneten Summe weiterarbeiten, sollten wir eine Methode mit Rückgabewert verwenden:
def summe(n=100):
ergebnis = 0
zaehler = 1
while zaehler <= n:
ergebnis = ergebnis+zaehler
zaehler = zaehler+1
return ergebnis
if __name__ == "__main__":
erste_summe = summe(10)
zweite_summe = summe(erste_summe)
print(zweite_summe)