.. _kapFunktionen:

################################
Funktionen
################################

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 :ref:`Modulen <kapModule>` 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


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.

.. _funcPointset: 

::

	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. 

.. figure:: bilder/2pointsets1.png
	:align:   center

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 .

Schlüsselwortparameter
=======================

Es wurde bereits gezeigt, dass die Funktion :ref:`plot2pointsets() <funcPointset>` 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.
		
Methoden
=========
		
**Methoden** sind Funktionen, die für eine bestimmte Klasse definiert sind. Methoden werden für ein Objekt einer :ref:`Klasse<kapKlassen>`, 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. 

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 :ref:`Klasse<kapKlassen>` 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