• Definition einer Funktion
  • Lokale Variablen
  • Etwas speziell: Funktionsvariablen
• Parameter
• Parametertypen prüfen
• Vorbelegte Parameter
• Parameter per Namen belegen
• Variable Anzahl von Funktionsparametern
• Rückgabewert
• Rückgabe mehrerer Werte
• Doc-Strings
• Globale und lokale Variablen
• Rekursion
• Übungsaufgaben
• Video

# zähle bis 10
for i in range(1,11,1):
    print(i)
...
# zähle bis 10

Definition einer Funktion

def zaehleBis10():
   for i in range(1,11,1):
       print(i)

...
zaehleBis10()
...
zaehleBis10()

• Vor dem ersten Aufruf muss sie mit def definiert werden.
• Jede Funktion benötigt einen eigenen, eindeutigen Namen. Der wird hinter dem def genannt und über diesen wird die Funktion aufgerufen.
• Ein besonderes Merkmal der Funktion sind die runden Klammern hinter dem Namen. Derzeit enthalten sie nichts, aber das werden wir noch ändern.
• Am Ende der def-Zeile erscheint ein Doppelpunkt und alles, was zur Funktion gehört wird eingerückt. Das kennen Sie schon von Abfragen und Schleifen.
• Egal, wo im Code die Funktion gerufen wird, kehrt der Interpreter nach Beendigung der Funktion zu der Stelle zurück, wo der Aufruf herkam. Keine Sorge, der Interpreter findet immer den richtigen Ort.

Etwas speziell: Funktionsvariablen

Diese Adresse kann wiederum einer anderen Variablen zugewiesen werden, die dann ebenfalls die Adresse der Funktion enthält.

Hängt man dieser Variablen nun ein paar Klammern an, wird die Funktion aufrufen, deren Adresse sie enthält.

Im Augenblick scheint das eher Quatsch zu sein, aber es gibt tatsächlich praktische Anwendungen dafür, beispielsweise, wenn Funktionen als Parameter für einen Rückruf übergeben werden sollen.

def zaehleBis10():
   for i in range(1,11,1):
       print(i)

anders = zaehleBis10
anders() # ruft die Funktion zaehleBis10

Lokale Variablen

Nicht einmal dann, wenn man außerhalb der Funktion eine Variable gleichen Namens verwendet, wird sie durch die Variable in der Funktion verändert.

>>> i = 4
>>> print(i)
4
>>> zaehleBis10()
1
2
...
10
>>> print(i)
4

Parameter

def zaehle(ende):
   for i in range(1,ende+1,1):
       print(i)

zaehle(5)
zaehle(7)

Was mit festen Zahlen funktioniert, funktioniert natürlich auch mit Variablen. Der folgende Aufruf wird zaehle also bis 8 zählen lassen.

anzahl = 8
zaehle(anzahl)

Parametertypen prüfen

Um solche Probleme zu verhindern, kann man den Typ einer Variablen mit der Funktion type prüfen.

def zaehle(ende): 
    if type(ende) in (float, int):
        for i in range(1, ende+1, 1):
            print(i)
    else:
        print("nix")

>>> zaehle(3)
1
2
3
>>> zaehle('Hallo')
nix

Vorbelegte Parameter

Alle vorbelegten Parameter müssen beim Aufruf nicht zwingend angegeben werden. Sie erhalten dann eben den vorbelegten Wert. Die Funktion zaehle() wird nun so verändert, dass der Schritt beim Zählen als weiterer Paramter angegeben werden kann. Ansonsten wird eine Schrittweite von 1 angenommen.

def zaehle(ende, schritt=1):
   for i in range(1,ende+schritt,schritt):
       print(i)

>>> zaehle(3)
1
2
3
>>> zaehle(5, 2)
1
3
5

Parameter per Namen belegen

Dazu wird in der Klammer des Funktionsaufruf eine Zuweisung des Wertes an den Parameternamen durchgeführt.

Schauen wir auf diese Version von zaehle:

def zaehle(start=1, ende=10, schritt=1):
   for i in range(start,ende+schritt,schritt):
       print(i)

Die obige Funktion kann beispielsweise so aufgerufen werden:

>>> zaehle(ende=3)
1
2
3
>>> zaehle(1, 5, schritt=2)
1
3
5

termin(12,5)

termin(monat=12,tag=5)

Variable Anzahl von Funktionsparametern

def calltupel(fest, tupelparameter):
    print(fest)
    for element in tupelparameter:
        print(element)

calltupel(12, (1, "Schau an", 3))

Die andere Variante besteht darin, dass Sie die Tupel-Auflösung im Funktionskopf durchführen und einen Stern vor den Parameter setzen.

def tumehr(fest, *parameter):
    print(fest)  # nicht ueberraschend
    for element in parameter:
        print(element)

tumehr("Fest", 12, "locker")

Rückgabewert

def summiere(ende):
   summe = 0
   for i in range(1,ende+1,1):
       summe += i
   return summe

Summe = summiere(10)
print(summiere(3))

Wird eine Funktion nicht mit return abgeschlossen, wird automatisch return None hinzugefügt.

Rückgabe mehrerer Werte

Stehen hinter dem Befehl return mehrere Werte, die durch Komma getrennt sind, interpretiert Python diese sofort als Tupel.

def gibMalEinDatum():
    return 28,12,1998

>>> datum = gibMalEinDatum()
>>> print(datum)
(28, 12, 1998)
>>> tag, monat, jahr = gibMalEinDatum()
>>> print(monat)
12

Doc-Strings

def doppelt(wert):
    """Die Funktion verdoppelt den übergebenen Wert und gibt ihn zurück"""
    return wert*2

help(doppelt)

Globale und lokale Variablen

Wenn eine Funktion einer globalen Variablen einen Wert zuweisen will, dann entsteht ein Problem. Der Interpreter hält dies für das Anlegen einer lokalen Variablen. Die globale Variable bleibt unverändert.

summe = 0

def summiere(ende):
   summe = 0
   for i in range(1,ende+1,1):
       summe += i

summiere(10)
print(summe)   # Das Ergebnis ist 0!

Andererseits kann es Situationen geben, in denen Sie unbedingt eine Variable außerhalb der Funktion verändern müssen. In diesem Fall können Sie sich helfen, indem Sie die Variale explizit als global deklarieren.

summe = 0

def summiere(ende):
   global summe # Verwende die globale Variable!
   summe = 0
   for i in range(1,ende+1,1):
       summe += i

summiere(10)
print(summe)   # Das Ergebnis ist nun 55!

Rekursion

Da die Funktion nach ihrem Ablauf immer zu dem Punkt zurückkehrt, wo sie aufgerufen wurde, ist es auch möglich, dass sich die Funktion selbst aufruft. Prinzipiell ist das mit einer Schleife vergleichbar. Und wie bei einer Schleife ist es auch bei der Rekursion wichtig, darauf zu achten, dass es eine saubere Abbruchbedingung gibt.

Als einfaches Beispiel soll die rekursive Funktion zählen, allerdings zunächst rückwärts.

def zaehleRekursiv(bis):     # rekursive Funktion
    if bis>0:                # Endebedingung der Rekursion
       print(bis)            # Aktion
       zaehleRekursiv(bis-1) # Selbstaufruf

zaehleRekursiv(3)

Nun aber wird die Abfrage verhindern, dass sich die Funktion selbst aufruft. Stattdessen tut sie nichts weiter und kehrt zu ihrem Selbstaufruf zurück. Dort ist die Variable bis noch 1. Da aber kein Befehl mehr folgt, läuft die Funktion wieder auf ihr Ende, springt zurück zum Selbstaufruf. Dies wiederholt sich, bis die Funktion zu ihrem ersten Aufruf zurückkehrt, der außerhalb der Funktion liegt.

Um nun von 1 bis 3 zu zählen, müssen Sie den print()-Aufruf nur hinter den Selbstaufruf stellen. Dann nämlich ruft sich die Funktion immer wieder selbst auf, bis die Variable bis 0 ist. Sie kehrt dann hinter den Selbstaufruf zurück. Dort ist bis dann 1 und wird per print() ausgegeben. Wieder läuft die Funktion auf ihr Ende, springt hinter den Selbstaufruf und gibt eine 2 aus.

def zaehleRekursiv(bis):     # rekursive Funktion
    if bis>0:                # Endebedingung der Rekursion
       zaehleRekursiv(bis-1) # Selbstaufruf
       print(bis)            # Aktion

zaehleRekursiv(3)

Rekursionen können bestimmte Probleme und Datenstrukturen extrem gut bearbeiten. Ein typisches Beispiel ist das Durchlaufen von Baumstrukturen, wie es die Verzeichnisstruktur einer Festplatte darstellt.

Übungsaufgaben

Fakultät

Dafür kann man eine Funktion schreiben, die n als Parameter übernimmt und das Ergebnis als Rückgabewert zurückgibt.

Größter gemeinsamer Teiler

Ein schönes Verfahren wird bei den Übungsaufgaben für Schleifen dargestellt. Diese werden Sie vielleicht schon gelöst haben.

Nun sollen Sie eine Funktion schreiben, die die beiden Zahlen als Parameter entgegen nimmt und den ggT als Rückgabewert liefert. Der Aufruf könnte dann so lauten:

wert = ggT(42, 36)

Rekursive Fakultät

Video