Kapitel 7: Funktionen (Teil 2): Rekursion, Namensräume, Scopes. Grundlagen der Programmierung 1. Holger Karl. Wintersemester 2016/2017

Transkript

1 Kapitel 7: Funktionen (Teil 2): Rekursion, Namensräume, Scopes Grundlagen der Programmierung 1 Holger Karl Wintersemester 2016/2017 Inhaltsverzeichnis Inhaltsverzeichnis 1 Abbildungsverzeichnis 2 Liste von Definitionen u.ä Überblick Flexible Funktionsparameter und Rückgabewerte Funktionen rufen Funktionen auf Indirekte Rekursion Direkte Rekursion Funktionen und Software-Entwurf

2 7.7 Zusammenfassung Abbildungsverzeichnis 7.1 Variable x wird im globalen Scope gefunden, y referenziert den Wert von x Drei verschiedene Variablen x in drei verschiedenen Scopes Zugriff auf globales x in g; Verdeckung in f Danger, danger! Beim zweiten Aufruf von is_even wird ein weiterer Namensraum angelegt, mit neuen x und y Weitere Aufrufe von is_even und is_odd mit jeweils eigenem Namensraum Bild im Bild Rekursion: Zeichnende Hände Visualisierung der rekursiven Fakultätsberechnung Visualisierung der rekursiven Fakultätsberechnung Rückgabe der Ergebnisse Zeichenkette umkehren Türme von Hanoi: Start Türme von Hanoi: Ziel Türme von Hanoi: Zwischenstand

3 Liste von Definitionen u.ä. 3 Liste von Definitionen u.ä. 7.1 Definition (Scope von Variablen) Definition (Jeder Funktionsaufruf hat einen eigenen Namensraum)

4 4 Liste von Definitionen u.ä. 7.1 Überblick Was bisher geschah Wir haben: Ausdrücke und Anweisungen Variablen als Referenz auf Werte Kontrollstrukturen für Ablauf: if, while, for Funktionen als Zusammenfassung von Anweisungen Definition und Aufruf Dieses Kapitel Wir kehren noch einmal zu Funktionen zurück und betrachten: Aufruf durch flexible Parameter Funktionen rufen andere Funktionen (oder sich selbst) auf Funktionsdefinition innerhalb anderer Funktionen Die Regeln für Namensräume und Scopes 7.2 Flexible Funktionsparameter und Rückgabewerte Erinnerung: Parameter von print An print können Parameter flexibler übergeben werden als an selbst definierte Funktionen: Beliebige Anzahl Parameter können mit Namen versehen werden Wäre das nicht auch für eigene Funktionen praktisch? Erinnerung: Welche formale Parameter bekommen welchen Wert? Mehrere formale Parameter in Funktionsdefinition: Argumente und formale Parameter werden von links nach rechts zugeordnet: a wird zu Namen für Wert von x, b für y, c für z Sogenannte Positionsparameter (positional arguments)

5 7.2. Flexible Funktionsparameter und Rückgabewerte 5 1 def f(a, b, c): 2 # f(x, y, z) Variable Anzahl an Positionsparametern? Bisherige Syntax von def: Feste Anzahl Parameter vorgegeben Erweiterte Syntax: Beliebige Parameteranzahl erlauben Wie Funktionsrumpf die Werte zur Verfügung stellen? * Als Aufzählung! In Funktionsdefinition: einem Parameter einen Stern voranstellen * Häufig: *args als formaler Parametername (nur Konvention!) Nach Stern-Parameter darf kein normaler Parameter folgen Variable Anzahl an Positionsparametern Beispiel 1 def f(a, b, *args): 2 # a und b sind normale Parameter 3 # args ist eine Aufzählung mit ggf. weiteren Parameter 4 print("a:", a, "b:", b) 5 print("anzahl weitere Parameter:", len(args)) 6 print("weitere Parameter:", args) 7 print(" ") 8 9 # f mit zwei Parametern aufrufen: 10 f(1, 2) 11 # f mit zusätzlichen, optionalen Parametern aufrufen: 12 f(3, 4, "a") 13 f(5, 6, "b", 17, "c") 14 # das würde scheitern: 15 # f(1) Formale Parameter mit vorbelegten Werten (default) Möglicherweise haben manche formale Parameter häufig vorkommende, typische Werte (defaults) Die der Funktionsentwickler kennt Und die der Aufrufer nicht jedes Mal neu hinschreiben will Syntax für defaults: Im Funktionskopf default mit = notieren Müssen bei Aufruf nicht vorhanden sein

6 6 Liste von Definitionen u.ä. 1 def f(a, b=42): 2 """Parameter b hat default-wert 42, wenn nicht 3 explizit anders übergeben.""" 4 print("a:", a, end=", ") 5 print("b:", b) 6 7 # Aufruf ohne default-parameter 8 f(1) 9 # Parameter nach Reihenfolge 10 f(2, 3) Argument bei Aufruf benennen Formale Parameter haben Namen Möglicherweise bei Aufruf angenehmer, die Namen zu nennen, statt die Position zu wissen? Sogenannte Schlüssel/Wert-Paare (keyword arguments) Überschreiben ggf. vorhandene default-werte Syntax: Als Zuweisung bei Aufruf Beispiel: 1 def f(a, b=42): 2 print("a:", a, end=", ") 3 print("b:", b) 4 5 # Aufruf nach Position: 6 f(1, 2) 7 # Aufruf mit Nennung der Parameter: 8 f(a=3, b=4) 9 # Bei Nennung der formalen Parameter Reihenfolge unwichtig: 10 f(b=5, a=6) dict als Schlüssel-/Wert-Paare übergeben Keyword arguments: Abbildung von Namen auf Wert Das kennen wir von dict! Kann man ein dict als Folge Schlüssel-Wert-Paaren an Funktion übergeben? Syntax: Ein dict mit zwei vorangestellten Sternen wird als Folge von entsprechenden Argumenten aufgefasst

7 7.2. Flexible Funktionsparameter und Rückgabewerte 7 1 def f(a, b, c): 2 print("a:", a, end=", ") 3 print("b:", b, end=", ") 4 print("c:", c) 5 6 d = { a : 17, b : 42, c : 99} 7 # Kann das funktionieren? 8 # f(d) 9 # Besondere Aufrufssyntax: 10 f(**d) Aufruf mit f(d) Der Aufruf mit f(d) kann natürlich nicht funktionieren. Dabei würde per Reihenfolge der Parameter dem formalen Parameter a der Wert von d zugewiesen. Für die formalen Parameter b und c sind keine Argumente mehr übrig, es gibt keinen default-wert, also scheitert der Funktionsaufruf dict als Schlüssel-/Wert-Paare übergeben Fehlende Schlüssel Was passiert hier, was muss man ändern? 1 def f(a, b, c): 2 print("a:", a, end=", ") 3 print("b:", b, end=", ") 4 print("c:", c) 5 6 d = { a : 17, b : 42} 7 # Besondere Aufrufssyntax: 8 f(**d) Fehlermeldung Die Fehlermeldung ~TypeError: f() missing 1 required positional argument: c ~ weist deutlich auf das Problem hin. Es fehlt ein Wert für den benötigten Parameter c. Also Parameter mit Wert versorgen entweder bei Aufruf oder mit einem default-wert ausstatten und den Parameter damit optional machen dict als Schlüssel-/Wert-Paare übergeben Zu viele Schlüssel? 1 def f(a, b, c): 2 print("a:", a, end=", ")

8 8 Liste von Definitionen u.ä. 3 print("b:", b, end=", ") 4 print("c:", c) 5 6 d = { a : 17, b : 42, c : 99, d : 1} 7 8 # Das scheitert: 9 f(**d) Fehlermeldung ~TypeError: f() got an unexpected keyword argument d ~ auch hier ist die Fehlermeldung deutlich. Es gibt keinen formalen Parameter d, also kann der Aufruf nicht erfolgen. Das entspricht genau einem Aufruf: f(a=17, b=42, c=99, d=1) der genau so scheitern würde dict als Schlüssel-/Wert-Paare übergeben Optionale Schlüssel? Wir brauchen eine Vorkehrung, um beliebige Schlüssel/Wert-Paare aufzunehmen Ähnlich wie bei beliebigen Positionsparametern mit *args Syntax entsprechend angelehnt: In Funktionskopf, einen Parameter mit zwei Sternen versehen * Konvention: oft **kwargs (für keyword arguments) Alle überzähligen Schlüssel-/Wert-Paare werden in diesem Parameter als dict abgelegt 1 def f(a, **kwargs): 2 print("a:", a, end=", ") 3 print("kwargs:", kwargs) 4 5 d = { a : 17, b : 42, c : 99, d : 1} 6 # Besondere Aufrufssyntax: 7 f(**d) Beispiel 1 def f(a, b, *args, **kwargs): 2 if x in kwargs: 3 return args[1], kwargs[ y ] 4 else:

9 7.2. Flexible Funktionsparameter und Rückgabewerte 9 5 return str(len(args)) * kwargs[ z ] 6 7 print(f("hallo", 3, 17, "gp1", **{ y : 17, z : 5})) Zusammenfassung formale Parameter und Argumente Syntax Definitions-Syntax def f(a, b) def f(a=17) def f(*args) def f(**kwargs) Aufruf-Syntax f(x, y) f(a=5) f(*l) f(**d) Interpretation Positionsparameter Parameter mit default Parameter für überzählige Positions-Argumente (als Tuple) Parameter für überzählige benannte Argumente (als Dict) Interpretation Positionsargument Argument explizit benennen Siehe Übungsblatt Dict d ist Liste der benannten Argumente Bemerkung: Python 3 hat noch ein paar weitere Feinheiten; brauchen wir zunächst nicht Tuple als Rückgabewerte Eigentlich selbstverständlich: Tuple sind legale Rückgabewerte Damit einfache Möglichkeit, aus Funktion mehr als einen Wert zurückzugeben return Tuple Automatisches unpacking bei Funktionsaufruf 1 def mehrfache_rueckgabe(): 2 x = 10 3 y = [1, 2, 3] 4 return x, y 5 6 # Tuple entgegennehmen: 7 t = mehrfache_rueckgabe() 8 print("t:", t) 9 # Unpacking des tuples: 10 a, b = mehrfache_rueckgabe() 11 print("a:", a, "b:", b)

10 10 Liste von Definitionen u.ä. ( t:, (10, [1, 2, 3])) ( a:, 10, b:, [1, 2, 3]) 7.3 Funktionen rufen Funktionen auf Funktionen rufen Funktionen auf Bis jetzt: lediglich eine Funktion, die aufgerufen wurde Stimmt nicht ganz: Unsere Funktion hat auch schon die Funktion print aufgerufen Was passiert genau, wenn eine Funktion eine andere aufruft? Insbesondere: Welche Variablen sind sichtbar? Ausführungsmodell Das Ausführungsmodell ist ganz naheliegend Illustration Aufrufende Funktion unterbricht Ablauf bei Aufruf Aufgerufene Funktion wird ausgeführt Rückgabewert nimmt den Platz des Aufrufs in der aufrufenden Funktion ein Aufrufer macht weiter 1 def f(): 2 print("in f, vor g") 3 x = g() 4 print("in f, nach g", "x: ", x) 5 6 def g(): 7 y = 42 8 return y 9 10 f() in f, vor g ( in f, nach g, x:, 42) (PT link)

11 7.3. Funktionen rufen Funktionen auf Beispiel: Matrix ausgeben Beispiel: Zwei Funktionen, um eine Matix auszugeben 1 # eine verschachtelte Liste: 2 matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]] 3 # matrix wollen wir als eine 4x3 Matrix ausgeben 4 5 def print_matrix(m): 6 for zeile in m: 7 print_zeile(zeile) 8 # Neue Zeile 9 print() def print_zeile(z): 12 for c in z: 13 print(c, end=" ") print_matrix(matrix) Beobachtung: Reihenfolge Definition und Aufruf Im Programmcode steht ein Aufruf von print_zeile bevor print_zeile definiert wurde Hier offenbar unproblematisch Weil def print_matrix eine Anweisung ist, die lediglich den Namen der Funktion mit dem Programmcode verbindet Dabei wird noch nichts ausgeführt! Entscheidend ist der Zeitpunkt der Ausführung des Aufrufs! Dann muss der Funktionsname def-iniert worden sein Beobachtung: Reihenfolge Definition und Aufruf Funktionsname vor Aufruf definiert das hier scheitert: Fehlermeldung: NameError: name f is not defined 1 f() 2 3 def f(): 4 print("hallo")

12 12 Liste von Definitionen u.ä Variablen und Sichtbarkeit? Auf welche Variablen kann man in einer Funktion zugreifen? Natürlich auf die selbst zugewiesenen Andere? Sichtbarkeit Variablen außerhalb der Funktion? Beispiel 1: Variable vor Funktionsdefinition zugewiesen 1 x = 5 2 def f(): 3 y = x 4 print(y) 5 f() 5 (PT link) Beispiel 2: Variable nach Funktionsdefinition zugewiesen 1 def f(): 2 y = x 3 print(y) 4 x = 5 5 f() Offenbar sichtbar! Bei Zugriff auf x stellt f fest, dass es kein x im eigenen Scope gibt Dann beginnt Suche: gibt es ein x im Scope des aufrufenden Programmteils? Ja! Dann benutzen wird doch das x! Diese Suche findet während der Ausführung von f statt, nicht während der Definition von f Deswegen ist es hier egal, ob x vor oder nach def Definition von f belegt wird

13 7.3. Funktionen rufen Funktionen auf 13 Visualisierung Abbildung 7.1 zeigt die Situation, nachdem die Funktion f die Variable x im aufrufenden Scope gefunden hat und die eigene Variable y den Wert von x referenziert. Abbildung 7.1: Variable x wird im globalen Scope gefunden, y referenziert den Wert von x Offenbar sichtbar! Beispiel Was wird hier ausgegeben? 1 x = 3 2 def f(): 3 y = x 4 print(y) 5 x = 5 6 f() 7 x = Sichtbarkeit bei schreibendem Zugriff? Funktioniert das hier? Nur minimale Änderung zu oben! 1 x = 5 2 def f(): 3 x = x print(x) 5 f()

14 14 Liste von Definitionen u.ä Scope durch Zuweisung Zuweisung an Variable bestimmt ihren Scope Warum funktioniert das nicht? Die Fehlermeldung: UnboundLocalError: local variable x referenced before assignment gibt einen ersten Hinweis. Offenbar wird die Variable x hier als eine Variable, die lokal zur Funktion ist, aufgefasst. Die Tatsache, dass es eine globale Variable x gibt, spielt jetzt keine Rolle anders als im Beispiel oben. Offenbar liegt der Unterschied zwischen diesen beiden Beispielen daran, dass an die Variable x im zweiten Beispiel zugewiesen wird; im vorherigen Beispiel wird x lediglich gelesen. Damit haben wir einen entscheidenen Punkt erarbeitet: Der Ort einer Zuweisung an eine Variable bestimmt ihren Scope Sichtbarkeit von Variablen zwischen zwei Funktionen? Aufruf von g durch f oben hatte keine Variablen Was passiert, wenn wir das hinzufügen? 1 def f(): 2 x = 17 3 g() 4 5 def g(): 6 z = a 7 z += x 8 print(z) 9 10 a = f() Fehlermeldung In Funktion g: NameError: global name x is not defined Unterschied der beiden Fälle? Offenbar unterschiedliches Verhalten Namen innerhalb oder außerhalb einer Funktion definiert

15 7.3. Funktionen rufen Funktionen auf 15 Namen außerhalb aller Funktionen existieren in einem besonderem Scope: dem global scope Namen innerhalb einer Funktion existieren nur im Scope der Funktion Der local scope der Funktion Local scopes zweier Funktionen haben nichts miteinander zu tun! * Genauer: Die Scopes der Namensräume der Funktionen... * Gleicher Variablenname in unterschiedlichen Scopes: Unterschiedliche Variable! Disjunkte local scopes Beispiel 1 x = def f(): 4 x = 17 5 print("x in f:", x) 6 g() 7 print("x in f:", x) 8 9 def g(): 10 x = print("x in g:", x) f() ( x in f:, 17) ( x in g:, 42) ( x in f:, 17) (PT link) Visualisierung Im obigen Progerammbeispiel tauchen drei verschiedene Variablen auf, die alle x heißen. Sie existieren in drei verschiedenen Kontexten und haben daher nichts miteinander zu tun. Abbildung 7.2 illustriert die Situation, nachdem in Funktion g an x zugewiesen wurde Disjunkte local scopes Beispiel 2 Fast das gleiche Beispiel wie eben Allerdings wird in g nicht an x zugewiesen Was gibt g aus? Erklärung?

16 16 Liste von Definitionen u.ä. Abbildung 7.2: Drei verschiedene Variablen x in drei verschiedenen Scopes 1 x = def f(): 4 x = 17 5 print("x in f:", x) 6 g() 7 print("x in f:", x) 8 9 def g(): 10 print("x in g:", x) f() ( x in f:, 17) ( x in g:, 99) ( x in f:, 17) (PT link) Visualisierung In dieser Variante von g gibt es im lokalen Scope von g keine Variable x. Daher schaut die Funktion g beim Zugriff auf x nach, ob im globalen Scope ein x existiert. Das ist der Fall; also wird dieser Wert (hier: 99) benutzt. Abbildung 7.3 zeigt die Situation nach der Ausgabe des (globalen) x in g. Beachten Sie, dass in f das globale x verdeckt ist durch die Zuweisung an die lokale Variable x.

17 7.3. Funktionen rufen Funktionen auf 17 Abbildung 7.3: Zugriff auf globales x in g; Verdeckung in f Modifizierende Nutzung globaler Variablen Zuweisung erzeugt eine Variable im lokalen Scope Genauer: Im Namensraum des lokalen Scopes Was passiert, wenn eine globale Variable verändert wird? Zuweisung erzeugt lokale Variable Wie oben das hier funktioniert nicht: 1 x = 5 2 def f(): 3 x = x f() Modifikation einer globalen Variable Das hier funktioniert: 1 L = [1, 2] 2 def f(): 3 L.append(3) 4 5 f() 6 print(l) [1, 2, 3]

18 18 Liste von Definitionen u.ä. Beobachtung An L wird nicht zugewiesen, also wird das globale L benutzt Es wird nicht L verändert, sondern das referenzierte Objekt! Modifikation einer globalen Variablen Eigentlich geht das nicht! Funktionen kommunizieren Ergebnisse durch * Rückgabewerte (gut!) * Ggf. durch Veränderung globaler Objekte (zweischneidig!) Aber wenn doch nötig? Abbildung 7.4: Danger, danger! Modifikation einer globalen Variablen Eigenes Schlüsselwort: global Deklariert einen Variablen als dem globalen Scope zugehörig Extrem bedenklich!! Schwer lesbar, schlecht wartbar, unübersichtlich, fehleranfällig,... 1 x = 5 2 def f(): 3 global x 4 x = x f() 7 print(x) 6

19 7.3. Funktionen rufen Funktionen auf Die Gefahr globaler Variablen Die Modifikation globaler Variablen wird durch die Sprache bewusst erschwert Kernproblem: Programm ist nicht mehr verständlich, indem man nur den jeweiligen Ausschnitt betrachtet Beispiel: Welchen Wert hat X? 1 X = 99 2 def func1(): 3 global X 4 X = def func2(): 7 global X 8 X = func2() 11 print(x) Zusammenfassung: Scope von Variablen in Funktionen Definition 7.1 (Scope von Variablen). Der Scope einer Variablen bestimmt sich daraus, wo an diese Variable eine Zuweisung erfolgt. Variablen, an die innerhalb eines def zugewiesen wurde, sind im local scope dieser Funktion Variablen, an die außerhalb aller Funktionen zugewiesen wurde, sind im global scope Referenziert eine Variable im global scope ein Objekt, so kann das Objekt durchaus verändert werden! Auf Variablen im global scope kann von einer Funktion aus nur lesend zugegriffen werden Es sei denn, sie sind vorher durch global deklariert 7.4 Indirekte Rekursion

20 20 Liste von Definitionen u.ä Funktionen rufen sich gegenseitig auf Bisher: f hat g aufgerufen. Und würde g eine Funktion h aufrufen, so ginge das genauso Was passiert, wenn g dann wieder f aufruft? Zwei Fragen: Terminierung? Scope? Wechselseitiger Aufruf: (Inkorrektes) Beispiel 1 def f(): 2 print("f") 3 g() 4 5 def g() 6 print("g") 7 f() 8 9 f() Problem Endlos, terminiert nicht! Wechselseitiger Aufruf: Terminierung Ziel: Stelle sicher, dass die Folge von Aufrufen terminiert Idee: Ähnlich wie Terminierung von Schleifen Finde einen Ausdruck, der mit jedem Ausdruck streng monoton und diskret fällt Zeige, dass Aufrufe enden, wenn Ausdruck einen Wert erreicht (z.b. 0) Wechselseitiger Aufruf: Beispiel Was tut dieses Programm? 1 def is_even(x): 2 print("is_even checks:", x)

21 7.4. Indirekte Rekursion 21 3 if x == 0: 4 return True 5 else: 6 y = x return is_odd(y) 8 9 def is_odd(x): 10 print("is_odd checks:", x) 11 if x == 0: 12 return False 13 else: 14 y = x return is_even(y) result = is_even(5) 18 print(result) ( is_even checks:, 5) ( is_odd checks:, 4) ( is_even checks:, 3) ( is_odd checks:, 2) ( is_even checks:, 1) ( is_odd checks:, 0) False Wechselseitiger Aufruf: Scopes und Namensräume Schauen wir uns die Scopes bzw. Namensräume genauer an: Beide Funktionen is_even und is_odd haben Variablen x und y Diese x und y werden sich gegenseitig verdecken Aber was passiert mit einem x von is_even, wenn is_even erneut aufgerufen wird? Was würden Sie sinnvollerweise erwarten? Wechselseitiger Aufruf: Animation 1 def is_even(x): 2 print("is_even checks:", x) 3 if x == 0: 4 return True 5 else: 6 y = x - 1

22 22 Liste von Definitionen u.ä. 7 return is_odd(y) 8 9 def is_odd(x): 10 print("is_odd checks:", x) 11 if x == 0: 12 return False 13 else: 14 y = x return is_even(y) result = is_even(5) 18 print(result) ( is_even checks:, 5) ( is_odd checks:, 4) ( is_even checks:, 3) ( is_odd checks:, 2) ( is_even checks:, 1) ( is_odd checks:, 0) False (PT link) Animationsschritte Der erste interessante Schritt passiert in diesem Beispiel, wenn is_odd die Funktion is_even mit dem Parameter 3 aufruft. Abbildung 7.5 zeigt, dass dann für den erneuten Aufruf von is_even ein neuer Namensraum angelegt wird, mit separatem x und y. Der Scope dieser beiden neuen Variablen x und y ist aber der gleiche (die gleichen Zeilen im Programmcode!). Dieses Muster setzt sich fort (Abbildung 7.6): jeder Aufruf einer Funktion erhält einen eigenen Namensraum, der mit den Namensraum der anderen Funktionen nichts zu tun hat Zugriff auf Variablen in anderen Namensraum? Im oben Beispiel mit f und g gelang es nicht, auf eine Variable x in einem anderen Namensraum zuzugreifen Geht das hier? Kann eine Funktion is_even auf eine Variable x von sich selbst zugreifen? In einem anderen Namensraum von is_even (allerdings im gleichen Scope)? Nein!

23 7.5. Direkte Rekursion 23 Abbildung 7.5: Beim zweiten Aufruf von is_even wird ein weiterer Namensraum angelegt, mit neuen x und y * Man kann das nicht einmal hinschreiben * Welches x würde man auch meinen? Rekursion und Namensraum Definition 7.2 (Jeder Funktionsaufruf hat einen eigenen Namensraum). Jeder rekursive Funktionsaufruf hat einen eigenen Namensraum. Die Variablennamen in einem Namensraum haben nichts mit Variablennamen in einem anderen Namensraum zu tun, selbst wenn es sich um den gleichen Scope handeln sollte. 7.5 Direkte Rekursion Direkte Rekursion Sonderfall der Rekursion: Eine Funktion ruft sich selbst auf Terminierung sicherstellen! Allgemeiner: Definition nimmt auf sich selbst Bezug Rekursion in der Kunst Abbildung 7.7 illustriert Rekursion.

24 24 Liste von Definitionen u.ä. Abbildung 7.6: Weitere Aufrufe von is_even und is_odd mit jeweils eigenem Namensraum Abbildung 7.7: Bild im Bild Rekursion in der Kunst Abbildung 7.8 illustriert Rekursion Beispiel: Fakultät Definition, nicht-rekursiv Für n 1: fak(n) = Πni=1 i = 1... n

25 7.5. Direkte Rekursion 25 Abbildung 7.8: Rekursion: Zeichnende Hände Definition, rekursiv 1 n = 0 fak(n) = 1 n = 1 n fak(n 1) sonst Beispiel: Fakultät Code 1 def fak(n): 2 if n==1: 3 return 1 4 else: 5 return n*fak(n-1) 6 7 res = fak(5) 8 print(res) 120 (PT link) Visualisierung Abbildung 7.9 zeigt einen Zwischenzustand bei der rekursiven Berechnung der Fakultät. Hier haben alle rekursiven Aufrufe stattgefunden; danach beginnt die Berechnung der Ergebnisse. Den Zustand ein paar Schritte weiter zeigt Abbildung Hier wurden die Teilergebnisse von fak(1), fak(2) und fak(3) berechnet; der Aufruf von fak(3) wird gleich zurückkehren und den Wert 6 zurückgeben.

26 26 Liste von Definitionen u.ä. Abbildung 7.9: Visualisierung der rekursiven Fakultätsberechnung Abbildung 7.10: Visualisierung der rekursiven Fakultätsberechnung Rückgabe der Ergebnisse Randfälle? Was passiert hier? Notwendige Änderungen? 1 fak(0) 2 fak(-5) Fakultät: Scope und Namensraum Um das nochmals zu betonen:

27 7.5. Direkte Rekursion 27 Der Namensraum der einer der lokalen Variable n in einer Funktion fak ist bei jedem Aufruf von fak ein neuer; jeder Aufruf hat einen eigenen Namensraum Der Scope der Variable n ist bei allen Aufrufen von fak der gleiche: die Zeilen Beispiel: String umdrehen Gegeben: Zeichenkette Gesucht: Die Zeichenkette, rückwärts gelesen Rekursive Idee Die einfachen Fälle: Eine leere Zeichenkette rückwärts: die leere Zeichenkette Eine Zeichenkette der Länge 1 rückwärts: die Zeichenkette selbst Die interessanten Fälle: eine längere Kette Nimm das erste Zeichen von der Kette weg Drehe die verkürzte Kette um Hänge das erste Zeichen ans Ende der umkehrten, verkürzten Kette an Beispiel: String umdrehen Code 1 def reverse(s): 2 if len(s)<=1: 3 return s 4 else: 5 first = s[0] 6 rest = reverse(s[1:]) 7 return rest + first 8 9 print(reverse("hallo GP1")) 1PG ollah Visualisierung Hier nur kurz die Visualisierung eines Zwischenstandes, nachdem bereits die ersten Zwischenergebnisse produziert wurden (Abbildung 7.11). Vollziehen Sie dieses Beispiel bitte selbst in nach!

28 28 Liste von Definitionen u.ä. Abbildung 7.11: Zeichenkette umkehren Knapperer Code Der hier angegebenen Code ist nur zur einfacheren Visualisierung etwas weitschweifig. Das kann man knapper wie folgt aufschreiben: 1 def reverse(s): 2 if len(s)<=1: 3 return s 4 else: 5 return reverse(s[1:]) + s[0] 6 7 print(reverse("hallo GP1")) 1PG ollah Rekursion Muster Rekursion beruht auf der Berechnung einfacherer Teilprobleme Zusammensetzen der Lösung dieser Teilprobleme zur Gesamtlösung Ganz einfache Teilprobleme werden direkt gelöst Typisches Muster: 1 def rekursive_funktion(parameter): 2 if (parameter einfach genug für direkte Loesung): 3 return Funktionswert beruhend auf parameter

29 7.5. Direkte Rekursion 29 4 else: 5 Bestimme einfacherere(s) Teilproblem(e) 6 Rufe rekursive_funktion fuer Teilprobleme auf 7 Berechne Funktionswert beruhend auf Loesungen der Teilprobleme Rekursion Entwurf? Wie entwirft man rekursive Algorithmen? Suche einfache Grenzfälle: Für welche Eingaben kann man das Ergebnis direkt angeben? Suche Zerteilung: Wie kann man kompliziertere Eingaben in einfachere Eingaben zerteilen, komplexe Probleme in einfachere Teilprobleme zerlegen? Suche Zusammensetzung: Wie kann man Lösungen der Teilprobleme zur Lösung des Gesamtproblems zusammensetzen? Entwurfsbeispiel: Türme von Hanoi Auf einem Turm liegt ein Stapel Scheiben unterschiedlicher Größe Kleinere Scheiben müssen auf größeren Scheiben liegen Dieser Scheibenstapel soll auf einen anderen Turm transportiert werden Es kann immer nur eine Scheibe bewegt werden Kleinere nur auf größeren, nicht umgekehrt! Es gibt einen dritten Turm, der als Zwischenablage verwendet werden kann Türme von Hanoi Start Abbildung 7.12: Türme von Hanoi: Start Türme von Hanoi Ziel Türme von Hanoi Möglicher Zwischenstand Türme von Hanoi Fragen Also: Grenzfall?

30 30 Liste von Definitionen u.ä. Abbildung 7.13: Türme von Hanoi: Ziel Abbildung 7.14: Türme von Hanoi: Zwischenstand Zerteilung? Zusammensetzung? Türme von Hanoi Code 1 def hanoi(hoehe, von, nach, ablage): 2 if hoehe==1: 3 print("lege Scheibe von", von, "nach", nach) 4 else: 5 hanoi(hoehe-1, von, ablage, nach) 6 print("lege Scheibe von", von, "nach", nach) 7 hanoi(hoehe-1, ablage, nach, von) 8 9 hanoi(3, "start", "ziel", "ablage") ( Lege Scheibe von, start, nach, ziel ) ( Lege Scheibe von, start, nach, ablage ) ( Lege Scheibe von, ziel, nach, ablage ) ( Lege Scheibe von, start, nach, ziel ) ( Lege Scheibe von, ablage, nach, start ) ( Lege Scheibe von, ablage, nach, ziel ) ( Lege Scheibe von, start, nach, ziel ) Wie oft wird eine Scheibe bewegt? Wie könnten wir das mitzählen? Ordentliche Lösung? Unordentlich?

31 7.5. Direkte Rekursion Rekursion oder Iteration? Fakultät lässt sich natürlich auch trivial iterativ (ohne rekursive Funktionsaufrufe) implementieren Häufig: Rekursive Variante einfacher, übersichtlicher Iterative Variante schneller, komplizierter Allgemein: Rekursiv und iterativ ineinander überführbar Wann nimmt man was? Je nach Problem, Struktur, Relevanz der Lösungszeit Vgl. VL Datenstrukturen und Algorithmen Rekursion zur Definition Grundidee der Rekursion auch für Definitionen anwendbar Für Funktionen, wie oben Für Datenstrukturen: Bäume, Listen Für Programmiersprachen: * Eine Anweisung besteht aus... * Ein Ausdruck besteht aus... anderen Ausdrücken! Mehr dazu in VL Modellierung, VL DuA, und im ganzen Rest des Studiums! Rekursion: Realisierung? Jeder Aufruf einer Funktion sei es normal, durch indirekte oder direkte Rekursion hat also einen eigenen Namensraum, eigene Version des Zustands der Funktion Zustand: Werte der Parameter, der lokalen Variablen, des Rückgabewertes Konzeptionell schön, aber wie wird das realisiert? Kernidee: Ein Stapel von Frames Datenstruktur, auf der andere Daten abgelegt werden können Kann wachsen und schrumpfen Stellt Platz für die Namensräume bereit Details: VL GPS 7.6 Funktionen und Software-Entwurf

32 32 Liste von Definitionen u.ä Wie nutzt man Funktionen sinnvoll? Bis jetzt: Syntax und Semantik für Funktionen (Noch nicht vollständig) Aber wie entwirft man Programme sinnvoll? Regel für die Nutzung von Funktionen? Hier: einige erste Faustregeln Später: VL Software-Entwurf Funktionen und Coupling Eingabe mit Argumenten, Ausgabe mit return Funktionen sollten Eingaben nur durch die Argumente erhalten Resultate nur durch return Unabhängig von Werten um die Funktion herum Isolation der Funktion erhöht Wiederverwendbarkeit Globale Variablen nur wenn nicht anders möglich Globale Variablen erzeugen Abhängigkeiten und Komplexität Nur als letzter Ausweg! Funktionen und Coupling (2) Veränderbare Argumente nicht verändern Bekommt eine Funktion veränderbare Typen (Listen, Mengen, Dicts) als Argumente, so sollte sie diese typischerweise nicht verändern Nur, wenn dies der Aufrufer offensichtlich erwarten muss Klar dokumentieren, wenn dies passiert! Meist besser: Veränderte Werte mit return zurückgeben Aufrufer entscheidet, was passiert Funktionen und Kohesion Eine Funktion erledigt genau eine Aufgabe Aufgabe typischerweise in einem knappen Satz beschreibbar Wenn zu kompliziert, zu viele unterschiedliche Aspekte: Funktion in Teilfunktionen aufteilen! Funktionen und Größe Funktion sollte relativ klein sein (Anzahl Code-Zeilen)

33 7.7. Zusammenfassung 33 Faustregel: zwei Bildschirmseiten als Maximum Wenn größer: Funktion in Teilfunktionen aufteilen! 7.7 Zusammenfassung Zusammenfassung Funktionen können Parameter in flexibler Form entgegen nehmen: default-werte, variable Parameteranzahl, Aufruf mit Parameter-Namen Funktionen können beliebige Typen zurückgeben, insbesondere Tuple Nützlich um mehrere unterschiedliche Werte als Resultat zu verwenden Jeder Funktionsaufruf hat einen eigenen Namensraum, in dem Variablennamen lokal existieren Entsteht bei Funktionsaufruf, zerstört bei Funktionsende Der Scope einer Variable ist lexikalisch durch den Ort der Zuweisung an die Variable bestimmt Bei Nutzung einer Variable wird zunächst der lokale, dann der globale Scope besucht Funktionen können direkte oder indirekte Rekursion nutzen Jeweils mit eigenem Namensraum Python-Keywords: Liste bis jetzt Bis jetzt: True, False, and, or, def, return, None in if, else, pass, elif, while, for, break, continue, assert Neu: global