3 Funktionsdefinitionen

Transkript

1 3 Funktionsdefinitionen Ziel heute: Programmcode zu wiederverwendbaren Einheiten zusammenpacken und wieder verwenden! Technische Realisierung: Funktionsdefinitionen (mit Teilaspekten Parameterversorgung und Ergebnisrückgabe ) Beispielprogramm: numerische Integration 43

2 Funktionen ohne Parameter und ohne Funktionsergebnis Einfachster Fall: einige Zeilen Code, die ohne weitere Information ausgeführt werden können. Funktion definieren mittels einer Anweisung folgender Form: Ein (sinnfreies) Beispiel: def Funktionsname () : Block def quadrate(): print Ein paar Quadratzahlen: for i in range(1, 5): print %d**2 = %d % (i, i**2) 44

3 Die Anweisungen werden bei Ausführung dieser Funktionsdefinition noch nicht ausgeführt. Das passiert erst bei einem Funktionsaufruf: der Funktionsname, gefolgt von () in einem Ausdruck bewirkt, dass die weitere Auswertung des Ausdrucks unterbrochen wird, statt dessen die Anweisungen des Funktionsrumpfes (der Block) ausgeführt werden, und es dann and der Stelle weitergeht, wo vorhin unterbrochen wurde. Im Moment wird der Ausdruck nur aus dem Funktionsaufruf bestehen, aber das ändert sich bald. So könnten wir die schöne Liste der Quadratzahlen gleich dreimal bestaunen: for i in range(1, 4): quadrate() 45

4 Funktionsparameter Meistens müssen der Funktion noch Informationen mitgegeben werden, was sie genau tun soll, das macht man im Regelfall über Funktionsparameter. Aufschreiben: in das bisher leere Klammerpaar () kommen in der Funktionsdefinition eine durch Kommas getrennte Folge von Variablennamen, die Formalparameter im Funktionsaufruf eine Folge von Ausdrücken, die Aktualparameter, ebenfalls durch Kommas getrennt, genauso viele, wie die Funktionsdefinition Formalparameter hat. (Python hat auch noch andere Varianten für Funktionsparameter, aber die interessieren uns heute nicht.) Beim Funktionsaufruf werden die Ausdrücke der Aktualparameter ausgewertet und die Ergebnisse in ihrer Reihenfolge den Namen der Formalparameter zugewiesen. Im Funktionsrumpf können die dann wie normale Variablen verwendet werden. 46

5 Das Quadratzahlen-Programm könnte nun so aussehen: def quadrate_par(anfang, ende): print Ein paar Quadratzahlen: for i in range(anfang, ende): print %d**2 = %d % (i, i**2) for i in range(1, 4): quadrate_par(i, 2*i) Ausgabe: Ein paar Quadratzahlen: 1**2 = 1 Ein paar Quadratzahlen: 2**2 = 4 3**2 = 9 Ein paar Quadratzahlen: 3**2 = 9 4**2 = 16 5**2 = 25 47

6 Funktionsergebnis Meistens werden die Funktionen nicht irgendwas ausdrucken, sondern etwas berechnen, mit dem wir weiterarbeiten können. Das Standardwerkzeug hierfür ist das Funktionsergebnis. Treffen wir bei der Abarbeitung eines Funktionsaufrufs auf eine Anweisung return Ausdruck so ist die Ausführung der Funktion an dieser Stelle beendet es wird nur noch der Ausdruck ausgewertet. Weiter geht s dann wieder da, wo der Funktionsaufruf die Bearbeitung unterbrochen hatte. Das kann jetzt aber in der Auswertung eines komplizierteren Ausdrucks sein: es wird dann mit dem Wert des return-ausdrucks weitergerechnet. Das ist genau das, was wir brauchen, um z.b. x = sin(y)*cos(z) hinschreiben zu können. 48

7 Beispiel: wir berechnen ende 1 i=anfang i 2. def quadratsum(anfang, ende): sum = 0 for i in range(anfang, ende): sum = sum + i**2 return sum for i in range(1, 4): erg = quadratsum(i, 2*i) print Summe %d**2+...+%d**2 = %d % (i, 2*i-1, erg) Ausgabe (nicht von quadratsum, sondern aus der unteren Schleife!): Summe 1** **2 = 1 Summe 2** **2 = 13 Summe 3** **2 = 50 49

8 Wichtiges Prinzip: teile und herrsche! Großes Problem in Teilprobleme zerlegen und die einzeln lösen. Funktionen sind dabei hilfreich: wir sagen dem Benutzer nur, was sie berechnet, das wie kann ihm ganz egal sein. Im primitiven Beispiel von oben könnte die Quadratsumme z.b. auch so implementiert sein, das würde der Benutzer gar nicht merken ( k 1 i=1 i2 = k 3 /3 k 2 /2 + k): def quadratsum2(ende): return (2*ende**3-3*ende**2 + ende)/6 def quadratsum(anfang, ende): return quadratsum2(ende) - quadratsum2(anfang) (Nebenbei: Merkt er vielleicht bei manchen Parameterwerten doch was?) 50

9 Lokale und globale Variablen Eine Zuweisung wie x=7 bindet den Namen (x) an den Wert (7) einige andere Konsruktionen, z.b. ein for oder die Verwendung als Formalparameter, binden ebenfalls Namen an Werte. Frage: für welche Teile des Programms gilt diese Bindung? D.h.: wo können wir über den Namen auf den Wert zugreifen? Vereinfacht gesagt: innerhalb der Funktion, in der die Bindung stattgefunden hat; bei Variablen, die ganz außerhalb von Funktionen definiert wurden, im ganzen Programm. Das i aus quadratsum ist also von außerhalb der Funktion völlig unsichtbar. Es macht daher nichts aus, dass es dort noch eine weitere Variable i gibt, bei beiden sind völlig unabhängig. Variablen, die nur innerhalb einer Funktion leben, heißen lokale Variablen. Variablen, die außerhalb von Funktionen definiert werden (globale Variablen), dürfen hingegen innerhalb der Funktionen verwendet werden. 51

10 Da die Werteübergabe mit Funktionsparametern und -ergebnissen anfangs oft unnötig kompliziert erscheint, ist man manchmal versucht, etwas in diese Art zu schreiben: def quadrate_global(): print Ein paar Quadratzahlen: for i in range(anfang, ende): print %d**2 = %d % (i, i**2) for i in range(1, 4): anfang = i ende = 2*i quadrate_global() Ganz schlechte Idee! Funktioniert hier zwar, aber bei größeren Programmen wird die Lesbarkeit völlig ramponiert... Aber wenn die Parameterlisten unsinnig lang werden? Dann lernen wir eben in den nächsten Wochen, wie man mehrere Dinge in einen Container verpackt und nur noch den bewegen muss. 52

11 Numerische Integration Nun berechnen wir Näherungen für das bestimmte Integral F 1 (f, a, b) := b a f (x) dx für ein f : [a, b] R (das im Folgenden stets als hinreichend oft differenzierbar angenommen wird). Klassische Verfahren zur numerischen Quadratur sind die Newton-Cotes- Formeln, hier betrachten wir zunächst die Trapezregel (Interpolation in den Intervallenden mit einer linearen Funktion): F 1 T := (b a) f (a) + f (b). 2 53

12 Die Simpsonregel entsteht durch Interpolation in Intervallenden und -mitte mit einem Polynom 2. Grades: ) + f (b) ( F 1 S := (b a) f (a) + 4f a+b 2 6. Für den Quadraturfehler der beiden Verfahren gilt: T F 1 M 2 (b a)3 12 S F 1 M 4 (b a) wobei M 2 und M 4 Schranken für die zweite bzw. vierte Ableitung sind: M 2 := sup f (x), x [a,b] M 4 := sup f (4) (x). x [a,b] 54

13 Die Fehlerschranken legen nahe, die Genauigkeit zu erhöhen, indem wir das Intervall [a, b] in Teilintervalle aufteilen und auf jedem von diesen die einfache Regel anwenden. Im einfachsten Fall (n gleich große Teilintervalle der Länge h = (b a)/n) führt das zur summierten Trapezregel ST := h [ f (a) 2 + n 1 i=1 ] f (a + ih) + f (b) 2 bzw. zur Simpson-Summe [ ( ) ( ) ( ) ] SS := h 6 f (a) + 4f a + h 2 + 2f (a + h) + 4f a + 3h f b h 2 + f (b) 55

14 Beim Quadraturfehler müssen wir nun n = (b a)/h Terme aufsummieren, die aber O(h 3 ) bzw. O(h 5 ) sind die Genauigkeit wird mit wachsendem n besser: ST F 1 M 2 12 (b a) h2, SS F 1 M (b a) h4. Verdopplung des Rechenaufwands (h h/2) reduziert die Fehlerschranke auf 1/4 (ST) bzw. 1/16 (SS) hinreichende Glattheit von f war ja vorausgesetzt. 56

15 Definieren wir uns einen Integranden in unserem Fall ist der so einfach, dass wir sofort eine Stammfunktion aufschreiben können. Das machen wir, um die Genauigkeit der summierten Trapezregel messen zu können. import math def f(x): return math.sin(math.pi*x) def f_int(x): return -math.cos(math.pi*x)/math.pi Die summierte Trapezregel besteht aus einer einfachen Schleife; wir verpacken sie in eine Funktion, die als Parameter noch die Intervallgrenzen a und b sowie die Zahl der Teilintervalle n bekommt: def trapez(a, b, n): h = (b-a)/n sum = (f(a)+f(b))/2. for i in range(1,n): sum = sum + f(a + h*i) return sum*h 57

16 Nun berechnen wir mal 1 0 sin(πx) dx näherungsweise für n = 20,..., 2 6 : a_bsp = 0. b_bsp = 1. exakt = f_int(b_bsp) - f_int(a_bsp) for i in range(1,7): n = 2**i t = trapez(a_bsp, b_bsp, n) print %4d %-12.6g %-12.6g % (n, t, exakt-t) N Näherung Fehler Verdopplung von n reduziert den Fehler um einen Faktor 4, vgl. Folie

17 Hatte ich mich nicht gerade gegen die Verwendung globaler Variablen ausgesprochen? Und jetzt wird eine verwendet, wenn auch nicht ganz offensichtlich: der Integrand f wäre in einem guten Quadraturprogramm ein Parameter von trapez und keine global an den Namen f gebundene Funktion. Ist in Python leicht zu reparieren Funktionen können hier ohne weiteres als Parameter übergeben werden: import math def trapez(f, a, b, n): h = (b-a)/n sum = (f(a)+f(b))/2. for i in range(1,n): sum = sum + f(a + h*i) return sum*h print trapez(math.sin, 0., math.pi, 16) 59

18 Selber machen! Simpson-Summe ausprogrammieren, in der Auswertung (Folie 58) zwei neue Spalten mit Ergebnis und Fehler anfügen. Mit Folie 56 vergleichen! Ausprobieren, was Trapez- und Simpsonsumme ergeben für π 0 x 1 3 dx. Hier darf man faul sein und die Stammfunktion nicht ausprogrammieren, sondern statt dessen mit der Simpsonsumme und vielen Telintervallen einen Referenzwert berechnen. Und nun noch 2π 0 e sin(x) dx. Was unterscheidet dise Funktion von den anderen? Tipp: sie verliert ihre magischen Fähigkeiten, wenn man sie in Stücke schneidet, d.h., das Integral z.b. nur von 0 bis 1 berechnet. 60