Ihr kennt das Konzept der Funktion bereits aus den Übungsaufgaben.
Funktionen (in anderen Programmiersprachen auch Subroutinen oder Prozeduren genannt) sind eine Sammlung von Einzelbefehlen. Sie erlauben
Damit entsprechen Funktionen direkt der DRY-Philosophie.
Eine Reihe von Funktionen gehören zum Grundinventar von Python, andere können wir uns durch das Einbinden von Paketen dazuholen, oder wir machen uns unsere eigenen Funktionen!
Üblicherweise geben Funktionen etwas zurück (in der Funktion gibt es ein return-Statement).
import os
# Die Funktion os.getcwd() gibt das aktuelle Arbeitsverzeichnis zurück
os.getcwd()
import datetime
# Die Funktion datetime.now() gibt die aktuelle Systemzeit zurück
datetime.datetime.now()
import math
# Die Funktion math.sin gibt den Sinus eines Inputs (Radian/Bogenmaß) zurück
math.sin(1)
Am letzten Beispiel sehen wir:
Python erlaubt, die Argumente einer Funktion mit Namen zu versehen:
import random
random.seed(42)
random.uniform(a=1, b=2)
Das Ergebnis ist identisch zu:
random.seed(42)
random.uniform(1,2)
aber unterscheidet sich von
random.seed(42)
random.uniform(b=1, a=2)
Bei unbenannten Argumenten ermittelt Python die Bedeutung der Argumente aus ihrer Reihenfolge. Manchmal erleichtert es die Lesbarkeit des Codes, die Argumente zu benennen.
Eine eigene Funktion, die lästige wiederkehrende Arbeit vereinfacht, könnte so angelegt werden:
# Einfache Funktion ohne Argumente und Rückgabewert
def abwasch():
print("Gläser spülen")
print("Teller spülen")
print("Besteck spülen")
type(abwasch)
Diese Funktionsdefinition enthält den Namen der Funktion (abwasch), das Zuweisungszeichen und ein Schlüsselwort (def) sowie den eigentlich Funktionsrumpf, welcher eingerückt werden muss, wie wir es auch schon von den Blöcken bei if oder den Schleifen kennen.
Nach dem Ausführen des Codes passiert scheinbar zunächst nichts. Aber die Funktion ist nun verfügbar. Wir können uns auch über den Aufruf (mit Klammern) ihres Namens von ihrer Existenz überzeugen:
abwasch()
Da Hausarbeit somit ihren Schrecken verloren hat, wasche doch bitte gleich die dreifache Menge ab!
abwasch()
abwasch()
abwasch()
# oder eleganter:
for i in range(0,3):
abwasch()
Damit die Funktion auf veränderte Bedingungen reagieren kann, sollte sie Eingabedaten über ihre Argumente berücksichtigen:
# Funktion mit Argument
def abwasch2(was_noch):
print("Gläser spülen")
print("Teller spülen")
print("Besteck spülen")
print(was_noch + " spülen")
Lasst uns nun zusätzlich noch Töpfe abspülen! Wie muss der Aufruf der Funktion aussehen?
abwasch2("Töpfe") # Funktion mit Argument benutzen
Noch flexibler wird die Funktion, wenn man ihr einen Vektor von Zeichenketten übergeben kann, von denen jede dann einzeln abgewaschen wird. Wie muss die Funktion erweitert werden?
def abwasch2_viele(was_noch):
print("Gläser spülen")
print("Teller spülen")
print("Besteck spülen")
for teil in was_noch:
print(teil + " spülen")
abwasch2_viele(["Untertassen", "Haare", "Hund"])
Unsere Funktion soll nun ein Ergebnis zurückgeben. In unserem Fall soll dies der Wert sauberkeit sein, die als Zufallszahl gezogen wird. Die Rückgabe des Wertes erfolgt mit dem Befehl return(). Mit diesem wird die Funktion auch verlassen; nachfolgende Befehle werden dann nicht mehr ausgeführt.
#Funktion mit Argument und Rückgabewert
def abwasch3(was_noch=[]):
print("Gläser spülen")
print("Teller spülen")
print("Besteck spülen")
for teil in was_noch:
print(teil + " spülen")
# eine Zufallszahl zwischen 1 und 10
sauberkeit = random.uniform(1,10)
return(sauberkeit)
# Dieser Befehl wird nicht mehr erreicht
print("Spülbecken putzen")
# Funktion mit Argument benutzen, Rückgabewert in Variable speichern
sauberkeit = abwasch3(["Töpfe"])
print("Sauberkeit: " + str(sauberkeit))
Wasche ab, auch die Pfanne. Wenn die Sauberkeit unter 5 ist, gib die Meldung "Abwaschwasser wechseln!" aus, andernfalls melde "Fertig!"
sauberkeit = abwasch3(["Pfanne"])
if sauberkeit < 5:
print("Abwaschwasser wechseln!")
else:
print("Fertig!")
Funktionsargumente können auch optional sein:
range(0,20,3)
print(list(range(0,20,3))) # das dritte Argument gibt die Intervalgröße an.
?range
In der Hilfe zu den Funktionen (?range) werden optionale Argumente mit ihrem voreingestellten Wert aufgeführt. In der selben Art können wir auch für unsere eigene Funktion optionale Argumenten erlauben.
Verändere die Funktion abwasch2() so, dass ihr Argument optional wird. Die entsprechende Ausgabe soll nur erfolgen, wenn das Argument gesetzt ist. Wird ein optionales Argument nicht übergeben, nimmt es den Wert an, der in der Funktionsdeklaration angegeben wurde. In diesem Fall geben wir eine leere Liste als default mit...
def abwasch2_viele(was_noch=[]):
print("Gläser spülen")
print("Teller spülen")
print("Besteck spülen")
for teil in was_noch:
print(teil + " spülen")
# Basisspülprogramm
abwasch2_viele()
# mit Extraspülung
abwasch2_viele(["Toilette"])
Funktionen lassen sich im Hauptprogramm aufrufen, können aber auch innerhalb anderer Funktionen ausgerufen werden. Es ist sogar möglich, dass sich Funktionen selbst aufrufen (rekursive Funktionen).
Schreibe eine Funktion fahr_zu_kelvin(), die die Temperatur von Fahrenheit in Kelvin umrechnet $(T_{Kelv} = ((T_{Fahr} - 32) \cdot (5 / 9)) + 273.15)$!
def fahr_zu_kelvin(temp_f):
temp_k = ((temp_f - 32) * (5 / 9)) + 273.15
return(temp_k)
# Gefrierpunkt von Wasser
fahr_zu_kelvin(32)
# Siedepunkt von Wasser
fahr_zu_kelvin(212)
Schreibe eine Funktion kelvin_zu_celsius(), die die Temperatur von Kelvin in °Celsius umrechnet ($T_{Cels} = ((T_{Kelv} - 273.15$)!
def kelvin_zu_celsius(temp_k):
temp_c = temp_k - 273.15
return(temp_c)
#absoluter Nullpunkt
kelvin_zu_celsius(0)
Schreibe nun eine Funktion, die Fahrenheit in Celsius umrechnet. Verwende dabei die beiden bestehenden Funktionen fahr_zu_kelvin und kelvin_zu_celsius!
def fahr_zu_celsius(temp_f):
temp_k = fahr_zu_kelvin(temp_f)
temp_c = kelvin_zu_celsius(temp_k)
return(temp_c)
# Gefrierpunkt von Wasser
fahr_zu_celsius(32)
Beim LESEN von Variablen (und auch Funktionen) wird i.d.R. "von innen nach außen" ausgewertet. Zuweisungen bleiben lokal (also in der Funktion). Hä?
Ein Beispiel:
X = "externer Wert von X" #eine Zuweisung zur EXTERNEN /globalen Variablen X
Y = "externer Wert von Y" #eine Zuweisung zur INTERNEN Variablen Y
print("Auswertung außen:")
print("X: " + X)
print("Y: " + Y)
def meine_funktion():
X = "interner Wert von X" #eine Zuweisung zur INTERNEN Variablen X
Z ="interner Wert von Z" #eine Zuweisung zur INTERNEN Variablen Z
print("Auswertung innen:")
print("X: " + X)
print("Y: " + Y)
print("Z: " + Z)
meine_funktion()
print(Z)
Das heißt:
X existiert praktisch doppelt, extern und intern. Die innere Zuweisung beeinflusst den Wert außen nicht.Y wird nur außen zugewiesen, ist aber dennoch innerhalb der Funktion lesbarZ wird nur innen zugewiesen. Außerhalb ist sie gar nicht verfügbar (Fehlermeldung).