2.3.3. Funktionen

Funktionen werden verwendet um Anweisungsgruppen zu kapseln. Diese Gruppen bilden eine übergreifende Funktionalität ab und können so zur besseren Lesbarkeit des Skripts beitragen, da die darin enthaltenen Anweisungen nicht jedes Mal aufgeführt werden müssen. Da Funktionen an verschiedenen Stellen aufgerufen werden, aber nur einmal definiert werden müssen, müssen Fehlerbehebungen oder Verbesserungen nur an einer einzigen Stelle implementiert werden.

Definition

Das Schlüsselwort def leitet die Funktionsdefinition ein. Es wird gefolgt vom Funktionsnamen und den Funktionsargumenten, welche in runden Klammern () eingeschlossen sind. Der Funktionskopf wird mit einem Doppelpunkt : beendet. Wie bei den anderen Programmierelementen, wird der Anweisungsblock der Funktion eingerückt. Jede Funktion liefert einen Rückgabewert, welche durch das Schlüsselwort return an die aufrufende Stelle zurückgegeben wird.

def Funktionsname(Argument1, Argument2):
    Anweisungsblock
    return Rückgabewert

Damit die Funktion verwendet werden kann, muss ihre Definition ausgeführt werden.

Folgende Beispiele verdeutlichen die Definition von Funktionen.

# Beispiel 1: Summe der Quadrate

# Definition einer Funktion zur Berechnung der Summe der Quadrate von zwei Argumenten
def sum_quadrate(a, b):
    print('Wert Argument a', a)
    print('Wert Argument b', b)
    summe = a**2 + b**2
    return summe

print( "Summe der Quadrate", sum_quadrate(5, 6) )
print( "Summe der Quadrate", sum_quadrate(1, 2) )
print( "Summe der Quadrate", sum_quadrate(-2, -3) )

Wert Argument a 5
Wert Argument b 6
Summe der Quadrate 61
Wert Argument a 1
Wert Argument b 2
Summe der Quadrate 5
Wert Argument a -2
Wert Argument b -3
Summe der Quadrate 13

# Beispiel 2: Summe einer Werteliste

# Definition der Funktion, mit einem Argument
def sum_liste(liste):
    summe = 0
    for el in liste:
        summe += el
    return summe

l1 = [5, 9, 2, 44, 2, 3, -50]

print( "Liste: ", l1 )
print( "Summe der Elemente: ", sum_liste(l1) )
print()

l2 = [[11, 22], [1, 2, 3, 4], [-10, -20, -30]]
for l in l2:
    summe = sum_liste(l)
    print( "Die Summe der Liste", l, "beträgt ", summe)

Liste:  [5, 9, 2, 44, 2, 3, -50]
Summe der Elemente:  15

Die Summe der Liste [11, 22] beträgt  33
Die Summe der Liste [1, 2, 3, 4] beträgt  10
Die Summe der Liste [-10, -20, -30] beträgt  -60

Optionale Argumente

Funktionen können auch optionale Argumente haben. Werden diese nicht beim Funktionsaufruf übergeben, so werden die für sie vorgesehenen Standardwerte verwendet.

Beispielhaft könnte in der obigen Funktion die Potenz als optionales Argument aufgeführt werden. Falls es nicht explizit aufgeführt wird, soll der Wert 2 angenommen werden.

# Beispiel 3: Summe mit variabler Potenz 

# Definition einer Funktion zur Berechnung der Summe der Quadrate von zwei Argumenten
def sum_potenz(a, b, p=2):
    print('Wert Argument a', a)
    print('Wert Argument b', b)
    print('Wert Argument p', p)
    summe = a**p + b**p
    return summe

print( "Summe der Quadrate", sum_potenz(5, 6) )
print( "Summe der Quadrate", sum_potenz(1, 2, 5) )
print( "Summe der Quadrate", sum_potenz(-2, -3, 1) )

Wert Argument a 5
Wert Argument b 6
Wert Argument p 2
Summe der Quadrate 61
Wert Argument a 1
Wert Argument b 2
Wert Argument p 5
Summe der Quadrate 33
Wert Argument a -2
Wert Argument b -3
Wert Argument p 1
Summe der Quadrate -5

Gibt es mehrere optionale Argumente, so kann der Argumentname verwendet werden um die Zuweisung durchzuführen. Dies ist grundsätzlich immer und bei allen Argumenten möglich.

# Beispiel 4: Summe Liste mit optionaler Ausgabe und optionalem Faktor

# Funktionsdefinition
def sum_liste_faktor(liste, faktor=1, ausgabe=False):
    # liste: Liste von Elementen, welche addiert werden
    # faktor: Zahl mit welcher alle Elemente vor der Addition multipliziert werden
    # ausgabe: soll eine Ausgabe der Zwischenschritte erfolgen?
    
    if ausgabe:
        print("Funktionsargumente: ", liste, faktor, ausgabe)
        
    summe = 0
    for el in liste:
        summe = summe + faktor * el
        if ausgabe:
            print("Zwischensumme: ", summe)
        
    if ausgabe:
        print("Endsumme: ", summe)
    return summe

l1 = list(range(11))

res = sum_liste_faktor(l1)
print("Ausgabe Rückgabewert der Funktion: ", res)

Ausgabe Rückgabewert der Funktion:  55

# Aufruf, mit dem optionalen Parameter ausgabe
res = sum_liste_faktor(l1, ausgabe=True)
print("Ausgabe Rückgabewert der Funktion: ", res)

Funktionsargumente:  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 1 True
Zwischensumme:  0
Zwischensumme:  1
Zwischensumme:  3
Zwischensumme:  6
Zwischensumme:  10
Zwischensumme:  15
Zwischensumme:  21
Zwischensumme:  28
Zwischensumme:  36
Zwischensumme:  45
Zwischensumme:  55
Endsumme:  55
Ausgabe Rückgabewert der Funktion:  55

# Aufruf, bei dem alle Argumente explzit benannt werden
res = sum_liste_faktor(liste = l1, ausgabe = True, faktor = 2)
print("Ausgabe Rückgabewert der Funktion: ", res)

Funktionsargumente:  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 2 True
Zwischensumme:  0
Zwischensumme:  2
Zwischensumme:  6
Zwischensumme:  12
Zwischensumme:  20
Zwischensumme:  30
Zwischensumme:  42
Zwischensumme:  56
Zwischensumme:  72
Zwischensumme:  90
Zwischensumme:  110
Endsumme:  110
Ausgabe Rückgabewert der Funktion:  110

Rückgabewerte

Wird der Anweisungsblock beendet, ohne einen expliziten Aufruf von return, so wird None zurückgegeben. Der Aufruf von return kann an einer beliebigen Stelle im Anweisungsblock erfolgen, womit die Funktion an der entsprechenden Stelle beendet wird.

Es ist möglich auch mehrere Werte zurückzugeben. Dazu werden diese mit einem Komma getrennt und als Tupel an die aufrufende Stelle zurückgegeben. Die Aufteilung dieses Tupels kann, wie im folgenden Beispiel gezeigt, direkt nach Rückgabe erfolgen.

# Beispiel 5: Mehrere Rückgabewerte

def umrechnung_laenge(laenge):
    # laenge: Länge in Meter
    
    # Kilometer
    km = laenge / 1000
    
    # Meile
    mi = laenge / 1482
    
    # Fuß
    fu = laenge / 0.3048
    
    return km, mi, fu

res = umrechnung_laenge(1500)
# Ausgabe des Rückgabewerts, hier ein Tupel
print("Rückgabewert:", res)
# Aufteilung des Tupels für individuelle Ausgabe
print('aufgeteilt:', res[0], 'km,', res[1], 'mi,', res[2], 'fuss')

Rückgabewert: (1.5, 1.0121457489878543, 4921.259842519685)
aufgeteilt: 1.5 km, 1.0121457489878543 mi, 4921.259842519685 fuss

k, m, f = umrechnung_laenge(150)
print('aufgeteilt:', k, 'km,', m, 'mi,', f, 'fuss')

aufgeteilt: 0.15 km, 0.10121457489878542 mi, 492.1259842519685 fuss

Ist die Anzahl der Elemente, welche zurückgegeben werden sollen nicht fest, können Listen zurückgegeben werden. Am folgenden Beispiel wird dies verdeutlicht.

# Beispiel 6: Summe benachbarter Listenelemente

# Definition einer Funktion, welche paarweise die Summe von Elementen bildet und diese zurückgibt
def paar_summe(liste):
    
    # prüfe ob die Liste eine gerade Anzahl an Elementen hat
    if len(liste) % 2 != 0:
        print('Die übergebene Liste hat eine ungerade Anzahl von Elementen\n  -- kann Funktion nicht ausführen.')
        return
    
    summen_liste = []
    for i in range(len(liste) // 2):
        summe = liste[2*i] + liste[2*i + 1]
        summen_liste.append(summe)
        
    return summen_liste

l2 = list(range(10))
print('Liste', l2)
res = paar_summe(l2)
print('Rückgabewert:', res)

Liste [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Rückgabewert: [1, 5, 9, 13, 17]

l3 = list(range(11))
print('Liste', l3)
res = paar_summe(l3)
print('Rückgabewert:', res)

Liste [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Die übergebene Liste hat eine ungerade Anzahl von Elementen
  -- kann Funktion nicht ausführen.
Rückgabewert: None