Kapitel 15: Von dynamischen zu statischen Typen. Grundlagen der Programmierung 1. Holger Karl. Wintersemester 2016/2017. Inhaltsverzeichnis 1

Transkript

1 Kapitel 15: Von dynamischen zu statischen Typen Grundlagen der Programmierung 1 Holger Karl Wintersemester 2016/2017 Inhaltsverzeichnis Inhaltsverzeichnis 1 Abbildungsverzeichnis 2 Liste von Definitionen u.ä Überblick Fehlerquellen in Python-Programmen Erinnerung: Typsysteme Statisch typisierte Sprachen Grundkonzepte Vergleich: Dynamisch vs. statisch typisierte Sprachen

2 15.6 Zusammenfassung Abbildungsverzeichnis 15.1 Zuweisung von Wert an Variable gleichen Typs Zuweisung von Wert an Variable inkompatiblen Typs Wert kleinen Typs an Variable großen Typs zuweisen gelingt Wert großen Typs an Variable kleinen Typs zuweisen scheitert Umwandlung eines Wertes in einen entsprechenden Wert eines anderen Typs Verhältnis von Ober- und Unterklasse als Typen Zuweisung Oberklasenobjekt an Unterklasse-Variable scheitert Zuweisung Unterklassenobjekt an Oberklassen-Variable gelingt Java is coming! Liste von Definitionen u.ä Definition (Dynamisch typisierte Programmiersprache) Definition (Statisch typisierte Sprache)

3 15.1. Überblick Überblick Was bisher geschah Bisher haben wir mit Python ein Beispiel für eine dynamisch und stark typisierte Sprache angeschaut Dies hatte erhebliche Vorteile: einfaches, elegantes Sprach-Design, kompakter Code,... Aber es hat auch Nachteile, insbes. kann es zur Laufzeit zu unnötigen Fehler führen Dieses Kapitel Wir legen den Grundstein für statisch typisierte Sprachen Vor- und Nachteil zwischen dynamischen und statischen Typen Wir nehmen hier Anlauf, um nicht in der Diskussion von Java-Details den Blick für das Wesentliche zu verlieren Wesentliche Quellen: L. Tratt, Dynamically Typed Languages und Appeal of dynamically-typed languages 15.2 Fehlerquellen in Python-Programmen Vergleich inkompatibler Typen 1 import random 2 geheim = random.randint(1,11) 3 zahl = input("rate meine geheime Zahl:") 4 5 if zahl == geheim: 6 print("richtig") 7 elif zahl < geheim: 8 print("zu klein!") 9 else: 10 print("zu groß!") Fehlermeldung

4 4 Liste von Definitionen u.ä. 1 Rate meine geheime Zahl:3 2 Traceback (most recent call last): 3 File "bla.py", line 7, in <module> 4 elif zahl < geheim: 5 TypeError: unorderable types: str() < int() Operationen auf inkompatiblen Typen 1 x = 5 2 y = "3" 3 print(x-y) Fehlermeldung 1 Traceback (most recent call last): 2 File "<stdin>", line 3, in <module> 3 TypeError: unsupported operand type(s) for -: int and str Aufruf nicht vorhandener Methoden 1 l = [1, 2, 3] 2 print(l.no_such_method()) Fehlermeldung 1 Traceback (most recent call last): 2 File "<stdin>", line 2, in <module> 3 AttributeError: list object has no attribute no_such_method Aufruf von Methoden bei falschem Objekt 1 class C: pass 2 class D(C): 3 def f(): pass 4 5 c = C() 6 c.f()

5 15.3. Erinnerung: Typsysteme 5 1 Traceback (most recent call last): 2 File "<stdin>", line 6, in <module> 3 AttributeError: C object has no attribute f Vermeidbar? Wären diese Fehler nicht vermeidbar gewesen? Mit einer besseren GP1-Vorlesung: Vielleicht! Oder zumindest entdeckbar? Man muss ja nur den Programmcode anschauen um zu sehen, dass das nicht funktionieren kann Damit muss man doch nicht bis zur Laufzeit waren? Allgemeiner: Fehler vor Laufzeit aufdecken? Kann man Fehler in einem Programm bereits vor dem Start entdecken? Während der Übersetzung? Während das Programm noch beim Entwickler ist? Fehler zur Laufzeit riskant! In einem Atomkraftwerk: AttributeError: Reaktor Object has no attribute emergency_shuddown Millionen Tote wegen eines Tippfehlers (shutdown)?? Problem bei dynamischen Sprachen: Fehlende Information Bei dynamischen Sprachen: Bei Übersetzung liegt noch nicht (zwangsläufig) genügend Information vor! Beispiele oben: Ja, das könnte man fehlende Information finden Was ist mit diesem Beispiel Funktion in einem Modul definiert 1 def f(a, b): 2 return a + b 15.3 Erinnerung: Typsysteme Stark typisierte Sprachen Zu jedem Wert gibt es einen Typ Typ bestimmt die Menge der darauf durchführbaren Operationen

6 6 Liste von Definitionen u.ä. Nicht alle Operationen auf beliebige Kombinationen von Typen anwendbar Beispiel: oder 17 > 18 scheitert Erinnerung (Kapitel 3): Dynamisch typisierte Sprachen Definition 15.1 (Dynamisch typisierte Programmiersprache). Eine Programmiersprache ist dynamisch typisiert, wenn Typen-Informationen für jeden Wert oder Ausdruck zur Laufzeit bekannt sind. Diese Typen-Information ist im Programm-Code nicht explizit repräsentiert und nicht notwendigerweise aus ihm ableitbar. Python ist ein Beispiel Erinnerung (Kapitel 3): Statisch typisierte Sprache Definition 15.2 (Statisch typisierte Sprache). Eine Programmiersprache ist statisch typisiert wenn Typen-Informationen für Variablen explizit im Programm-Code angegeben werden müssen. Aus der Betrachtung des Programm-Codes kann der Typ eines Wertes abgeleitet werden, bereits bevor das Programm selbst abläuft. Meist (aber nicht unbedingt) wird in einer solchen Sprache auf die explizite Repräsentation des Typs eines Wertes zur Laufzeit verzichtet, da ja alle Informationen bereits vorab bekannt sind. Java ist ein Beispiel Erinnerung: Compiler vs. Interpreter Ausführung: Anweisung ausführen: * Die Zustandsänderung bestimmen, die die Anweisung bewirken soll * Diese Zustandsänderung im Speicher durchführen Programm ausführen: Die Anweisungen des Programm ausführen Interpreter: ein Programm in einer gegebenen Sprache Anweisung für Anweisung ausführen Ein Mikroprozessor ist ein Interpreter für Maschinensprache Compiler: Ein Programm in einer Sprache in ein semantisch äquivalentes Programm in einer anderen Sprache überführen Erinnerung: Compiler vs. Interpreter Viele modernen Sprachen haben einen Compiler und einen Interpreter

7 15.4. Statisch typisierte Sprachen Grundkonzepte 7 Überführung in Zwischensprache Interpretation dieser Zwischensprache * (Oder auch: weitere Compilationsschritte, Just-in-Time Compilation) Beispiel: Java, Python,... Das ist orthogonal zu statisch vs. dynamisch typisiert! 15.4 Statisch typisierte Sprachen Grundkonzepte Grundidee Variablen bekommen einen Typ, nicht nur Werte Damit ändert sich Interpretation: Eine Variable ist nicht mehr ein Namensschild an einem Wert Sondern: Eine Schachtel mit einer bestimmten Form Der Typ des Werts muss mit dem Typ der Variable zusammenpassen Sozusagen: Wert muss in Form der Schachtel passen Zuweisungen an typisierte Variablen Also neu: auf der linken Seite einer Zuweisung steht nun eine Variable mit Typ Bisher: links steht nur ein Name ohne Typ In beiden Fällen: rechts ein Ausdruck mit Typ Zuweisungsregel: Typgerecht Kernpunkt typisierter Sprachen: Zuweisungen müssen typgerecht erfolgen Beispiele siehe unten Schachteln mit Form Visualisierung von Typen: Variablen als Typen Werte als Boxen, Kreise Werte müssen in Schachtel passen, sonst Zuweisung nicht erlaubt Zuweisung gleichen Typs Typ von Wert und Variable gleich: Kein Problem, Zuweisung erlaubt

8 8 Liste von Definitionen u.ä. Abbildung 15.1: Zuweisung von Wert an Variable gleichen Typs Zuweisung inkompatibler Typen Versucht man Wert an Variable mit nicht passendem Typ zuzuweisen: Compiler erkennt das; Code wird nicht übersetzt Beispiel: An eine Variable mit Typ integer eine Zeichenkette zuweisen Abbildung 15.2: Zuweisung von Wert an Variable inkompatiblen Typs Zuweisung inkompatibler Typen: Größe Was ist mit ähnlichen Typen, die aber unterschiedlich groß sind? Wesentliches Beispiel: Unterschiedliche Darstellungen von ganzen Zahlen Abbildung 15.3: Wert kleinen Typs an Variable großen Typs zuweisen gelingt Abbildung 15.4: Wert großen Typs an Variable kleinen Typs zuweisen scheitert

9 15.4. Statisch typisierte Sprachen Grundkonzepte Zuweisung inkompatibler Typen: Wert umbauen Aber wenn in der Zeichenkette eine Zahl enthalten ist? Wert umbauen in einen semantisch äquivalenten Wert eines anderen Typs? Typumwandlung (type cast)! Also: Aus Zeichenkette 42 (Buchstabe 4 und Buchstabe 2) mache die Zahl Zuweisung inkompatibler Typen: Wert umbauen (2) Abbildung 15.5: Umwandlung eines Wertes in einen entsprechenden Wert eines anderen Typs Typumwandlung (type cast): Explizit oder implizit Type casts können explizit oder implizit sein: Explizite Type casts: Im Programm steht ausdrücklich, dass ein Wert in einen anderen Wert umgewandelt werden soll Implizite Type casts: Rechts und links der Zuweisung gibt es (unterschiedliche) Typen Compiler sieht das bei Analyse des Programms Compiler versucht, selbst eine Funktion zur Umwandlung des gegebenen Typs in den Wunschtyp zu finden Kann kompliziert, überraschend sein! Implizite Type-Casts, Beispiel Was sollte hier wie umgewandelt werden? 1 print("hallo " + 1)

10 10 Liste von Definitionen u.ä. Typumwandlung in Ausdrücken Ausdrücke: Zerlegen in Teilausdrücke; wie Zuweisung vorstellen Type cast bei Python Explizit Explizite type casts gibt es auch bei Python Keine spezielle Eigenschaft einer statisch typisierten Sprache! Notation: Ziel-Typ als Konstruktor benutzen Ausgangswert als Parameter des Konstruktors Geht natürlich nur bei passenden Werten! 1 x = 42 + int("42") 2 y = 42 + int("abc") 3 print("hallo " + 1) Implizit Implizite Type casts haben allerdings kaum Sinn Lediglich bei numerischen Typen zwischen floats und ints Und generell: explicit is better than implicit 1 print(type( )) <class float > Typen und Klassen? Klassen sind Typen! Für Werte und Variablen Typen, Klassen und Vererbung? Verhältnis von Klassenhierarchien und typisierten Variablen? Insbesondere: Wie schlägt sich das is-a-prinzip nieder? Unterklasse und Oberklasse mit zusätzlicher Eigenschaft Zunächst: Visualisieren wir das Verhältnis von Ober- und Unterklasse Unterklasse ist Oberklasse mit zusätzlicher Eigenschaft

11 15.4. Statisch typisierte Sprachen Grundkonzepte 11 Abbildung 15.6: Verhältnis von Ober- und Unterklasse als Typen Wert einer Oberklasse an Variable vom Typ Unterklasse zuweisen Was würde das bedeutet? Variable vom Typ Unterklasse verspricht: Ich enthalte ein Objekt dieser Unterklasse Alle Attribute (Methoden, Daten) der Unterklasse verfügbar Ein Objekt der Oberklasse hat diese Attribute aber nicht! Versprechen des Variablentyps würde gebrochen! Also: So eine Zuweisung darf nicht gelingen! Abbildung 15.7: Zuweisung Oberklasenobjekt an Unterklasse-Variable scheitert Wert einer Unterklasse an Variable vom Typ Oberklasse zuweisen Das Objekt der Unterklasse is-a Objekt der Oberklasse! Substitutionsprinzip: Objekte Unterklasse immer dort verwendbar, wo auch Objekt Oberklasse verwendbar Also sollte das gelingen! Variable vom Typ Oberklasse macht schwächere Versprechen! Wert einer Unterklasse an Variable vom Typ Oberklasse zuweisen (2) Funktionsaufrufe: Parameter, Rückgabewerte Funktionen: Parameter bekommen einen Typ Rückgabewert bekommt Typ (ggf. den leeren Typ) Aufruf einer Funktion: Zuweisung von Werten an die formalen Parameter

12 12 Liste von Definitionen u.ä. Abbildung 15.8: Zuweisung Unterklassenobjekt an Oberklassen-Variable gelingt Rückgabewert wird an Variable zugewiesen Unterliegt obigen Regeln Und Methoden sind sowieso nur Funktionen 15.5 Vergleich: Dynamisch vs. statisch typisierte Sprachen Vorteile statischer Typsysteme Typische Vorteile: Fehlerdetektion: Compiler kann manche Fehler finden Dokumentation durch Typen Optimierung: Keine Prüfung der Typen zur Laufzeit nötig! Compiler kann Information über Typen nutzen, um besseren Code zu erzeugen Werkzeuge: Können Typinformationen nutzen Beispiel IDE: die verfügbaren Methoden für eine Variable vorschlagen Nachteile statischer Typsysteme Komplizierte Typspezifikation Eigentlich: eine zweite Sprache, um Datentypen zu beschreiben Kann extrem kompliziert werden (Java: geht so; C++: Alptraum) Korrektheit nicht unbedingt klar Typsystem kann sinnlose Zuweisungen erlauben Ossification Siehe Details

13 15.6. Zusammenfassung Das Beste zweier Welten? Kombinationen der Ansätze? Einer dynamisch typisierten Sprache etwas mehr statische Typinformation beibringen? Ansätze dazu für Python Eine statisch typisierte Sprache dynamischer machen? Schwierig In gewissem Sinne: Reflection 15.6 Zusammenfassung Zusammenfassung Und nun? Dynamische und statisch typisierte Sprachen haben Berechtigung und Einsatzgebiet Statisch typisiert in der Regel erheblich komplexere Syntax und Semantik Dafür unter Umständen bessere Garantien, Verlässlichkeit der Programme Abbildung 15.9: Java is coming!