Kapitel 11: Funktionen (Teil 3): Verschachtelung und funktionale Programmierung. Grundlagen der Programmierung 1. Holger Karl

Transkript

1 Kapitel 11: Funktionen (Teil 3): Verschachtelung und funktionale Programmierung Grundlagen der Programmierung 1 Holger Karl Wintersemester 2016/2017 Inhaltsverzeichnis Inhaltsverzeichnis 1 Abbildungsverzeichnis 2 Liste von Definitionen u.ä Überblick Verschachtelte Funktionen Closures Anonyme Funktionen: lambda-ausdrücke Funktionaler Programmierstil Generatoren Decorators

2 11.8 Zusammenfassung Abbildungsverzeichnis 11.1 Verschachtelte Funktionen, Anlegen der äußeren Funktion Verschachtelte Funktionen, Anlegen der inneren Funktion Verschachtelte Funktionen, Aufruf der inneren Funktion Effekt von nonlocal Nachschlageregel LEGB Aufruf einer Funktion, die als Funktionsergebnis bekannt wurde Zurückgegebene Funktion mit Parameter: Vor Aufruf Zurückgegebene Funktion mit Parameter: Im Aufruf Zwei Closures LISP Popularität reiner funktionaler Sprachen Master of a tiny universe Liste von Definitionen u.ä Definition (Nachschlageregel für Namen: LEGB) Definition (Closure) Definition (λ-ausdrücke: lambda) Definition (Das Decorator-Muster)

3 11.1. Überblick Überblick Was bisher geschah Wir haben uns grundlegende Techniken zur Gestaltung und Nutzung von Funktionen angeschaut Wir haben Funktionen im Kontext von Klassen als Methoden verwendet (eine Funktion, die an/mit einem Objekt arbeitet) Wir haben angedeutet, dass eine Funktion eigentlich auch nur ein Objekt (von einem recht speziellen Typ) ist Dieses Kapitel Wir erweitern die Möglichkeiten, wie man mit Funktionen arbeiten kann Insbes. die Vorstellung, dass eine Funktion ein Objekt ist, auf das man eine Referenz erzeugen und herumreichen kann Darauf aufbauend erarbeiten wir typische Programmiertechniken zur funktionalen Programmierung 11.2 Verschachtelte Funktionen Vorüberlegung: def ist eine Anweisung def ist eine Anweisung, die eine Funktion mit einem Namen versieht Der Code der Funktion wird intern abgelegt In einem Objekt einer geeigneten Klasse gespeichert Im Block einer Funktion stehen Anweisungen Darf dann dort auch ein def stehen? def in Funktionsblock Syntaktisch geht das natürlich Semantik? 2 print("f1") 3 4 def g(): 5 print("g!")

4 4 Liste von Definitionen u.ä. 6 7 g() 8 print("f2") 9 10 f() 11 print("nach f") f1 g! f2 nach f (PT link) def in Funktionsblock: Semantik Bei geschachtelter Funktionsdefinition: Der Name der inneren Funktion ist im Namensraum der äußeren Funktion nach Ausführung der inneren def-anweisung bekannt Dieser Name kann wie jeder andere Funktionsname auch zum Aufruf benutzt werden Nach Rückkehr der äußeren Funktion verschwindet der Name g Im Beispiel: damit ist diese Funktion auch nicht aufrufbar! Visualisierung 1. Erzeugen von f Mit Ausführung der def-anweisung in Zeile 1 wird das Objekt für die Funktion f angelegt und der Name f (im globalen Namensraum) referenziert es. Abbildung 11.1 zeigt diesen Zustand. Abbildung 11.1: Verschachtelte Funktionen, Anlegen der äußeren Funktion

5 11.2. Verschachtelte Funktionen 5 2. Erzeugen von g Abbildung 11.2 zeigt den nächsten Schritt. Nach dem Aufruf von f wird in f selbst die Zeile 4 ausgeführt. Dadurch wird ebenfalls ein Objekt für eine Funktion angelegt. Dieses Objekt unterscheidet sich (zunächst) nicht besonders von einem Funktionsobjekt, dass im globalen Scope erzeugt wurde (aber siehe später Abschnitt 11.3). Für dieses Objekt wird der Name g vereinbart; dieser Name existiert nur im Namensraum von f (präziser: im Namensraum des ersten Aufrufs von f, in der Abbildung als f1 angegeben f1 steht hier für Frame 1, nicht für Funktion f). Abbildung 11.2: Verschachtelte Funktionen, Anlegen der inneren Funktion 3. Aufruf von g aus f heraus Der eigentlich Aufruf von g aus f heraus (Zeile 7) ist dann ein ganz normaler Funktionsaufruf; hier passiert nichts außergewöhnliches (Abbildung 11.3). Dass es sich um eine Funktion handelt, die in f vereinbart wurde und dass der Name g nur im lokalen Namensraum bekannt ist, spielt dabei keine Rolle. Abbildung 11.3: Verschachtelte Funktionen, Aufruf der inneren Funktion

6 6 Liste von Definitionen u.ä Verschachtelte Funktionen: Argumente, Rückgabewert Argumentübergabe und Rückgabewert funktionieren ganz normal 2 def g(x): 3 print(x+1) 4 return x y = g(17) 7 print(y) 8 9 f() Verschachtelte Funktionen: Zugriff auf Variablen? Wie funktioniert der Zugriff auf Variablen außerhalb des eigenen Namensraum aus einer inneren Funktion heraus? Im wesentlichen: Regeln wie bisher Zugriff auf globale Variablen, lesend Ohne besondere Vorkehrungen, wenn nur lesen 2 def g(): 3 print(x) 4 g() 5 6 x = 1 7 f() Zugriff auf globale Variablen, schreiben Schreibender Zugriff: Erfordert Deklaration mit global

7 11.2. Verschachtelte Funktionen 7 2 def g(): 3 global x 4 x = x print(x) 6 g() 7 8 x = 1 9 f() Zugriff auf Variablen der äußeren Funktion? global? Spannender Punkt: Was ist mit Variable, die nicht global, aber in der äußeren Funktion vereinbart ist? Zugriff mit global? 2 def g(): 3 global x 4 x = x print(x) 6 x = 1 7 g() 8 9 f() Fehlermeldung Das scheitert: Es gibt kein globales x, also kann der Zugriff hier nicht gelingen. 1 Traceback (most recent call last): 2 File "<stdin>", line 9, in <module> 3 File "<stdin>", line 7, in f 4 File "<stdin>", line 4, in g 5 NameError: name x is not defined

8 8 Liste von Definitionen u.ä Zugriff auf Variablen der äußeren Funktion? Direkt? 2 def g(): 3 x = x print(x) 5 x = 1 6 g() 7 8 f() Fehlermeldung Scheitern ist plausibel: Nach bisherigen Regeln wird im lokalen Namensraum von g gesucht; dort gibt es kein x. Also Fehler. 1 Traceback (most recent call last): 2 File "<stdin>", line 8, in <module> 3 File "<stdin>", line 6, in f 4 File "<stdin>", line 3, in g 5 UnboundLocalError: local variable x referenced before assignment Zugriff auf Variablen der äußeren Funktion Reihenfolge? Liegt es vielleicht an der Reihenfolge? Im Beispiel eben war bei der Definition von g die Variable x noch gar nicht existent Muss es das x schon geben, wenn g definiert wird? Damit g darauf zugreifen kann? 2 x = 1 3 def g(): 4 print(x) 5 g() 6 7 f() 1

9 11.2. Verschachtelte Funktionen 9 Ja! Offenbar wird auch der Namensraum einer umschließenden Funktion durchsucht! Modifizierender Zugriff auf Variablen der äußeren Funktion? Kann man solche umschließenden Variablen auch verändern? 2 x = 1 3 def g(): 4 x += 1 5 print(x) 6 g() 7 8 f() Offenbar nein Das ist analog zur Situation bei global Fehlermeldung 1 Traceback (most recent call last): 2 File "<stdin>", line 8, in <module> 3 File "<stdin>", line 6, in f 4 File "<stdin>", line 4, in g 5 UnboundLocalError: local variable x referenced before assignment Neues Schlüsselwort: nonlocal Analog zu global: Neues Schlüsselwort, um umschließende Variablen zu verändern nonlocal Unterschied zu global: Die Variable muss schon existieren! (durch Zuweisung, siehe oben) 2 x = 1 3 def g():

10 10 Liste von Definitionen u.ä. 4 nonlocal x 5 x += 1 6 print(x) 7 g() 8 9 f() Beispiel: Tiefere Verschachtelung (1) 2 x = 1 3 def g(): 4 def h(): 5 nonlocal x 6 x += 1 7 print("x in h:", x) 8 h() 9 print("x in g:", x) 10 g() 11 print("x in f:", x) f() x in h: 2 x in g: 2 x in f: Beispiel: Tiefere Verschachtelung (2) 2 x = 1 3 def g(): 4 x = 42 5 def h(): 6 nonlocal x 7 x += 1 8 print("x in h:", x) 9 h() 10 print("x in g:", x)

11 11.2. Verschachtelte Funktionen g() 12 print("x in f:", x) f() x in h: 43 x in g: 43 x in f: 1 (PT link) Anmerkung: x aus f? Es gibt keine Möglichkeit, von h aus auf das von f angelegte x zuzugreifen. Dieses x wird durch das x von g verdeckt! Visualisierung Es lohnt sich, hier kurz Abbildung 11.4 zu betrachten. Die Abbildung zeigt den Zustand nach Ausführung der Addition in h, Zeile 7. Dabei fällt auf, dass es einerseits natürlich eine Variable x im Frame f1 von f gibt, die auf den Wert 1 verweist; anderseits auch eine Variable x im Frame f2 von g gibt, die auf den Wert 43 (nach der Addition) weist; aber keine Variable x im Frame von h gibt; nonlocal sorgt dafür, dass der Namespace von g hier benutzt wird. Abbildung 11.4: Effekt von nonlocal

12 12 Liste von Definitionen u.ä Nachschlageregel: LEGB Bisher einfache Nachschlagregel für Namensräume: Erst lokal, dann global Tatsächlich etwas umfangreicher Definition 11.1 (Nachschlageregel für Namen: LEGB). Python sucht Namen in diesen Namensräumen, in dieser Reihenfolge: 1. dem lokalen Namensraum (einer Funktion): L 2. dem Namensraum umgebender (enclosing) Funktionen: E 3. dem globalen Namensraum: G 4. dem Namensraum eingebauter (vordefinierter) Namen (build-in): B Kurz: Die Reihenfolge ist LEGB Nachschlageregel: LEGB Illustration Abbildung 11.5: Nachschlageregel LEGB Abbildung 11.5 illustriert die Nachschlageregel LEGB: von innen nach aussen Closures Vorüberlegung: Referenzen auf Funktionen? Kann man Funktionsnamen wie normale Namen behandeln? Kann man diese kopieren, und trotzdem noch aufrufen?

13 11.3. Closures 13 2 print("f!") 3 4 g = f 5 g() f! Was passiert hier? f ist ein Name für ein Funktionsobjekt Die Anweisung g = f lässt den Namen g auf das gleiche Objekt referenzieren Also wird der Aufruf g() auch die gleiche Funktion aufrufen Der Name der referenzierenden Variable ist irrelevant! Vorüberlegung 2: Funktionsreferenzen als Rückgabewert? Wenn man Funktionsreferenzen kopieren kann Dann kann man sie doch bestimmt auch als Rückgabewert einer Funktion verwenden? 2 def g(): 3 print("innere Funktion!") 4 return g 5 6 h = f() 7 h() (PT link) innere Funktion! Natürlich! Die Semantik ist ganz banal! Nach Aufruf von f ist h ein weiterer Name für das Funktionsobjekt geworden, das ursprünglich unter dem Namen g eingeführt wurde

14 14 Liste von Definitionen u.ä. Visualisierung Auch Abbildung 11.6 zeigt, dass hier eigentlich nichts spannendes passiert. Der Umstand, dass das Funktionsobjekt g innerhalb einer Funktion erzeugt wurde, ist genauso viel oder wenig relevant wie das bei einem normalen Objekt der Fall wäre. Abbildung 11.6: Aufruf einer Funktion, die als Funktionsergebnis bekannt wurde Analogie: Normales Objekt als Rückgabewert Zur Analogie: Dieser Code ist ja klar Eine Liste kann man nicht aufrufen, sondern ausgeben Aber sonst ist das genau das gleiche! 2 g = ["ein", "Beispiel", "Objekt"] 3 return g 4 5 h = f() 6 print(h) Funktionen mit Parametern als Rückgabe? Was passiert, wenn wir eine Funktion zurückgeben, die Parameter benutzt? 2 def g(x): 3 print("innere Funktion!", x) 4 return g 5 6 h = f() 7 h("wert für x")

15 11.3. Closures 15 innere Funktion! Wert für x Parameter bleibt bestehen Dann hat die Funktion natürlich einen Parameter Aufruf unter neuem Namen erfordert diesen Parameter Funktion mit Zugriff auf nichtlokale Variablen als Rückgabe Spannender: Innere Funktion greift auf Parameter der äußeren Funktion zu Innere Funktion wird zurückgeben und dann aufgerufen Erwartetes Verhalten? 2 n = 5 3 def g(x): 4 print("innere Funktion!", x*n) 5 return g 6 7 h = f() 8 h("wert für x") innere Funktion! Wert für xwert für xwert für xwert für xwert für x (PT link) Äußerer Parameter bleibt erhalten! Offenbar behält die Funktion, die unter h im globalen Scope bekannt ist, Zugriff auf die Variable n Erstaunlich! n im Namensraum von f, aber f schon beendet!? Visualisierung Abbildung 11.7 zeigt hier den Zustand beim Ablauf von f, kurz vor Rückgabe von g an den Aufruf in Zeile 7. Man sieht schön das angelegte Funktionsobjekt für g (mit dem Parameter x) und den Namen n für die Zahl 5.

16 16 Liste von Definitionen u.ä. Abbildung 11.7: Zurückgegebene Funktion mit Parameter: Vor Aufruf Abbildung 11.8 visualisiert dann die Ausführung der Funktion h (was g ist). g wird mit dem String Wert für x als Wert für den Parameter x aufgerufen. Zusätzlich behält g Zugriff auf den Wert von n (hier nicht schön visualisiert; man sieht aber, dass der Frame f1 noch existiert. Abbildung 11.8: Zurückgegebene Funktion mit Parameter: Im Aufruf Nicht-lokale Variable selbst als Parameter In obigem Beispiel: n hatte einen festen Wert Aber wo der Wert für n herkommt ist egal Er muss lediglich vor dem def von g vorhanden sein Es könnte selbst ein Funktionsparameter sein? 1 def f(n): 2 def g(x): 3 print("innere Funktion!", x*n) 4 return g 5 6 h = f(3) 7 h("wert für x")

17 11.3. Closures 17 innere Funktion! Wert für xwert für xwert für x Beispiel Aufgeräumt 1 def vervielfacher_fabrik(n): 2 def vervielfacher(x): 3 return x*n 4 5 return vervielfacher 6 7 doppler = vervielfacher_fabrik(2) 8 fuenffacher = vervielfacher_fabrik(5) 9 10 print(doppler("mehrfach ausgeben! ")) 11 print(fuenffacher("mehrfach ausgeben! ")) Mehrfach ausgeben! Mehrfach ausgeben! Mehrfach ausgeben! Mehrfach ausgeben! Mehrfach ausgeben! Mehrfach ausgeben! Me (PT link) Muster: Fabrik (Factory) Beispiel hatte mehrere Bestandteile Eine...-fabrik Funktion: Sie erzeugt eine andere Funktion, richtig parametriert Der Bauplan für die zu erzeugende Funktion (hier: vervielfacher) * Bauplan wird konkretisiert durch Einsetzen von Werten für Parameter (hier: n) Mehrfacher Aufruf der Fabrik mit unterschiedlichen Parametern * Ergibt maßgeschneiderte Funktionen, die aufgerufen werden Das sog. factory pattern Realisierung: Closures Das erstaunliche: Die produzierten Funktionen merken sich die Werte der Parameter der Fabrik-Funktion! Dazu werden die Frames (Namensräume) dieser Fabrikfunktionsaufrufe nicht entsorgt, sondern an die produzierte Funktion (doppler, fuenffacher,...) gekoppelt Diese Datenstruktur (Kopplung von Frames an einen Funktionsnamen) heißt Closure Closure merken sich den relevanten Zustand ein state retention Ansatz

18 18 Liste von Definitionen u.ä. Definition 11.2 (Closure). Ein Closure ist eine Funktion, deren nicht-lokale Namen an Objekte gebunden wurden. Visualisierung Abbildung 11.9 zeigt die beiden im Beispiel entstandenen Closures. Die beiden Funktionsnamen doppler und fuenffacher referenzieren jeweils zwei Funktionsobjekte. Der entscheidende Punkt ist nun die Angabe parent bei diesen Objekten: sie verweisen auf den Namensraum, in dem die fehlenden Variablen (hier: n) gesucht werden sollen. Dies sind die beiden Namensräume, die durch die beiden Aufrufe von vervielfacher_fabrik erzeugt wurden. Abbildung 11.9: Zwei Closures Anmerkung: Terminologie Je nach Literaturquelle wird auch das Programmiermuster selbst als Closure bezeichnet, nicht nur die Realisierungstechnik. Das macht letztlich keinen großen Unterschied. Anmerkung: Vorkommen von Closures Closures kommen häufig in funktionalen Sprachen vor. Neben Python ist Javascript ein populäres Beispiel, bei dem häufig Closures benutzt werden, um die Reaktion auf Nutzereingaben oder Daten vom Server zu beschreiben. Auch in Sprachen wie Lisp oder Ruby sind Closures ein populäres, elegantes Sprachmittel. Sprachen wie Java, C++, C# und Abkömmlinge stellen in der Regel nur vereinfachte Strukturen zur Verfügung und können das Konzept der Closures nicht vollständig abbilden.

19 11.4. Anonyme Funktionen: lambda-ausdrücke Nutzen: Fabriken und Closures Beispiel oben ist zugeben etwas künstlich Typischer Einsatz von Closures: Graphische Nutzerschnittstellen: Funktionen, die abhängig von Nutzereingabe erzeugt werden Web-Anwendungen: Funktionen erzeugen, die auf Veränderungen reagiert (sog. callbacks) * Häufig in event handlers in Javascript! 11.4 Anonyme Funktionen: lambda-ausdrücke Funktionsdefinition bisher: def def ist Anweisung Erzeugt ein Funktionsobjekt Legt einen Namen im entsprechenden Namensraum an Verbindet Namen mit erzeugtem Objekt Was, wenn man den Namen eigentlich gar nicht braucht? Sondern nur das Funktionsobjekt an sich? Z.B., weil es in einer Factory sowieso direkt zurückgegeben wird? Oder nur an einer einzigen Stelle gebraucht wird, z.b. in einer list comprehension? Funktionsname in Factory: Nötig? Beispiel oben: Name vervielfacher eigentlich nicht sehr nützlich 1 def vervielfacher_fabrik(n): 2 def vervielfacher(x): 3 return x*n 4 5 return vervielfacher 6 7 doppler = vervielfacher_fabrik(2) 8 fuenffacher = vervielfacher_fabrik(5) 9 10 print(doppler("mehrfach ausgeben! ")) 11 print(fuenffacher("mehrfach ausgeben! "))

20 20 Liste von Definitionen u.ä. Mehrfach ausgeben! Mehrfach ausgeben! Mehrfach ausgeben! Mehrfach ausgeben! Mehrfach ausgeben! Mehrfach ausge Anonyme Funktionen: λ-ausdrücke Das kommt häufig vor, verdient also Sprachunterstützung Definition 11.3 (λ-ausdrücke: lambda). Ausdruck, der eine anonyme Funktion vereinbart Keine Anweisung! Präziser: der ein Funktionsobjekt erzeugt und eine Referenz auf dieses Objekt zurückgibt Eigenschaften Anonyme Funktion darf beliebig viele Parameter haben Aber die Funktion darf nur aus einem Ausdruck bestehen; sie darf keine Anweisungen nutzen Syntax: lambda Liste von Parameter : Zu berechnender Ausdruck λ-ausdrücke Beispiele Funktion, die drei Zahlen addiert 1 adder = lambda a, b, c : a + b + c 2 print(adder(1, 2, 3)) 6 lambda in Factory Viel besser lesbare Closure-Version: 1 def vervielfacher_fabrik(n): 2 return lambda x: x*n 3 4 doppler = vervielfacher_fabrik(2) 5 fuenffacher = vervielfacher_fabrik(5) 6 7 print(doppler("mehrfach ausgeben! ")) 8 print(fuenffacher("mehrfach ausgeben! "))

21 11.5. Funktionaler Programmierstil 21 Mehrfach ausgeben! Mehrfach ausgeben! Mehrfach ausgeben! Mehrfach ausgeben! Mehrfach ausgeben! Mehrfach ausgeben! Me λ-ausdrücke Funktionen an Objekte übergeben Objekte brauchen manchmal eine Funktion, die sie aufrufen können Häufig: GUI-Frameworks Funktion wird nur als Referenz in Objekt gespeichert Funktion bei Methodenaufruf bei lambda erzeugen 1 class SomeClass: 2 def init (self, name, fct): 3 self.name = name 4 self.fct = fct 5 6 def do(self): 7 self.fct() o = SomeClass(name="somename", 11 fct = lambda: some expression here) 12 o.do() 11.5 Funktionaler Programmierstil Beobachtung: Funktionen sind first-class citizens Python behandelt Funktionen wie ganz normale Objekte, mit allerlei Operationen darauf Funktionen als Parameter, als Rückgabewerte, speichern in Variablen oder Datenstrukturen,... Solche Funktionen sind first-class citizens Dies erlaubt funktionale Programmierung als Programmierparadigma Funktionale Programmierung Typische Merkmale Funktionen sind first-class citizens Impliziert: Funktionen können auf Funktionen angewendet werden Rekursion Keine Seiteneffekte

22 22 Liste von Definitionen u.ä Beispiel: map, filter Iterables filter Häufiger Stil in funktionalen Sprachen: Daten in Listen ablegen Listen filtern gemäß einer Filterfunktion Funktion auf jedes Element einer Aufzählung (iterable) anwenden Liste zu einem einzelnen Wert reduzieren Sog. map/filter/reduce-muster Idee nicht nur auf Listen eingeschränkt Warum nicht auf Tuple, Mengen,...? Alles, was man der Reihe nach durchlaufen kann Formalisiert: Klasse Iterable Unterklassen: list, str, tuple, dict, Dateien,... filter: eingebaute Funktion Signatur: filter(function, iterable) Wende die Funktion function auf jedes Element einer Aufzählung an Resultat: Aufzählung mit den Elementen, bei denen die Funktion wahr ergab Beispiel: 1 l = [1, 2, 3, 4, 5] 2 l2 = filter(lambda x: x % 2 == 1, l) 3 print(list(l2)) map [1, 3, 5] map: eingebaute Funktion Signatur: map(function, iterable) Wende die Funktion function auf jedes Element eines Objektes an, dass zu einer von iterable abgeleiteten Klasse gehört Resultat: Aufzählung der Funktionsergebnisse Beispiel:

23 11.5. Funktionaler Programmierstil 23 1 l = [1, 2, 3, 4, 5] 2 l2 = map(lambda x: x*x, l) 3 print(list(l2)) 4 5 print(" -- ".join(map(str,l))) [1, 4, 9, 16, 25] Anmerkung Konvertierung in Liste nur nötig für print Weitere Operationen auf iterables Reichlich Beispiele, siehe Übungen: zip reduce λ-ausdrücke und flexible Argumente Eine Funktion, die beliebig viele Argumente beliebigen Types mit & dazwischen ausgibt? 1 out = lambda *x: print(" & ".join(map(str, x))) 2 out(1, 2, 3, "hallo", "gp1") 1 & 2 & 3 & hallo & gp Vergleich: list comprehensions und map/filter Die Beispiele oben sind in Python einfacher und kompakter als list comprehensions aufzuschreiben Allerdings: dadurch wird die komplette Liste erzeugt Sinnvoll? 1 l = [x for x in range(100000) if x < 2][0:1] 2 print(l)

24 24 Liste von Definitionen u.ä. Abbildung 11.10: LISP Abbildung 11.11: Popularität reiner funktionaler Sprachen Evolution funktionaler Sprache: Großvater LISP Rein funktionale Sprachen 11.6 Generatoren Funktionen auf große Listen anwenden? Große Eingaben brauchen viel Platz Ggf. kann das Erzeugen der Eingabe schon allen Speicherplatz verbrauchen Mit endlichen Listen kann man keine unendlichen Folgen erzeugen Beispiel: Alle Primzahlen Vielleicht Idee: Werte nach und nach erzeugen Statt komplette Liste zu berechnen, nur jeweils den nächsten Wert Auf Aufforderung als Funktionsaufruf? Werte auf Aufforderung Skizze?

25 11.6. Generatoren 25 1 def magic_prime_production(start): 2 if erster Aufruf: 3 letzte_zahl = start 4 res = nächste Primzahl größer als letzte_zahl 5 letzte_zahl = res 6 return res 7 8 # Nutzung in for Schleife?? 9 for p in magic_prime_production(): 10 print(p) Werte auf Aufforderung Realisierung? Mit Funktionsaufruf wie bisher geht das so nicht Funktion hat keine Vorstellung, was der letzte Wert ist Wir müssten das der Funktion beibringen?...? Analogie: Closures? Hat sich auch Zustand gemerkt? Realisierung: Closure-artig Mit Closure-artiger Zustandsspeicherung lässt sich das Problem lösen Siehe auch Programmieraufgabe! Aber syntaktisch unhandlich also Anweisung! Werte auf Aufforderung Generatoren Syntaktischer Zucker: Generatoren Schlüsselwort: yield und Generatorenfunktionen Idee: Ersetze in einer Funktion return durch yield Liefert Wert an Aufrufer und merkt sich Zustand für nächsten Aufruf! * Zustand: Werte lokaler Variablen; Zeilennummer; Generator: Einfaches Beispiel Generator wird die Werte 1, 2, 3 liefern. Danach nichts. 1 def gen(): 2 yield 1 3 yield 2 4 yield 3

26 26 Liste von Definitionen u.ä Generatoren: Nutzung Aufruf: Unterscheidung erster und folgende Aufrufe notwendig Erster Aufruf: normaler Funktionsaufruf, initialisiert * Gibt ein Generator-Objekt Folgender Aufruf: Funktion next auf dieses Generator-Objekt anwenden Generator: Einfaches Beispiel Nutzung Generator wird die Werte 1, 2, 3. Danach StopIteration-Exception. 1 def gen(): 2 yield 1 3 yield 2 4 yield g = gen() 7 print(g) 8 print(next(g)) 9 print(next(g)) 10 print(next(g)) 11 try: 12 print(next(g)) 13 except StopIteration: 14 print("da kommt nichts mehr") <generator object gen at 0x10301b3b8> da kommt nichts mehr Generator: Nutzung in Schleife Spannender Punkt: Generatoren können wie Iterables in Schleife benutzt werden Syntax dadurch deutlich einfacher StopIteration führt zum Schleifenende 1 def gen(): 2 yield 1

27 11.6. Generatoren 27 3 yield 2 4 yield for v in gen(): 7 print(v) Beispiel: Unendlicher Generator Produziere alle Vielfachen von 3 ab Startwert: 1 def gen(start): 2 # wir wollen alle Vielfache, also Endlosschleife: 3 while True: 4 if start % 3 == 0: 5 yield start 6 print("restarting with value: ", start) 7 start += for v, i in zip(gen(16), range(5)): 10 print("wert: ", v) Verständnisfragen Wozu range und zip in Beispiel? Wann werden Aufrufe von gen durchgeführt? Wieviele Schleifendurchläufe? Beispiel: Generator als Closure 1 def gengen(multiplier): 2 def gen(start): 3 while True: 4 if start % multiplier == 0: 5 yield start 6 start += return gen 9

28 28 Liste von Definitionen u.ä. 10 dreis = gengen(3) 11 viers = gengen(4) for d, v, i in zip(dreis(10), viers(17), range(2)): 14 print (d, v) Ausgabe? 1 pingo_title = "WAs wird hier ausgebenen?" 2 pingo_type = "single" 3 pingo_questions = ["12, 15 und 20, 24", "12, 20 und 15, 24", "10, 17 un 4 pingo_duration = "60" 5 6 %pingo Wesentlicher Punkt: Speicherverbrauch Natürlich kann man das auch über eine list comprehension hinschreiben Aber Speicherverbrauch: List comprehension erzeugt die gesamte Liste vor Verarbeitung; muss im Speicher stehen Generator: nur Platz für eine einzige Iteration notwendig * Also: start, und die Closure für den Generator Generators für List comprehensions Kombination der Vorteile? Elegante Syntax der List comprehension? Ohne den Speicherverbrauch? Generatoren statt Listen! Kleine syntaktische Änderung: Wir ersetzen [] durch () in Schleifen 1 print("mit Liste: ") 2 for i in [x for x in range(17, 40) if x % 3 == 0]: 3 print(i, end=", ") 4 5 print("\nmit Generator: ")

29 11.7. Decorators 29 6 for i in (x for x in range(17, 40) if x % 3 == 0): 7 print(i, end=", ") Mit Liste: 18, 21, 24, 27, 30, 33, 36, 39, Mit Generator: 18, 21, 24, 27, 30, 33, 36, 39, 11.7 Decorators Ausgangspunkt Wir haben folgende Eigenschaften kennengelernt: Funktionen sind first-class citizens in Python Funktionsnamen sind eigentlich auch nur Variablen, die ein Funktionsobjekt referenzieren Solche Referenzen können aus Funktionen zurückgegeben werden Und Referenzen können Funktionsnamen zugewiesen werden Was kann man damit anstellen? Überlegung 1: Wir können aus einer Funktion eine neue Funktion bauen Beispiel: Wir möchten die Ausgaben einer Funktion f mit == einrahmen Ansatz: Baue eine neue Funktion, die = ausgibt f aufruft und nochmal = ausgibt Diese neue Funktion bauen wir als Closure und geben eine Referenz darauf zurück Schauen wir uns den Code in mehreren Schritten an! Eingerahmte Ausgabe Version 1 Version 1: Eine einfache factory 2 print("ausgabe von f")

30 30 Liste von Definitionen u.ä. 3 4 def einrahmer_fabrik(): 5 def einrahmer(): 6 print("=====") 7 f() 8 print("=====") 9 10 return einrahmer f_neu = einrahmer_fabrik() 13 f_neu() ===== Ausgabe von f ===== Eingerahmte Ausgabe Version 2 Version 1 ist unnötig speziell Factory-Muster kann doch Parameter nehmen (Closures!) 2 print("ausgabe von f") 3 4 def g(): 5 print("ausgabe von g") 6 7 def einrahmer_fabrik(fct): 8 def einrahmer(): 9 print("=====") 10 fct() 11 print("=====") return einrahmer f_neu = einrahmer_fabrik(f) 16 g_neu = einrahmer_fabrik(g) f_neu() 19 g_neu() =====

31 11.7. Decorators 31 Ausgabe von f ===== ===== Ausgabe von g ===== Eingerahmte Ausgabe Version 3 Den einrahmenden Text kann man auch zum Parameter machen 2 print("ausgabe von f") 3 4 def g(): 5 print("ausgabe von g") 6 7 def einrahmer_fabrik(fct, s="==========="): 8 def einrahmer(): 9 print(s) 10 fct() 11 print(s) return einrahmer f_neu = einrahmer_fabrik(f, "***********") 16 g_neu = einrahmer_fabrik(g) f_neu() 19 g_neu() *********** Ausgabe von f *********** =========== Ausgabe von g =========== Eingerahmte Ausgabe Version 4 Brauchen wir die ursprüngliche Version von f noch? Nein? Dann brauchen wir auch keinen neuen Namen!

32 32 Liste von Definitionen u.ä. 2 print("ausgabe von f") 3 4 def einrahmer_fabrik(fct, s="==========="): 5 def einrahmer(): 6 print(s) 7 fct() 8 print(s) 9 10 return einrahmer # Wir lassen die Variable f ein neues Funktionsobjekt referenzieren: 13 f = einrahmer_fabrik(f, "***********") f() *********** Ausgabe von f *********** Muster Dieses Muster tritt häufig auf, ist extrem nützlich Einer Funktion wird neues Verhalten hinzugefügt, ohne dass dies für einen Nutzer der Funktion sichtbar ist! Die Signatur der Funktion verändert sich nicht; nicht einmal der Name Nützlich, um vorhandenen Code anzupassen Dekoration (decorator) Definition 11.4 (Das Decorator-Muster). Das Decorator-Muster beschreibt eine typische Struktur, mit der eine Funktion mit weiterer Funktionalität versehen werden kann, ohne die Funktion oder den nutzenden Code zu verändern Decorators: Anwendungen Vorhandenen Code verändern, patchen Fehlersuche, Leistungsmessung Komplexere Code-Strukturen GUI-Frameworks

33 11.7. Decorators 33 * Beispiel: einer Funktion zum Zeichnen eines Fenster werden als decorators Funktionen zum Zeichnen von Scrollbars hinzugefügt Funktion selbst und Aufrufer merken nicht, dass das Fenster Scrollbars hat Webframework (Beispiel: Django) * Die Handhabung von URLs wird durch Dekoratoren angepasst Decorators für Methoden Methoden einer Klasse sind Funktion Also können sie dekoriert werden Decorators: Syntaktischer Zucker Decorators stellen sich als extrem nützlich und vielseitig heraus Aber auch unhandlich Beispiel oben: Die Funktion f wird 3x erwähnt? DRY? Die Dekoration kann an ganz anderer Stelle geschehen; unübersichtlich Kompakter? Sprachunterstützung? Decorators: Syntaktischer Zucker (2) Syntax: Die dekorierende Funktion wird wie üblich vereinbart Sie nimmt einen Parameter: die aufzurufende (zu dekorierende) Funktion Die zu dekorierende Funktion wird durch voranstellen dekoriert Decorator: kompakte Syntax Beispiel 1 def einrahmer_fabrik(fct): 2 def einrahmer(): 3 print("=====") 4 fct() 5 print("=====") 6 7 return einrahmer 8 10 def f(): 11 print("ausgabe von f")

34 34 Liste von Definitionen u.ä f() ===== Ausgabe von f ===== Decorator: kompakte Syntax Beispiel mit typischen Namen Die _fabrik-terminologie wird bei Dekoratoren typischerweise weggelassen 1 def einrahmer(fct): 2 def _einrahmer(): 3 print("=====") 4 fct() 5 print("=====") 6 7 return _einrahmer 8 10 def f(): 11 print("ausgabe von f") f() ===== Ausgabe von f ===== Decorators: Syntaktischer Zucker Kompakt, leicht lesbar, elegant, häufig benutzt Sie werden kaum ein nicht-triviales Python-Programm ohne decorators finden Nachteil: Parameter an dekorierende Funktion übergeben ist umständlich Beispiel Benchmarking Wie bestimmt man Zeitverbrauch einer Funktion?

35 11.7. Decorators 35 Man schaut in einem Dekorator vor und nach dem Aufruf der Funktion auf die Uhr! 1 import time 2 3 def benchmark(fct): 4 def _benchmark(*args, **kwargs): 5 tstart = time.time() 6 r = fct(*args, **kwargs) 7 tend = time.time() 8 9 print("{} (args: {}, kwargs: {}) verbrauchte {} Sekunden".format( 10 fct. name, args, kwargs, tend-tstart)) return r return _benchmark def f1(s): 18 print("anfang f1") 19 time.sleep(s) 20 print("ende f1") f1(0.2) 24 f1(0.6) Anfang f1 Ende f1 f1 (args: (0.2,), kwargs: {}) verbrauchte Sekunden Anfang f1 Ende f1 f1 (args: (0.6,), kwargs: {}) verbrauchte Sekunden Property Tatsächlich kennen wir schon einen Decorator: Property Bisher nur als eingebaute Funktion property Es fehlt also nur noch der Zucker Getter: dekorieren; Funktionsname wird Name der Property

36 36 Liste von Definitionen u.ä. Setter: dekorieren; Funktionsname muss Name der Property sein, mit value 1 class Temperature: 2 def init (self, temp=0): 3 # auch Methoden der Klasse greifen normal auf das Attribut zu: 4 self._temperature = temp 5 7 def temperature(self): 8 print("lesender Zugriff") 9 return self._temperature def temperature(self, value): 13 print("schreibender Zugriff") 14 if value < 0: 15 raise ValueError("Keine negativen Temperaturen in Kelvin!") 16 else: 17 self._temperature = value t1 = Temperature(17) 20 print(t1.temperature) 21 t1.temperature = print(t1.temperature) Lesender Zugriff 17 Schreibender Zugriff Lesender Zugriff 42 Für Fortgeschrittene Warum kann man hier scheinbar eine Funktion doch überschreiben? Das geht doch angeblich nicht? verketten? Siehe auch: Quelle des Beispiels

37 11.7. Decorators 37 1 def star(func): 2 def inner(*args, **kwargs): 3 print("*" * 30) 4 func(*args, **kwargs) 5 print("*" * 30) 6 return inner 7 8 def percent(func): 9 def inner(*args, **kwargs): 10 print("%" * 30) 11 func(*args, **kwargs) 12 print("%" * 30) 13 return inner def printer(msg): 18 print(msg) printer("hallo GP1!") ****************************** %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Hallo GP1! %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ****************************** Decorators: Ausblick Das Dekorieren von Methoden einer Klasse ist typisch (siehe Man kann auch Klassen zu decorators machen, nicht nur Funktionen Siehe auch eine lange Liste mit Beispielen War doch gar nicht so schwer Abbildung 11.12: Master of a tiny universe

38 38 Liste von Definitionen u.ä Zusammenfassung Zusammenfassung Und nun? Funktionen können Funktionen definieren Erfordert Erweiterung der Nachschlageregel für Namen: LEGB Macht ein Programmierparadigma Funktionen zu first-class citizens, eröffnen sich viele elegante Möglichkeiten Fabriken / Closures, um Funktionen zur Laufzeit zu erzeugen Generatoren, um große (unendliche) Aufzählungen bei Bedarf zu erzeugen Decorators, um Funktionen zur Laufzeit zu modifizieren Eine elegante Syntax ist dabei für praktische Nützlichkeit wichtig lambda-ausdrücke für anonyme für Decorators Was waren diese seltsamen import-anweisungen??