5. Funktionen

5.1. Definition von Funktionen

Funktionen werden in Python mit dem Schlüsselwort def eingeleitet. Danach folgt der Funktionsname an den unmittelbar angeschlossen innerhalb von runden Klammern die Liste der Funktionsparameter folgt. Die runden Klammern sind zwingend erforderlich, auch wenn keine Parameter übergeben werden. Nach dieser Kopfzeile folgt der Funktionskörper, der durch die Anweisungen gebildet wird. Alle Anweisungen müssen eingerückt sein. Nach dem Schlüsselwort return folgt die Variable, deren Wert dem aufrufenden Programm zurückgeliefert wird. Wenn nach return kein Ausdruck steht, und wenn return ganz fehlt, liefert die Funktion None zurück:

import math
def eukliddist(pointA,pointB):
        ''' Diese Funktion berechnet die euklidische Distanz zwischen zwei Punkten beliebiger Dimension.'''
        mindim=min(len(pointA),len(pointB))
        sum=0
        for i in range(mindim):
                sum+=math.pow(pointA[i]-pointB[i],2)
        return math.sqrt(sum)

Es ist üblich Funktionen in Modulen zu definieren und diese dann in die Module, in denen sie gebraucht werden, zu importieren. Im obigen Beispiel ist ein derartiger Import schon enthalten. Die Funktion eukliddist() greift auf Funktionen zu, die in der Datei math.py definiert sind. Diese Datei ist in der Python Standardbibliothek enthalten und stellt eine Vielzahl mathematischer Funktionen bereit.

Angenommen die oben definierte Funktion eukliddist() ist in der Datei funktionenbeispiele1.py definiert, dann kann auf diese aus einer Datei mit dem folgenden Listing zugegriffen werden.:

import funktionenbeispiele1 as fbsp
a=range(1,4)
b=range(3,6)
d=fbsp.eukliddist(a,b)
print 'Koordinaten des ersten Punkts:    ',a
print 'Koordinaten des zweiten Punkts:   ',b
print '----------------------------------------------'
print 'Distanz zwischen den Punkten:     ',d

Die Ausführung dieses kleinen Programms erzeugt die Ausgabe:

Koordinaten des ersten Punkts:     [1, 2, 3]
Koordinaten des zweiten Punkts:    [3, 4, 5]
----------------------------------------------
Distanz zwischen den Punkten:      3.46410161514

5.2. Standardwerte für Funktionen

Funktionsargumente können mit Standardwerten belegt werden. Beim Funktionsaufruf müssen diesen, mit Standardwerten versehenen Argumenten, nicht zwingend Parameter übergeben werden. Als Beispiel betrachten wir folgende Funktion, die zwei Punktmengen ps1 und ps2 in einem 2-dimensionalen Plot grafisch anzeigt. Die beiden Punktmengen werden mit unterschiedlichen Markern dargestellt. Für die zwei verschiedenen Marker können sowohl Farbe (col) als auch Form (mark) als Parameter der Funktion übergeben werden.

from matplotlib import pyplot as plt
def plot2pointsets(ps1,ps2,col1='b',mark1='o',col2='r',mark2='s',marksize=10):
        plt.grid(True)
        plt.hold(True)
        m1=col1+mark1
        m2=col2+mark2
        xvals=[]
        yvals=[]
        for a in ps1:
                xvals.append(a[0])
                yvals.append(a[1])
        plt.plot(xvals,yvals,m1,markersize=marksize)
        xvals=[]
        yvals=[]
        for a in ps2:
                xvals.append(a[0])
                yvals.append(a[1])
        plt.plot(xvals,yvals,m2,markersize=marksize)
        plt.title("2 Pointsets")
        plt.xlabel("x")
        plt.ylabel("y")
        plt.show()

Da jedoch die Argumente für die Markersymbole mit Standardwerten vorbelegt sind, können der Funktion auch nur die zwei darzustellenden Punktmengen übergeben werden. Dann werden die definierten Standardwerte benutzt. Im Beispiel ist das Symbol für die erste Punktmenge ps1 ein blauer (b) Kreis (o) und das Symbol für die Punkte in ps2 ein rotes (r) Quadrat (s).

Wird die Funktion nun mit der Anweisungsfolge:

import funktionenbeispiele1 as fbsp
p1=[[-1,-0.5],
        [-1.5, 0.8],
        [-2,0.5],
]
p2=[[1,1.5],
        [2.5, 1.8],
        [2,-0.8],
]
fbsp.plot2pointsets(p1,p2,'m','v','y','h')

aufgerufen, dann werden als Marker Dreiecke (v) in der Farbe Magenta (m) und Hexagone (h) in der Farbe Gelb (y) benutzt. Da kein Argument dem Parameter marksize zugewiesen wird, wird als Markergröße einfach der voreingestellte Standardwert von 10 benutzt.

Der Funktionsaufruf in der letzten Zeile kann jedoch auch mit nur 2 Parametern durchgeführt werden:

fbsp.plot2pointsets(p1,p2)

In diesem Fall werden die in der Funktionsdefinition festgelegten Standardwerte für die Marker verwendet. Mehr Information zur grafischen Ausgabe mit Matplotlib liefert http://matplotlib.sourceforge.net/index.html .

5.3. Schlüsselwortparameter

Es wurde bereits gezeigt, dass die Funktion plot2pointsets() mit einer unterschiedlichen Anzahl von Parametern aufgerufen werden kann. Bisher wurden aber immer nur die Parameter am Ende der Parameterliste weggelassen. Soll bei der Übergabe eine beliebige Untermenge von Parametern zugwiesen werden, dann muss beim Aufruf der Name des Parameters, dem das jeweilige Argument zu übergeben ist, angeführt werden. Die Beispielfunktion kann damit auch wie folgt aufgerufen werden:

fbsp.plot2pointsets(p1,p2,marksize=12)

Damit werden die definierten Standard-Markersymbole benutzt, jedoch größer als in der Voreinstellung.

5.4. Methoden

Methoden sind Funktionen, die für eine bestimmte Klasse definiert sind. Methoden werden für ein Objekt einer Klasse, für die die Funktion definiert ist, aufgerufen, z.B. obref.methode(). Hier ist obref eine Referenz auf ein Objekt einer Klasse, für die methode() definiert ist.

5.5. Globale und lokale Variablen

Variablen, die innerhalb von Funktionen definiert werden sind lokale Variablen. Diese sind nur innerhalb der Methode sichtbar und existieren nur solang wie die Methode ausgeführt wird. Variablen, die innerhalb von Klassen definiert werden sind entweder Klassenattribute oder Instanzattribute und werden in Klasse beschrieben. Variablen, die weder innerhalb von Klassen noch innerhalb von Funktionen definiert werden, heißen globale Variablen. Sie sind im ganzen Modul sichtbar, also auch in den Funktionen des Moduls wie folgendes Beispiel demonstriert:

def testfunc():
        a="lokal"
        print "In Funktion:  a=",a
        print "In Funktion:  b=",b
b="global"
testfunc()

Das Programm erzeugt die Ausgabe:

In Funktion:  a= lokal
In Funktion:  b= global

Der globale Parameter b ist in der Funktion lesbar.

Folgendes Beispiel zeigt, dass der globale Parameter b nicht ohne Weiteres in einer lokalen Funktion verändert werden kann:

def testfunc():
        b="globalInFunc"
        a="lokal"
        print "In Funktion:  a=",a
        print "In Funktion:  b=",b
b="global"
testfunc()
print b

Das Programm erzeugt die Ausgabe:

In Funktion:  a= lokal
In Funktion:  b= globalInFunc
Ausserhalb:   global

Zu beachten ist, dass innerhalb der Funktion nicht die globale Variable b verändert wird. Stattdessen wird ein neues String-Objekt innerhalb der Funktion erzeugt und einer lokalen Variablen b zugewiesen. Das neue String-Objekt existiert nur für die Ausführungsdauer der Funktion. Die globale Variable b wurde nicht verändert.

Es ist jedoch auch möglich innerhalb einer Funktion eine globale Variable zu verändern, hierzu muss aber diese globale Variable innerhalb der Funktion explizit mit global gekennzeichnet werden:

def testfunc():
        global b
        b="globalInFunc"
        a="lokal"
        print "In Funktion:  a=",a
        print "In Funktion:  b=",b
b="global"
testfunc()
print b

Die Ausgabe des Programms zeigt, dass jetzt tatsächlich die globale Variable innerhalb der Funktion verändert wurde:

In Funktion:  a= lokal
In Funktion:  b= globalInFunc
Ausserhalb:   globalInFunc