5
Inhaltsverzeichnis
Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Warum Python? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Python 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
An wen wendet sich dieses Buch? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Inhalt und Aufbau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
Hinweise zur Typographie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
Programmbeispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
1 Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
1.1 Was ist Programmieren? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
1.2 Hardware und Software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
1.3 Programm als Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
1.4 Syntax und Semantik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
1.5 Interpreter und Compiler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
1.6 Programmierparadigmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
1.7 Objektorientierte Programmierung . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
1.7.1 Strukturelle Zerlegung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
1.7.2 Die Welt als System von Objekten . . . . . . . . . . . . . . . . . . . . . . 34
1.7.3 Objekte besitzen Attribute und beherrschen Methoden . . . . 35
1.7.4 Objekte sind Instanzen von Klassen . . . . . . . . . . . . . . . . . . . . 36
1.8 Hintergrund: Geschichte der objektorientierten
Programmierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
1.9 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
1.10 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
2 Der Einstieg – Python im interaktiven Modus . . . . . . . . . . . . . . . . . . . 39
2.1 Python installieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
2.2 Python im interaktiven Modus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
2.2.1 Start des Python-Interpreters in einem Konsolenfenster . . . 42
2.2.2 Die Python-Shell von IDLE . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
2.2.3 Die ersten Python-Befehle ausprobieren . . . . . . . . . . . . . . . . 43
2.2.4 Hotkeys . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
2.3 Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Inhaltsverzeichnis
6
2.4 Namen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
2.5 Hintergrund: Syntax-Regeln für Bezeichner . . . . . . . . . . . . . . . . . . . 47
2.6 Schlüsselwörter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
2.7 Anweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
2.7.1 Ausdruckanweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
2.7.2 Import-Anweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
2.7.3 Zuweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
2.7.4 Erweiterte Zuweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
2.7.5 Hintergrund: Dynamische Typisierung . . . . . . . . . . . . . . . . 59
2.8 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
2.9 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
3 Python-Skripte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
3.1 Skripte editieren und ausführen mit IDLE . . . . . . . . . . . . . . . . . . . . . 65
3.2 Ausführen eines Python-Skripts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
3.3 Kommentare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
3.4 Die Zeilenstruktur von Python-Programmen . . . . . . . . . . . . . . . . . . 69
3.5 Das EVA-Prinzip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
3.6 Phasen der Programmentwicklung . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
3.7 Guter Programmierstil . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
3.8 Hintergrund: Die Kunst des Fehlerfindens . . . . . . . . . . . . . . . . . . . . 78
3.9 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
3.10 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
4 Standard-Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
4.1 Daten als Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
4.2 Fundamentale Datentypen im Überblick . . . . . . . . . . . . . . . . . . . . . . 85
4.3 Typen und Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
4.4 NoneType . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
4.5 Wahrheitswerte – der Datentyp bool . . . . . . . . . . . . . . . . . . . . . . . . . . 87
4.6 Ganze Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
4.7 Gleitkommazahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
4.8 Komplexe Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
4.9 Arithmetische Operatoren für Zahlen . . . . . . . . . . . . . . . . . . . . . . . . 92
4.10 Sequenzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
4.10.1 Zeichenketten (Strings) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
4.10.2 Bytestrings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
4.10.3 Tupel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Inhaltsverzeichnis
7
4.10.4 Liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
4.10.5 Bytearray . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
4.10.6 Einige Grundoperationen für Sequenzen . . . . . . . . . . . . . . . . 103
4.10.7 Veränderbare und unveränderbare Sequenzen . . . . . . . . . . . 106
4.11 Mengen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
4.12 Dictionaries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
4.13 Typumwandlungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
4.13.1 int() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
4.13.2 float() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
4.13.3 complex() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
4.13.4 bool() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
4.13.5 str() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
4.13.6 dict(), list() und tuple() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
4.14 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
4.15 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
5 Kontrollstrukturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
5.1 Einfache Bedingungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
5.1.1 Vergleiche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
5.1.2 Zugehörigkeit zu einer Menge (in, not in) . . . . . . . . . . . . . . . 123
5.1.3 Beliebige Ausdrücke als Bedingungen . . . . . . . . . . . . . . . . . . 123
5.2 Zusammengesetzte Bedingungen – logische Operatoren . . . . . . . . . 124
5.2.1 Negation (not) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
5.2.2 Konjunktion (and) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
5.2.3 Disjunktion (or) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
5.2.4 Formalisierung von Bedingungen . . . . . . . . . . . . . . . . . . . . . . 127
5.2.5 Hinweis zum Programmierstil . . . . . . . . . . . . . . . . . . . . . . . . 128
5.3 Programmverzweigungen (bedingte Anweisungen) . . . . . . . . . . . . . . 128
5.3.1 Einseitige Verzweigung (if) . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
5.3.2 Zweiseitige Verzweigung (if-else) . . . . . . . . . . . . . . . . . . . . . . 129
5.3.3 Mehrfache Fallunterscheidung (elif) . . . . . . . . . . . . . . . . . . . . 130
5.3.4 Bedingte Ausdrücke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
5.4 Bedingte Wiederholung (while) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
5.4.1 Endlosschleifen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
5.5 Iteration über eine Kollektion (for) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
5.5.1 Zählschleifen – Verwendung von range() . . . . . . . . . . . . . . . . 136
5.5.2 Verschachtelte Iterationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
5.5.3 Vertiefung: Iterative Berechnung rekursiver Folgen . . . . . . . 139
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Inhaltsverzeichnis
8
5.6 Abbruch einer Schleife mit break . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
5.6.1 Abbruch eines Schleifendurchlaufs mit continue . . . . . . . . 140
5.7 Abfangen von Ausnahmen mit try . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
5.7.1 try...except . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
5.8 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
5.9 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
6 Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
6.1 Aufruf von Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
6.2 Definition von Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
6.3 Schrittweise Verfeinerung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
6.4 Ausführung von Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
6.4.1 Globale und lokale Namen . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
6.4.2 Seiteneffekte – die global-Anweisung . . . . . . . . . . . . . . . . . . 165
6.4.3 Parameterübergabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
6.5 Voreingestellte Parameterwerte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
6.5.1 Schlüsselwort-Argumente . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
6.6 Funktionen mit beliebiger Anzahl von Parametern . . . . . . . . . . . . . 172
6.7 Lokale Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
6.8 Rekursive Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
6.9 Experimente zur Rekursion mit der Turtle-Grafik . . . . . . . . . . . . . . . 176
6.9.1 Turtle-Befehle im interaktiven Modus . . . . . . . . . . . . . . . . . 176
6.9.2 Eine rekursive Spirale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
6.9.3 Baumstrukturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
6.9.4 Künstlicher Blumenkohl – selbstähnliche Bilder . . . . . . . . . 180
6.10 Rekursive Zahlenfunktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
6.11 Hintergrund: Wie werden rekursive Funktionen ausgeführt? . . . . . 183
6.11.1 Execution Frames . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
6.11.2 Rekursionstiefe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
6.12 Funktionen als Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
6.12.1 Hintergrund: Typen sind keine Funktionen . . . . . . . . . . . . . 187
6.13 Lambda-Formen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
6.14 Hinweise zum Programmierstil . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
6.14.1 Allgemeines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
6.14.2 Funktionsnamen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
6.14.3 Kommentierte Parameter . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
6.14.4 Docstrings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Inhaltsverzeichnis
9
6.15 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
6.16 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
7 Sequenzen, Mengen und Generatoren . . . . . . . . . . . . . . . . . . . . . . . . . 197
7.1 Gemeinsame Operationen für Sequenzen . . . . . . . . . . . . . . . . . . . . . . 197
7.1.1 Zugriff auf Elemente einer Sequenz . . . . . . . . . . . . . . . . . . . . 198
7.1.2 Slicing von Sequenzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
7.1.3 Auspacken (unpacking) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
7.2 Vertiefung: Rekursive Funktionen für Sequenzen . . . . . . . . . . . . . . . 201
7.2.1 Rekursives Summieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
7.2.2 Rekursive Suche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
7.3 Tupel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
7.4 Listen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204
7.4.1 Eine Liste erzeugen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205
7.4.2 Eine Liste verändern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207
7.4.3 Flache und tiefe Kopien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
7.4.4 Listen sortieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210
7.4.5 Binäre Suche in einer sortierten Liste . . . . . . . . . . . . . . . . . . . 212
7.4.6 Zwei Sortierverfahren im Vergleich . . . . . . . . . . . . . . . . . . . . 213
7.4.7 Modellieren mit Listen – Beispiel: die Charts . . . . . . . . . . . . 217
7.5 Generatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
7.5.1 Generatorausdrücke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
7.5.2 Generatorfunktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
7.5.3 Iteratoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224
7.5.4 Verwendung von Generatoren . . . . . . . . . . . . . . . . . . . . . . . . . 225
7.6 Mengen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
7.6.1 Operationen für Mengen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
7.6.2 Modellieren mit Mengen – Beispiel: Graphen . . . . . . . . . . . . 228
7.7 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231
7.8 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
8 Dictionaries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237
8.1 Operationen für Dictionaries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237
8.2 Wie erstellt man ein Dictionary? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238
8.2.1 Definition mit einem Dictionary-Display . . . . . . . . . . . . . . . . 238
8.2.2 Schrittweiser Aufbau eines Dictionarys . . . . . . . . . . . . . . . . . 240
8.2.3 Ein Dictionary aus anderen Dictionaries zusammensetzen – update() . . . . . . . . . . . . . . . . . . . . . . . . . . 241
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Inhaltsverzeichnis
10
8.3 Zugriff auf Daten in einem Dictionary . . . . . . . . . . . . . . . . . . . . . . . . 241
8.3.1 Vergebliche Zugriffsversuche . . . . . . . . . . . . . . . . . . . . . . . . 241
8.4 Praxisbeispiel: Vokabeltrainer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242
8.5 Typische Fehler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244
8.6 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244
8.7 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247
9 Ein- und Ausgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251
9.1 Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251
9.1.1 Die Rolle der Files bei E/A-Operationen . . . . . . . . . . . . . . . . 251
9.1.2 Was ist ein File? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252
9.1.3 Ein File-Objekt erzeugen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253
9.1.4 Speichern einer Zeichenkette . . . . . . . . . . . . . . . . . . . . . . . . 254
9.1.5 Laden einer Zeichenkette aus einer Datei . . . . . . . . . . . . . . . 255
9.1.6 Absolute und relative Pfade . . . . . . . . . . . . . . . . . . . . . . . . . . 255
9.1.7 Zwischenspeichern, ohne zu schließen . . . . . . . . . . . . . . . . 258
9.1.8 Zugriff auf Files (lesen und schreiben) . . . . . . . . . . . . . . . . . 258
9.1.9 Speichern beliebiger Daten auf Files . . . . . . . . . . . . . . . . . . . 260
9.2 Mehr Zuverlässigkeit durch try- und with-Anweisungen . . . . . . . . . 261
9.2.1 try...finally . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262
9.2.2 With-Anweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263
9.3 Objekte speichern mit pickle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264
9.3.1 Funktionen zum Speichern und Laden . . . . . . . . . . . . . . . . . 265
9.4 Die Pseudofiles sys.stdin und sys.stdout . . . . . . . . . . . . . . . . . . . . . . 266
9.5 Ausgabe von Werten mit der print()-Funktion . . . . . . . . . . . . . . . . . 267
9.5.1 Anwendung: Ausgabe von Tabellen . . . . . . . . . . . . . . . . . . . 269
9.6 Kommandozeilen-Argumente (Optionen) . . . . . . . . . . . . . . . . . . . . . 269
9.7 Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272
9.8 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275
10 Definition eigener Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281
10.1 Klassen und Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281
10.2 Definition von Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283
10.3 Objekte (Instanzen) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285
10.4 Zugriff auf Attribute – Sichtbarkeit . . . . . . . . . . . . . . . . . . . . . . . . . . 288
10.4.1 Öffentliche Attribute . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288
10.4.2 Private Attribute . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289
10.4.3 Properties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291
10.4.4 Dynamische Erzeugung von Attributen . . . . . . . . . . . . . . . . 293
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Inhaltsverzeichnis
11
10.5 Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293
10.5.1 Polymorphismus – Überladen von Operatoren . . . . . . . . . . . 294
10.6 Statische Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298
10.7 Abstraktion, Verkapselung und Geheimnisprinzip . . . . . . . . . . . . . . . 299
10.8 Vererbung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300
10.8.1 Spezialisierungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300
10.8.2 Beispiel: Die Klasse Konto – eine Spezialisierung der Klasse Geld . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301
10.8.3 Vertiefung: Standardklassen als Basisklassen . . . . . . . . . . . . 304
10.9 Hinweise zum Programmierstil . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306
10.9.1 Bezeichner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306
10.9.2 Sichtbarkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306
10.9.3 Dokumentation von Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . 308
10.10 Typische Fehler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308
10.11 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310
10.12 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313
11 Klassenbibliotheken in Modulen speichern . . . . . . . . . . . . . . . . . . . . . 319
11.1 Testen einer Klasse in einem lauffähigen Stand-alone-Skript . . . . . . 319
11.2 Module speichern und importieren . . . . . . . . . . . . . . . . . . . . . . . . . . . 321
11.3 Den Zugang zu einem Modul sicherstellen . . . . . . . . . . . . . . . . . . . . . 323
11.4 Programmierstil: Verwendung und Dokumentation von Modulen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325
12 Objektorientiertes Modellieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327
12.1 Phasen einer objektorientierten Software-Entwicklung . . . . . . . . . . . 327
12.2 Fallstudie: Modell eines Wörterbuchs . . . . . . . . . . . . . . . . . . . . . . . . . 328
12.2.1 OOA: Entwicklung einer Klassenstruktur . . . . . . . . . . . . . . . 328
12.2.2 OOD: Entwurf einer Klassenstruktur für eine Implementierung in Python . . . . . . . . . . . . . . . . . . . . . . . . . . 332
12.2.3 OOP: Implementierung der Klassenstruktur . . . . . . . . . . . . 334
12.3 Assoziationen zwischen Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338
12.3.1 Reflexive Assoziationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338
12.3.2 Aggregation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 340
12.4 Beispiel: Management eines Musicals . . . . . . . . . . . . . . . . . . . . . . . . . 341
12.4.1 OOA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341
12.4.2 OOD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343
12.4.3 OOP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Inhaltsverzeichnis
12
12.5 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353
12.6 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354
13 Verarbeitung von Zeichenketten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359
13.1 Standardmethoden zur Verarbeitung von Zeichenketten . . . . . . . . . 359
13.1.1 Formatieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360
13.1.2 Schreibweise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360
13.1.3 Tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361
13.1.4 Entfernen und Aufspalten . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
13.1.5 Suchen und Ersetzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363
13.2 Codierung und Decodierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363
13.2.1 Platonische Zeichen und Unicode . . . . . . . . . . . . . . . . . . . . . 363
13.2.2 Vertiefung: Zeichenketten durch Bytefolgen darstellen . . . 365
13.3 Automatische Textproduktion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367
13.3.1 Texte mit variablen Teilen – Anwendung der
String-Methode
format() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367
13.3.2 Vertiefung: Eine Tabelle erstellen . . . . . . . . . . . . . . . . . . . . . 370
13.3.3 Mahnbriefe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371
13.3.4 Textuelle Repräsentation eines Objektes . . . . . . . . . . . . . . . . 372
13.3.5 F-Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374
13.4 Analyse von Texten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375
13.4.1 Chat Bots . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375
13.4.2 Textanalyse mit einfachen Vorkommenstests . . . . . . . . . . . 376
13.5 Reguläre Ausdrücke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
13.5.1 Aufbau eines regulären Ausdrucks . . . . . . . . . . . . . . . . . . . . 379
13.5.2 Objekte für reguläre Ausdrücke (RE-Objekte) . . . . . . . . . . . 382
13.5.3 Analyse von Strings mit match() und search() . . . . . . . . . . . 383
13.5.4 Textpassagen extrahieren mit findall() . . . . . . . . . . . . . . . . . 384
13.5.5 Zeichenketten zerlegen mit split() . . . . . . . . . . . . . . . . . . . . . 385
13.5.6 Teilstrings ersetzen mit sub() . . . . . . . . . . . . . . . . . . . . . . . . 386
13.5.7 Match-Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387
13.6 Den Computer zum Sprechen bringen – Sprachsynthese . . . . . . . . 389
13.6.1 Buchstabieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 391
13.6.2 Den Klang der Stimme verändern . . . . . . . . . . . . . . . . . . . . 393
13.7 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396
13.8 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 399
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Inhaltsverzeichnis
13
14 Systemfunktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 407
14.1 Das Modul sys – die Schnittstelle zum Laufzeitsystem . . . . . . . . . . . . 407
14.1.1 Informationen über die aktuelle Systemumgebung . . . . . . . 408
14.1.2 Standardeingabe und -ausgabe . . . . . . . . . . . . . . . . . . . . . . . . 409
14.1.3 Die Objektverwaltung beobachten mit getrefcount() . . . . . . . 410
14.1.4 Ausführung eines Skripts beenden . . . . . . . . . . . . . . . . . . . . . 411
14.2 Das Modul os – die Schnittstelle zum Betriebssystem . . . . . . . . . . . . 411
14.2.1 Dateien und Verzeichnisse suchen . . . . . . . . . . . . . . . . . . . . . 412
14.2.2 Hintergrund: Zugriffsrechte abfragen und ändern (Windows und Unix) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413
14.2.3 Dateien und Verzeichnisse anlegen und modifizieren . . . . . 415
14.2.4 Merkmale von Dateien und Verzeichnissen abfragen . . . . . . 416
14.2.5 Pfade verarbeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417
14.2.6 Hintergrund: Umgebungsvariablen . . . . . . . . . . . . . . . . . . . . 419
14.2.7 Systematisches Durchlaufen eines Verzeichnisbaumes . . . . 420
14.3 Datum und Zeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 422
14.3.1 Funktionen des Moduls time . . . . . . . . . . . . . . . . . . . . . . . . . . 422
14.3.2 Sekundenformat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 423
14.3.3 Zeit-Tupel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424
14.3.4 Zeitstrings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 425
14.3.5 Einen Prozess unterbrechen mit sleep() . . . . . . . . . . . . . . . . . 426
14.4 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426
14.5 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 427
15 Grafische Benutzungsoberflächen mit tkinter . . . . . . . . . . . . . . . . . . . 433
15.1 Ein einführendes Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434
15.2 Einfache Widgets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 437
15.3 Die Master-Slave-Hierarchie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 438
15.4 Optionen der Widgets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 439
15.4.1 Optionen bei der Instanziierung setzen . . . . . . . . . . . . . . . . . 439
15.4.2 Widget-Optionen nachträglich konfigurieren . . . . . . . . . . . . 440
15.4.3 Fonts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 441
15.4.4 Farben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 442
15.4.5 Rahmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443
15.4.6 Die Größe eines Widgets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443
15.4.7 Leerraum um Text . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445
15.5 Gemeinsame Methoden der Widgets . . . . . . . . . . . . . . . . . . . . . . . . . . 446
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Inhaltsverzeichnis
14
15.6 Die Klasse Tk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 447
15.7 Die Klasse Button . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 447
15.8 Die Klasse Label . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 448
15.8.1 Dynamische Konfiguration der Beschriftung . . . . . . . . . . . . 448
15.8.2 Verwendung von Kontrollvariablen . . . . . . . . . . . . . . . . . . . . 449
15.9 Die Klasse Entry . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 451
15.10 Die Klasse Radiobutton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 453
15.11 Die Klasse Checkbutton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 455
15.12 Die Klasse Scale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 457
15.13 Die Klasse Frame . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 459
15.14 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 459
15.15 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 461
16 Layout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 467
16.1 Der Packer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 467
16.2 Layout-Fehler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 469
16.3 Raster-Layout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 470
16.4 Vorgehensweise bei der GUI-Entwicklung . . . . . . . . . . . . . . . . . . . . 474
16.4.1 Die Benutzungsoberfläche gestalten . . . . . . . . . . . . . . . . . . . 477
16.4.2 Funktionalität hinzufügen . . . . . . . . . . . . . . . . . . . . . . . . . . . 480
16.5 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 481
16.6 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 484
17 Grafik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 495
17.1 Die tkinter-Klasse Canvas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 495
17.1.1 Generierung grafischer Elemente – ID, Positionierung und Display-Liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 496
17.1.2 Grafische Elemente gestalten . . . . . . . . . . . . . . . . . . . . . . . . . 498
17.1.3 Visualisieren mit Kreisdiagrammen . . . . . . . . . . . . . . . . . . . 500
17.2 Die Klasse PhotoImage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 503
17.2.1 Eine Pixelgrafik erzeugen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 504
17.2.2 Fotos analysieren und verändern . . . . . . . . . . . . . . . . . . . . . . 506
17.3 Bilder in eine Benutzungsoberfläche einbinden . . . . . . . . . . . . . . . . 509
17.3.1 Icons auf Schaltflächen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 509
17.3.2 Hintergrundbilder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 510
17.3.3 Hintergrund: Das PPM-Format . . . . . . . . . . . . . . . . . . . . . . . 512
17.4 Die Python Imaging Library (PIL) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 513
17.4.1 Installation eines Moduls mit pip . . . . . . . . . . . . . . . . . . . . . 513
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Inhaltsverzeichnis
15
17.4.2 Mit PIL beliebige Bilddateien einbinden . . . . . . . . . . . . . . . . 514
17.4.3 Steganografie – Informationen in Bildern verstecken . . . . . . 515
17.5 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 517
17.6 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 518
18 Event-Verarbeitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 523
18.1 Einführendes Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 524
18.2 Event-Sequenzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 526
18.2.1 Event-Typen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 526
18.2.2 Qualifizierer für Maus- und Tastatur-Events . . . . . . . . . . . . . 526
18.2.3 Modifizierer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 528
18.3 Beispiel: Tastaturereignisse verarbeiten . . . . . . . . . . . . . . . . . . . . . . . . 528
18.4 Programmierung eines Eventhandlers . . . . . . . . . . . . . . . . . . . . . . . . . 530
18.4.1 Beispiel für eine Event-Auswertung . . . . . . . . . . . . . . . . . . . . 531
18.5 Bindemethoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 532
18.6 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 532
18.7 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 535
19 Komplexe Benutzungsoberflächen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 541
19.1 Text-Widgets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 541
19.1.1 Methoden der Text-Widgets . . . . . . . . . . . . . . . . . . . . . . . . . . . 542
19.2 Rollbalken (Scrollbars) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 544
19.3 Menüs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 546
19.3.1 Die Klasse Menu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 546
19.3.2 Methoden der Klasse Menu . . . . . . . . . . . . . . . . . . . . . . . . . . . 547
19.4 Texteditor mit Menüleiste und Pulldown-Menü . . . . . . . . . . . . . . . . . 548
19.5 Dialogboxen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 550
19.6 Applikationen mit mehreren Fenstern . . . . . . . . . . . . . . . . . . . . . . . . . 554
19.7 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 557
19.8 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 558
20 Threads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 563
20.1 Funktionen in einem Thread ausführen . . . . . . . . . . . . . . . . . . . . . . . 564
20.2 Thread-Objekte erzeugen – die Klasse Thread . . . . . . . . . . . . . . . . . . . 566
20.3 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 569
20.4 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 570
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Inhaltsverzeichnis
16
21 Fehler finden und vermeiden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 575
21.1 Testen von Bedingungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 575
21.1.1 Ausnahmen (Exceptions) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 575
21.1.2 Testen von Vor- und Nachbedingungen mit assert . . . . . . . 576
21.1.3 Vertiefung: Programmabstürze ohne Fehlermeldung . . . . . 579
21.2 Debugging-Modus und optimierter Modus . . . . . . . . . . . . . . . . . . . . 581
21.3 Ausnahmen gezielt auslösen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 582
21.4 Selbstdokumentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 583
21.5 Dokumentation eines Programmlaufs mit Log-Dateien . . . . . . . . . 585
21.5.1 Grundfunktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 585
21.5.2 Beispiel: Logging in der GUI-Programmierung . . . . . . . . . . 586
21.6 Vertiefung: Professionelles Arbeiten mit Logging . . . . . . . . . . . . . . . 587
21.6.1 Logging-Levels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 587
21.6.2 Logger-Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 592
21.6.3 Das Format der Logging-Meldungen konfigurieren . . . . . . 592
21.7 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594
21.8 Aufgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 595
21.9 Lösung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 596
22 CGI-Programmierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 597
22.1 Wie funktionieren CGI-Skripte? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 597
22.2 Wie spät ist es? Aufbau eines CGI-Skripts . . . . . . . . . . . . . . . . . . . . . 599
22.2.1 Ein einfacher HTTP-Server . . . . . . . . . . . . . . . . . . . . . . . . . . 602
22.2.2 Hintergrund: CGI-Skripte auf einem Host im Internet installieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 603
22.3 Kommunikation über interaktive Webseiten . . . . . . . . . . . . . . . . . . . 604
22.3.1 Aufbau eines HTML-Formulars . . . . . . . . . . . . . . . . . . . . . . 605
22.3.2 Eingabekomponenten in einem HTML-Formular . . . . . . . . 606
22.4 Verarbeitung von Eingabedaten in einem CGI-Skript . . . . . . . . . . . . 608
22.5 Sonderzeichen handhaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 610
22.6 CGI-Skripte debuggen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 611
22.7 Objektorientierte CGI-Skripte – Beispiel: ein Chatroom . . . . . . . . . . 612
22.8 CGI-Skripte mit Cookies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 618
22.9 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 621
22.10 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 623
23 Internet-Programmierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 629
23.1 Was ist ein Protokoll? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 629
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Inhaltsverzeichnis
17
23.2 Übertragung von Dateien mit FTP . . . . . . . . . . . . . . . . . . . . . . . . . . . . 630
23.2.1 Das Modul ftplib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 631
23.2.2 Navigieren und Downloaden . . . . . . . . . . . . . . . . . . . . . . . . . 632
23.2.3 Ein Suchroboter für FTP-Server . . . . . . . . . . . . . . . . . . . . . . . 634
23.3 Zugriff auf Webseiten mit HTTP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 638
23.3.1 Automatische Auswertung von Webseiten . . . . . . . . . . . . . . . 640
23.4 E-Mails senden mit SMTP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 642
23.5 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 645
23.6 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 647
24 Datenbanken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 653
24.1 Was ist ein Datenbanksystem? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 653
24.2 Entity-Relationship-Diagramme (ER-Diagramme) . . . . . . . . . . . . . . . 654
24.3 Relationale Datenbanken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 655
24.4 Darstellung von Relationen als Listen oder Dictionaries . . . . . . . . . . 656
24.5 Das Modul sqlite3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 657
24.5.1 Eine Tabelle anlegen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 657
24.5.2 Anfragen an eine Datenbank . . . . . . . . . . . . . . . . . . . . . . . . . . 659
24.5.3 SQL-Anweisungen mit variablen Teilen . . . . . . . . . . . . . . . . . 660
24.5.4 SQL-Injections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 661
24.6 Online-Redaktionssystem mit Datenbankanbindung . . . . . . . . . . . . . 662
24.6.1 Objektorientierte Analyse (OOA) . . . . . . . . . . . . . . . . . . . . . . . 664
24.6.2 Objektorientierter Entwurf des Systems (OOD) . . . . . . . . . . . 664
24.6.3 Hintergrund: Authentifizieren mit MD5-Fingerprints . . . . . 666
24.6.4 Implementierung des Redaktionssystems mit Python (OOP) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 667
24.7 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 676
24.8 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 677
25 Testen und Tuning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 681
25.1 Automatisiertes Testen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 681
25.2 Testen mit Docstrings – das Modul doctest . . . . . . . . . . . . . . . . . . . . . 682
25.3 Praxisbeispiel: Suche nach dem Wort des Jahres . . . . . . . . . . . . . . . . 684
25.4 Klassen testen mit doctest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 691
25.4.1 Wie testet man eine Klasse? . . . . . . . . . . . . . . . . . . . . . . . . . . . 691
25.4.2 Normalisierte Whitespaces – doctest-Direktiven . . . . . . . . . . 692
25.4.3 Ellipsen verwenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 692
25.4.4 Dictionaries testen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 693
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Inhaltsverzeichnis
18
25.5 Gestaltung von Testreihen mit unittest . . . . . . . . . . . . . . . . . . . . . . . 693
25.5.1 Einführendes Beispiel mit einem Testfall . . . . . . . . . . . . . . . 693
25.5.2 Klassen des Moduls unittest . . . . . . . . . . . . . . . . . . . . . . . . . . 695
25.5.3 Weiterführendes Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . 697
25.6 Tuning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 701
25.6.1 Performance-Analyse mit dem Profiler . . . . . . . . . . . . . . . . . 701
25.6.2 Praxisbeispiel: Auswertung astronomischer Fotografien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 703
25.6.3 Performance-Analyse und Tuning . . . . . . . . . . . . . . . . . . . . . 709
25.7 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 710
25.8 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 712
26 XML und JSON . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 719
26.1 Was ist XML? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 719
26.2 XML-Dokumente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 720
26.3 Ein XML-Dokument als Baum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 722
26.4 DOM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 723
26.5 Das Modul xml.dom.minidom . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 726
26.5.1 XML-Dokumente und DOM-Objekte . . . . . . . . . . . . . . . . . . 726
26.5.2 Die Basisklasse Node . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 728
26.5.3 Die Klassen Document, Element und Text . . . . . . . . . . . . . . 730
26.6 Attribute von XML-Elementen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 732
26.7 Anwendungsbeispiel 1: Eine XML-basierte Klasse . . . . . . . . . . . . . . . 732
26.8 Anwendungsbeispiel 2: Datenkommunikation mit XML . . . . . . . . . 735
26.8.1 Überblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 736
26.8.2 Das Client-Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 737
26.8.3 Das Server-Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 740
26.9 JSON . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 744
26.9.1 JSON-Texte decodieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 745
26.9.2 Decodierungsfehler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 746
26.9.3 Ein Dictionary als JSON-Objekt speichern: Kompakt oder gut lesbar? . . . . . . . . . . . . . . . . . . . . . . . . . . . 746
26.9.4 Projekt: Verarbeitung von Wetterdaten . . . . . . . . . . . . . . . . . 749
26.10 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 752
26.11 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 753
27 Modellieren mit Kellern, Schlangen und Graphen . . . . . . . . . . . . . . 755
27.1 Stack (Keller, Stapel) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 755
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Inhaltsverzeichnis
19
27.2 Queue (Schlange) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 758
27.3 Graphen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 759
27.4 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 769
27.5 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 771
28 Benutzungsoberflächen mit Qt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 775
28.1 Was bietet PyQT5? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 775
28.1.1 PyQt5 erkunden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 776
28.2 Wie arbeitet PyQt? Applikation und Fenster . . . . . . . . . . . . . . . . . . . . 776
28.3 Eine objektorientierte Anwendung mit PyQt5 . . . . . . . . . . . . . . . . . . . 777
28.4 Ein Webbrowser . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 778
28.5 Interaktive Widgets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 781
28.6 Label – Ausgabe von Text und Bild . . . . . . . . . . . . . . . . . . . . . . . . . . . . 783
28.7 Signale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 784
28.8 Checkboxen und Radiobuttons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 785
28.9 Auswahlliste (ComboBox) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 788
28.10 Gemeinsame Operationen der Widgets . . . . . . . . . . . . . . . . . . . . . . . . 790
28.11 Spezielle Methoden eines Fensters . . . . . . . . . . . . . . . . . . . . . . . . . . . . 791
28.12 Events . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 793
28.13 Fonts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 794
28.14 Stylesheets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 796
28.15 Icons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 799
28.16 Messageboxen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 799
28.17 Timer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 800
28.18 Das Qt-Layout unter der Lupe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 802
28.18.1 Absolute Positionierung und Größe . . . . . . . . . . . . . . . . . . . . 803
28.18.2 Raster-Layout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 804
28.18.3 Form-Layout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 805
28.19 Browser für jeden Zweck . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 807
28.19.1 Die Klasse QWebEngineView . . . . . . . . . . . . . . . . . . . . . . . . . 808
28.20 Ein Webbrowser mit Filter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 808
28.21 Surfen mit Geschichte – der Verlauf einer Sitzung . . . . . . . . . . . . . . 810
28.22 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 812
28.23 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 813
29 Multimediaanwendungen mit Qt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 819
29.1 Kalender und Textfeld – ein digitales Tagebuch . . . . . . . . . . . . . . . . . 819
29.1.1 Programmierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 820
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Inhaltsverzeichnis
20
29.2 Kamerabilder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 825
29.3 Dialoge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 827
29.3.1 Projekt Ansichtskarte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 829
29.4 Videoplayer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 833
29.4.1 Ein einfacher Videoplayer . . . . . . . . . . . . . . . . . . . . . . . . . . . . 833
29.4.2 Videoplayer mit Playlist . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 837
29.4.3 Regeln zur Änderung der Größe (Size Policy) . . . . . . . . . . . 840
29.4.4 Das Dashboard bei Mausbewegungen einblenden . . . . . . . 841
29.5 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 844
29.6 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 848
30 Rechnen mit NumPy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 857
30.1 NumPy installieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 857
30.2 Arrays erzeugen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 857
30.2.1 Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 858
30.2.2 Matrizen und Vektoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 860
30.2.3 Zahlenfolgen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 860
30.2.4 Zufallsarrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 861
30.2.5 Spezielle Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 862
30.3 Indizieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 863
30.4 Slicing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 864
30.5 Arrays verändern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 865
30.6 Arithmetische Operationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 867
30.7 Funktionen, die elementweise ausgeführt werden . . . . . . . . . . . . . . 868
30.8 Einfache Visualisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 869
30.9 Matrizenmultiplikation mit dot() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 870
30.10 Array-Funktionen und Achsen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 871
30.11 Projekt: Diffusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 873
30.12 Vergleiche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 876
30.13 Projekt: Wolken am Himmel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 876
30.14 Projekt: Wie versteckt man ein Buch in einem Bild? . . . . . . . . . . . . 879
30.15 Datenanalyse mit Histogrammen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 882
30.16 Wie funktioniert ein Medianfilter? . . . . . . . . . . . . . . . . . . . . . . . . . . . 885
30.17 Rechnen mit SciPy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 888
30.17.1 Lineare Gleichungssysteme lösen . . . . . . . . . . . . . . . . . . . . . 888
30.17.2 Integration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 890
30.18 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 891
30.19 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 894
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Inhaltsverzeichnis
21
31 Messdaten verarbeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 899
31.1 Messwerte in einem Diagramm darstellen – Matplotlib und tkinter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 899
31.1.1 Basisprojekt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 899
31.1.2 Erweiterung: Den letzten Wert löschen . . . . . . . . . . . . . . . . . 903
31.1.3 Das Aussehen eines Diagramms gestalten . . . . . . . . . . . . . . . 905
31.2 Messwerte aus einem Multimeter lesen und darstellen . . . . . . . . . . . 908
31.2.1 Vorbereitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 908
31.2.2 Werte auslesen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 909
31.2.3 Welche Ziffern zeigt das Display des Multimeters? . . . . . . . . 912
31.3 Anzeige der Temperatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 916
31.4 Messreihen aufzeichnen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 918
31.5 Aufgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 921
31.6 Lösung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 921
32 Parallele Datenverarbeitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 925
32.1 Was sind parallele Programme? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 925
32.2 Prozesse starten und abbrechen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 926
32.3 Funktionen in eigenen Prozessen starten . . . . . . . . . . . . . . . . . . . . . . 927
32.4 Prozesse zusammenführen – join() . . . . . . . . . . . . . . . . . . . . . . . . . . . 929
32.5 Wie können Prozesse Objekte austauschen? . . . . . . . . . . . . . . . . . . . 929
32.5.1 Objekte als Argumente übergeben . . . . . . . . . . . . . . . . . . . . . 929
32.5.2 Objekte über eine Pipe senden und empfangen . . . . . . . . . . 930
32.5.3 Objekte über eine Queue austauschen . . . . . . . . . . . . . . . . . . 931
32.6 Daten im Pool bearbeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 932
32.6.1 Mit dem Pool geht’s schneller – ein Zeitexperiment . . . . . . . 933
32.6.2 Forschen mit Big Data aus dem Internet . . . . . . . . . . . . . . . . 934
32.7 Synchronisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 937
32.8 Produzenten und Konsumenten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 940
32.8.1 Sprücheklopfer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 940
32.9 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 942
32.10 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 943
A Anhang . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 947
A.1 Zeichencodierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 947
A.1.1 Codierung von Sonderzeichen in HTML . . . . . . . . . . . . . . . . 947
A.2 Quellen im WWW . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 947
A.3 Standardfunktionen und Standardklassen . . . . . . . . . . . . . . . . . . . . . . 948
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Inhaltsverzeichnis
22
A.4 Mathematische Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 950
A.4.1 Das Modul math . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 950
A.4.2 Das Modul random . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 951
B Glossar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 953
C Download der Programmbeispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . 965
D Ein Python-Modul veröffentlichen: PyPI . . . . . . . . . . . . . . . . . . . . . . 967
D.1 Bei PyPI und TestPyPI registrieren . . . . . . . . . . . . . . . . . . . . . . . . . . . 968
D.2 Ein Paket für die Veröffentlichung vorbereiten . . . . . . . . . . . . . . . . . 969
D.2.1 Die Programmdatei setup.py . . . . . . . . . . . . . . . . . . . . . . . . . 969
D.2.2 Die Lizenz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 970
D.2.3 Die Datei README.txt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 971
D.2.4 Die Datei __init__.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 972
D.3 Das Paket auf PyPI veröffentlichen . . . . . . . . . . . . . . . . . . . . . . . . . . . 972
D.3.1 Das Paket aktualisieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 973
Stichwortverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 975
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
23
Einleitung
Warum Python?Es gibt triftige Argumente für die Verwendung der Programmiersprache Python.
� Python ist einfach. Man könnte auch sagen minimalistisch. Auf Sprachelemente, dienicht unbedingt notwendig sind, wurde verzichtet. Mit Python kann man kurze Pro-gramme schreiben, die viel leisten.
� Python besitzt einen interaktiven Modus. Sie können einzelne Befehle direkt eingebenund ihre Wirkung beobachten. Python unterstützt das Experimentieren und Ausprobie-ren. Das erleichtert das Erlernen neuer Programmierkonzepte und hilft vor allemAnfängern bei den ersten »Gehversuchen«.
� Dennoch ist Python ist kein Spielzeug. Zusammen mit vielen Zusatzkomponenten, sogenannten Modulen, ist es eine sehr mächtige Programmiersprache.
� Python ist nichtkommerziell. Alle Software, die Sie benötigen, ist kostenlos und für jedePlattform verfügbar.
� Hinter Python steht eine wachsende internationale Community aus Wissenschaftlernund Praktikern, die die Sprache pflegen und weiterentwickeln.
Python 3Im Jahre 2008 fand in der Python-Welt eine kleine Revolution statt. Python 3 wurde veröf-fentlicht. Eine neue Version, die mit den Vorgängerversionen 2.X nicht mehr kompatibelist. Ein Programm, das z.B. in Python 2.5 geschrieben worden ist, läuft (in der Regel) nichtmehr mit einem Python-3-Interpreter. Das ist natürlich schade, war aber notwendig, weil eseinige sehr tief gehende Änderungen gab. Doch das neue Python 3 ist noch konsistenterund führt zu schönerem Programmtext als die früheren Versionen.
An wen wendet sich dieses Buch?Dieses Buch ist für jeden, der die Programmierung mit Python lernen möchte. BesondereVorkenntnisse werden nicht erwartet. Für die hinteren Kapitel ist es allerdings hilfreich,wenn man sich mit HTML auskennt. Das Buch wendet sich sowohl an Anfänger als auchan Leserinnen und Leser, die bereits mit einer höheren Programmiersprache vertraut sind,und ihr Wissen erweitern und vertiefen wollen. Für Neulinge gibt es zahlreiche Passagen,in denen grundlegende Konzepte anschaulich erklärt werden. Insbesondere das erste Kapi-tel ist zum überwiegenden Teil eine allgemeine Einführung für diejenigen, die sich bishernoch nie ausführlicher mit der Computertechnik beschäftigt haben. Wenn Sie sich eher zu
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Einleitung
24
den Fortgeschrittenen zählen, dürfen Sie getrost diese Textabschnitte überspringen undsich dem zuwenden, das Sie interessiert.
Auf der anderen Seite enthält das Buch auch Stellen, die eine Herausforderung darstellen.Einige Abschnitte tragen Überschriften, die mit Hintergrund: oder Vertiefung: beginnen. Sieenthalten Ausblicke und Hintergrundinformationen oder gehen vertiefend auf speziellereAspekte der jeweiligen Thematik ein, die nicht jeden interessieren.
Generell ist der Theorieanteil dieses Buches gering. Die praktische Arbeit steht im Vor-dergrund. In der Regel ist es möglich, theoretische Passagen (wie die über formale Gram-matiken) zu überspringen, wenn man nun gar nicht damit zurechtkommt. Alle wichtigenDinge werden zusätzlich auch auf anschauliche Weise erklärt. Und Sie werden erleben,dass beim Nachvollziehen und praktischen Ausprobieren der Programmbeispiele auchzunächst schwierig erscheinende Konzepte verständlich werden. Lassen Sie sich alsonicht abschrecken.
Inhalt und AufbauIm Zentrum steht die Kunst der Programmentwicklung nach dem objektorientierten Para-digma. Dabei machen wir einen Rundgang durch verschiedene Gebiete der Informatik. Wirwerfen einen Blick hinter die Kulissen von Software-Systemen, die Sie als Anwender ausdem Alltag kennen. Wie gestaltet man eine grafische Benutzungsoberfläche? Wie funktio-niert E-Mail? Wie programmiert man einen Chatroom? Darüber hinaus werden eine Reihefundamentaler Ideen der Informatik angesprochen. Das Buch orientiert sich an den übli-chen Curricula von Universitätskursen zur Einführung in die Programmierung. In vielenFällen dürfte es deshalb eine sinnvolle Ergänzung zu einem Vorlesungsskript sein.
Dieses Buch ist so angelegt, dass man es von vorne nach hinten lesen kann. Wir fangen miteinfachen Dingen an und nachfolgende Kapitel knüpfen an den vorhergehenden Inhalt an.Idealerweise sollte jeder Begriff bei seiner ersten Verwendung erklärt werden. Doch lässtsich dieses Prinzip nur schwer in Perfektion umsetzen. Manchmal gehen wir von einemintuitiven Vorverständnis aus und erläutern die Begrifflichkeit erst kurz darauf ausführlich.
Im vorderen Teil des Buches finden Sie an verschiedenen Stellen Hinweise zum Program-mierstil und zu typischen Fehlern. Am Ende jedes Kapitels gibt es Übungsaufgaben, die inder Regel nach Schwierigkeitsgrad sortiert sind. Einige Programmieraufgaben sind so kom-plex, dass man sie (insbesondere als Anfänger) eigentlich gar nicht eigenständig lösen kann.Sie sind dann eher als Erweiterung gedacht und es wurde ins Kalkül gezogen, dass Sie»mogeln« und während der Bearbeitung in die Lösung gucken.
Unterkapitel, deren Überschriften mit dem Wort »Vertiefung« beginnen, wenden sich anbesonders interessierte Leser und können in der Regel übersprungen werden.
Der vordere Teil des Buches befasst sich mit den grundlegenden Konzepten der Program-mierung mit Python. Herausgestellt werden die syntaktischen Besonderheiten gegenüberanderen Programmiersprachen. Sie finden an verschiedenen Stellen Hinweise zum Pro-grammierstil und zu typischen Fehlern. Angesprochen werden unter anderem folgendePunkte:
� Aufbau von Anweisungen in einem Python Programm
� Umgang mit der Standard-Entwicklungsumgebung IDLE
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
25
Einleitung
� Standard-Datentypen
� Modellieren mit Datenstrukturen: Tupel, Listen, Dictionaries, Mengen
� Kontrollstrukturen: Wiederholungen, Verzweigungen, Abfangen von Ausnahmen (try ...except)
� Funktionen: Arten von Parametern, Voreinstellungen, Lambda-Ausdrücke, Rekursion,Docstrings
� Ein- und Ausgabe: Dateien, pickle
� Konzepte der Objektorientierung: Klassen, Objekte, Vererbung, statische Methoden,Polymorphie, Properties
� Techniken der objektorientierten Modellierung: Analyse (OOA) und Design (OOD), UML,Objekt- und Klassendiagramme, Assoziationen
� Modularisieren
� Verarbeitung von Zeichenketten: String-Methoden, Codierung und Decodierung, For-matierung, reguläre Ausdrücke, Sprachsynthese, Chat-Bots
� Systemfunktionen: Schnittstelle zum Betriebssystem, Datum und Zeit
� Grundprinzipien der Gestaltung von grafischen Benutzungsoberflächen mit tkinter:Widgets, Event-Verarbeitung, Layout, Threads
� Debugging-Techniken
Im hinteren Teil des Buches werden die Kapitel immer spezieller. Hier kommen dann gele-gentlich auch Module von Drittanbietern ins Spiel, die nicht zur Standardinstallation vonPython gehören (z.B. PIL, PyQt, NumPy). Sie müssen erst heruntergeladen und installiertwerden. Zu diesen spezielleren Themen gehören:
� Internet-Programmierung: CGI-Skripte, Webserver, E-Mail-Clients
� Datenbanken und XML
� Testen und Performance-Analyse: doctest, unittest
� Benutzungsoberflächen für Multimedia-Anwendungen mit PyQt: Video-Player, Web-browser, Kalender
� Wissenschaftliches Rechnen mit NumPy und SciPy: Arrays, Vektoren und Matrizen,digitale Bildbearbeitung, Datenvisualisierung, lineare Gleichungssysteme, Integral-rechnung
� Parallele Datenverarbeitung: Prozesse und Synchronisation, Queues, Pipes, Pools
� Messdaten eines externen digitalen Multimeters erfassen und verarbeiten.
Hinweise zur TypographieAchten Sie beim Lesen auf den Schrifttyp. Formale Texte, wie Python-Programmtext, Funk-tions- und Variablennamen, Operatoren, Grammatik. Regeln, Zahlen und mathematischeAusdrücke, werden in einem Zeichenformat mit fester Breite gesetzt. Beispiele:
x = y + 1
print()
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Einleitung
26
In solchen formalen Texten tauchen gelegentlich Wörter auf, die kursiv gesetzt sind. Hierbeihandelt es sich um Platzhalter, die man nicht Buchstabe für Buchstabe aufschreibt, sondernz.B. durch Zahlen oder andere Zeichenfolgen ersetzt. Beispiel:
Hier bezeichnet zahl eine (ganze) Zahl. Ein korrekter Aufruf der Funktion range() lautetz.B. range(10), während range (zahl) zu Problemen führen kann.
In Programmtexten sind wichtige Passagen fett gedruckt, damit man sie schneller findenkann.
ProgrammbeispieleDas Buch enthält zahlreiche Programmbeispiele, die zum Ausprobieren, Nachmachen undWeiterentwickeln ermuntern sollen. Sie können alle Skripte und einige zusätzliche Dateienals ZIP-Archiv von der Website des mitp-Verlages herunterladen. Der URL ist:
http://www.mitp.de/791
Klicken Sie im Kasten DOWNLOADS auf den Link PROGRAMMBEISPIELE.
Beim Design der Beispiele wurde darauf geachtet, dass sie möglichst kurz und übersichtlichsind. Häufig sind die Skripte Spielzeugversionen richtiger Software, die man im Alltag zusinnvollen Dingen nutzen kann. Sie sind Modelle – etwa so wie Häuser aus LegosteinenModelle richtiger Häuser sind. Sie sind auf das Wesentliche reduziert und sollen nurbestimmte Aspekte verdeutlichen. Sie genügen deshalb nicht den Qualitätsanforderungen,die man üblicherweise an professionelle Software stellt, aber sie dienen vielleicht als Anre-gung und Inspiration für eigene Projekte.
range(zahl)
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
27
Kapitel 1
Grundlagen
Bitte noch etwas Geduld! Im ersten Kapitel bleibt der Computer noch ausgeschaltet. Hierwird zunächst eine anschauliche Vorstellung von einigen Grundideen der Programmierungvermittelt. Sie helfen, den Rest des Buches besser zu verstehen. Im Mittelpunkt stehen fol-gende Fragen:
� Was sind Programme und Algorithmen?
� Worin unterscheiden sich Programmierparadigmen?
� Was ist die Philosophie der objektorientierten Programmierung?
1.1 Was ist Programmieren?Es ist eigentlich ganz einfach: Programmieren ist das Schreiben eines Programms. Nun gibtes den Begriff »Programm« auch in unserer Alltagssprache – fernab von jeder Computer-technik. Sie kennen Fernseh- und Kinoprogramme, planen ein Programm für Ihre Geburts-tagsparty, genießen im Urlaub vielleicht Animationsprogramme (sofern Sie nichts Bessereszu tun haben) und lesen als gewissenhafter Staatsbürger vor den Bundestagswahlen Partei-programme. In diesen Zusammenhängen versteht man unter einem Programm eigentlichrecht unterschiedliche Dinge: Ein Parteiprogramm ist so etwas wie ein strukturiertes Kon-zept politischer Ziele, ein Kinoprogramm ein Zeitplan für Filmvorstellungen und ein Ani-mationsprogramm ein Ablauf von Unterhaltungsveranstaltungen.
In der Informatik – der Wissenschaft, die hinter der Programmiertechnik steht – ist derBegriff Programm natürlich enger und präziser gefasst. Allerdings gibt es auch hier unter-schiedliche Sichtweisen.
Die älteste und bekannteste Definition basiert auf dem Begriff Algorithmus. Grob gespro-chen ist ein Algorithmus eine Folge von Anweisungen (oder militärisch formuliert: Befeh-len), die man ausführen muss, um ein Problem zu lösen. Unter einem Programm verstehtman in dieser Sichtweise einen Algorithmus,
� der in einer Sprache geschrieben ist, die auch Maschinen verstehen können (Program-miersprache), und
� der das Verhalten von Maschinen steuert.
Daraus folgt: Wer ein Computerprogramm schreibt, muss zumindest zwei Dinge tun:
� Er oder sie muss einen Algorithmus erfinden, der in irgendeiner Weise nützlich ist undzum Beispiel bei der Lösung eines Problems helfen kann.
� Der Algorithmus muss fehlerfrei in einer Programmiersprache formuliert werden. Manspricht dann von einem Programmtext.
Ziel einer Programmentwicklung ist korrekter Programmtext.
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Kapitel 1Grundlagen
28
1.2 Hardware und SoftwareEin Computer ist eine universelle Maschine, deren Verhalten durch ein Programmbestimmt wird. Ein Computersystem besteht aus Hardware und Software. Ersteres ist dasenglische Wort für »Eisenwaren« und meint alle Komponenten des Computers, die mananfassen kann – Arbeitsspeicherbausteine, Prozessor, Peripheriespeicher (Festplatte, Dis-kette, CD), Monitor, Tastatur usw. Software dagegen ist ein Kunstwort, das als Pendant zuHardware gebildet wurde. Mit Software bezeichnet man die Summe aller Programme, diedie Hardware steuern.
Man kann die gesamte Software eines Computers grob in zwei Gruppen aufteilen:
Das Betriebssystem regelt den Zugriff auf die Hardware des Computers und verwaltet Daten,die im Rechner gespeichert sind. Es stellt eine Umgebung bereit, in der Benutzer Pro-gramme ausführen können. Bekannte Betriebssysteme sind Unix, MS Windows oder MacOS. Python-Programme laufen unter allen drei genannten Betriebssystemen. Man nenntsie deshalb portabel.
Anwendungs- und Systemsoftware dient dazu, spezifische Probleme zu lösen. Ein Textverarbei-tungsprogramm z.B. unterstützt das Erstellen, Verändern und Speichern von Textdokumen-ten. Anwendungssoftware ist also auf Bedürfnisse des Benutzers ausgerichtet, während dasBetriebssystem nur für ein möglichst störungsfreies und effizientes Zusammenspiel der ver-schiedenen Komponenten des Computersystems sorgt.
Ein Computersystem wird häufig durch ein Schichtenmodell wie in Abbildung 1.1 beschrie-ben. Die unterste Schicht ist die Computer-Hardware, darüber liegt das Betriebssystem undzuoberst befinden sich schließlich die Anwendungs- und Systemprogramme, die eineBenutzungsschnittstelle enthalten. Nur über diese oberste Software-Schicht kommunizie-ren Menschen mit einem Computersystem.
Abb. 1.1: Komponenten eines Computer-Systems
Mensch
System- und Anwendungsprogramme
Betriebssystem
Computer-Hardware
Python-Interpreter
Entwicklungsumgebung IDLE
Python-InterpreterPython-Programm
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
29
1.3Programm als Algorithmus
Wenn Sie ein Python-Programm schreiben, entwickeln Sie vor allem Anwendungssoftware.Dabei verwenden Sie eine Systemsoftware, zum Beispiel die integrierte Entwicklungsumge-bung IDLE. Ausgeführt wird das Programm mithilfe einer weiteren Systemsoftware, näm-lich dem Python-Interpreter. Dieser »liest« den Python-Programmtext Zeile für Zeile undbeauftragt das Betriebssystem (eine Schicht tiefer), bestimmte Dinge zu tun – etwa eine Zahlauf den Bildschirm zu schreiben.
1.3 Programm als AlgorithmusEin Algorithmus ist eine Anleitung zur Lösung einer Aufgabe. Es besteht aus einer Folgevon Anweisungen, die so präzise formuliert sind, dass sie auch von einem völlig Unkundi-gen rein mechanisch ausgeführt werden können. Sie kennen Algorithmen aus dem Alltag:
� Kochrezept
� Anleitung zur Mund-zu-Mund-Beatmung in einer Erste-Hilfe-Fibel
� Gebrauchsanweisung für die Benutzung einer Bohrmaschine
Abb. 1.2: Natürlichsprachlich formulierter Algorithmus zur Zubereitung eines Brathähnchens, entwickelt von Martha Pötsch aus Essen
Abbildung 1.2 zeigt einen äußerst effizienten Algorithmus zur Zubereitung eines Brathähn-chens (Vorbereitungszeit: eine Minute). Wenn auch das Rezept wirklich sehr gut ist (esstammt von meiner Großmutter), so erkennt man dennoch an diesem Beispiel zwei Schwä-chen umgangssprachlich formulierter Alltags-Algorithmen:
Algorithmus Brathähnchen nach Martha Pötsch (1901 -1994)
Schalten Sie Ihren Backofen ein und stellen Sie den Temperaturregler auf 200 °C (bei einem Umluftherd nur 180 °C).Schälen Sie eine Zwiebel und zerschneiden Sie sie in Viertel.Schneiden Sie eine Tomate ebenfalls in Viertel.Reiben Sie ein frisches ausgenommenenes Hähnchen innen und außen mit insgesamt zwei gestrichenen Teelöffeln Salz ein.Legen Sie das gesalzene Hähnchen, Zwiebel und Tomate in eine Casserole oder ofenfeste Porzellanschale. Geben Sie eine Tassenfüllung Wasser hinzu.Schieben Sie das Gefäß mit den Zutaten in den Backofen auf eine mittlere Schiene.Nach vierzig Minuten wenden Sie das Hähnchen und ergänzen das verdampfte Wasser. Nach weiteren zwanzig Minuten prüfen Sie, ob das Hähnchen goldbraun ist. Ist das nicht der Fall, erhöhen Sie die Temperatur um 20 °C.Nach weiteren zehn Minuten schalten Sie den Backofen ab und nehmen das Gefäß mit dem köstlich duftenden Hähnchen heraus.Fertig.
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Kapitel 1Grundlagen
30
� Sie beschreiben die Problemlösung meist nicht wirklich vollständig, sondern setzen vo-raus, dass der Leser, d.h. die den Algorithmus ausführende Instanz, über ein gewissesAllgemeinwissen verfügt und in der Lage ist, »Beschreibungslücken« selbstständig zufüllen. So steht in dem Kochrezept nichts davon, dass man die Backofentür öffnen undschließen muss. Das versteht sich von selbst und wird deshalb weggelassen.
� Sie enthalten ungenaue Formulierungen, die man unterschiedlich interpretieren kann.Was heißt z.B. »goldbraun«?
Auch ein Computerprogramm kann man als Algorithmus auffassen. Denn es »sagt« demComputer, was er zu tun hat. Damit ein Algorithmus von einem Computer ausgeführt wer-den kann, muss er in einer Sprache formuliert sein, die der Computer »versteht« – einerProgrammiersprache. Im Unterschied zu »natürlichen« Sprachen, wie Deutsch oder Eng-lisch, die sich in einer Art evolutionärem Prozess im Laufe von Jahrhunderten entwickelthaben, sind Programmiersprachen »künstliche« Sprachen. Sie wurden von Fachleuten ent-wickelt und sind speziell auf die Formulierung von Algorithmen zugeschnitten.
1.4 Syntax und SemantikEine Programmiersprache ist – wie jede Sprache – durch Syntax und Semantik definiert.Die Syntax legt fest, welche Folgen von Zeichen ein Programmtext in der jeweiligen Spracheist. Zum Beispiel ist
kein gültiger Python-Programmtext, weil die Python-Syntax vorschreibt, dass in einemarithmetischen Ausdruck zwischen zwei Zahlen ein Operator (z.B. +, -, *, /) stehen muss.Das Ausrufungszeichen ! ist aber nach der Python-Syntax kein Operator.
Dagegen ist die Zeichenfolge
ein syntaktisch korrektes Python-Programm. Die Syntax sagt aber nichts darüber aus, wel-che Wirkung dieses Mini-Programm hat. Die Bedeutung eines Python-Programmtexteswird in der Semantik definiert. Bei diesem Beispiel besagt die Semantik, dass auf dem Bild-schirm die Zeichenkette Schweinebraten mit Klößen ausgegeben wird.
1.5 Interpreter und Compiler Python ist eine höhere Programmiersprache. Es ist eine künstliche Sprache für Menschen,die Algorithmen formulieren wollen. Mit einer höheren Programmiersprache lässt sich aufbequeme Weise Programmtext notieren, der leicht durchschaubar und gut verständlich ist.Syntax und Semantik einer höheren Programmiersprache sind auf die Bedürfnisse vonMenschen zugeschnitten und nicht auf die technischen Spezifika der Maschine, die das Pro-gramm ausführen soll.
a = 1 ! 2
print("Schweinebraten mit Klößen")
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
31
1.5Interpreter und Compiler
Damit ein Programmtext – man spricht auch von Quelltext (source code) – vom Computer»verstanden« wird und abgearbeitet werden kann, muss er in ein ausführbares Programmübersetzt werden.
Dazu gibt es zwei unterschiedliche Methoden.
Ein Compiler übersetzt einen kompletten Programmtext und erzeugt ein direkt ausführba-res (executable) Programm, das vom Betriebssystem geladen und gestartet werden kann. Beider Übersetzung müssen natürlich die Besonderheiten des Rechners, auf dem das Pro-gramm laufen soll, berücksichtigt werden. Es gibt dann z.B. unterschiedliche Fassungen fürMS-Windows- und Unix-Systeme. Programmiersprachen, bei denen kompiliert wird, sindz.B. Pascal, C, C++.
Abb. 1.3: Arbeitsweise eines Compilers
Ein Interpreter liest einen Programmtext Zeile für Zeile und führt (über das Betriebssystem)jede Anweisung direkt aus. Wenn ein Programm gestartet werden soll, muss zuerst der Inter-preter aufgerufen werden. Für jedes Betriebssystem gibt es zu der Programmierspracheeinen eigenen Interpreter. Wer ein Programm in einer interpretativen Sprache verwendenmöchte, benötigt also zusätzlich zu dem Anwendungsprogramm noch einen Interpreter.
Python ist eine interpretative Programmiersprache. Dies hat den Vorteil, dass ein und das-selbe Programm auf allen Rechnerplattformen läuft. Als nachteilig könnte man aus Ent-wicklersicht empfinden, dass der Quelltext einer Software, die man verkaufen möchte,immer offen gelegt ist (open source). Damit besteht das Risiko, dass jemand illegalerweiseden Programmtext leicht verändert und ihn unter seinem Namen weiterverkauft. Das geis-tige Eigentum des Programmentwicklers ist also schlecht geschützt. Auf der anderen Seitegibt es einen gewissen Trend, nur solche Software einzusetzen, deren Quelltext bekannt ist.Denn nur dann ist es möglich, etwaige Fehler, die erst im Lauf des Betriebes sichtbar wer-den, zu finden und zu beseitigen. Wer Software verwendet, deren Quelltext geheim gehaltenist, macht sich vom Software-Hersteller abhängig, und ist im Störungsfall »auf Gedeih undVerderb« auf ihn angewiesen.
Programmtext inhöherer Programmier-sprache
ausführbares Programm
Betriebssystem
Compiler
Hardware
a = int(input()) b = a*a print(b)
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Kapitel 1Grundlagen
32
Abb. 1.4: Arbeitsweise eines Interpreters
1.6 ProgrammierparadigmenEin Paradigma ist allgemein ein Denk- oder Handlungsmuster, an dem man sich z.B. beider Formulierung einer Problemlösung orientiert. Wenn man ein Programm als Algorith-mus betrachtet, also als System von Befehlen, folgt man dem imperativen Programmier-paradigma (imperare: lat. befehlen).
Zur Abgrenzung sei kurz darauf hingewiesen, dass es auch andere Programmierparadig-men gibt. Prolog z.B. ist eine deklarative Programmiersprache. Ein deklaratives Programmbeschreibt Eigenschaften der Lösung des Problems. Der Programmierer legt sein Augen-merk auf die Frage, was berechnet werden soll, und nicht, wie man es berechnet. Dagegenstellt ein imperatives Programm eine Anleitung dar. Sie beschreibt, wie – Schritt für Schritt– die Aufgabe gelöst werden soll.
Das folgende kleine Experiment veranschaulicht den Unterschied. Wenn Sie es selbst durch-spielen wollen, benötigen Sie sieben Streichhölzer. Die beiden folgenden Texte beschreibenauf deklarative und auf imperative Weise, wie die Streichhölzer angeordnet werden sollen.Probieren Sie aus, mit welchem Paradigma Sie besser zurechtkommen.
Deklaratives Paradigma:
� Insgesamt gibt es sieben Streichhölzer.
� Genau ein Streichholz berührt an beiden Enden jeweils zwei weitere Streichhölzer.
� Wenigstens ein Streichholz bildet mit zwei benachbarten Streichhölzern jeweils einenrechten Winkel.
Programmtext inhöherer Programmier-sprache
Python-Interpreter
Betriebssystem
Interpreter a = int(input()) b = a*a print(b)
Hardware
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
33
1.7Objektorientierte Programmierung
� Drei Streichhölzer liegen zueinander parallel, berühren sich aber nicht.
� Es gibt kein Streichholz, das nicht an jedem Ende wenigstens ein anderes Streichholzberührt.
Imperatives Paradigma:
� Legen Sie zwei Streichhölzer (A und B) in einer geraden Linie nebeneinander auf denTisch, so dass sie sich an einer Stelle berühren.
� Legen Sie ein Streichholz C mit einem Ende an der Stelle an, wo sich A und B berühren.Das Streichholz soll einen rechten Winkel zu A und B bilden.
� Legen Sie an die äußeren Enden von A und B jeweils ein weiteres Streichholz mit einemEnde an (D und E), so dass diese neuen Streichhölzer jeweils einen rechten Winkel zuA und B bilden und in die gleiche Richtung gehen wie das mittlere Streichholz.
� Verbinden Sie die noch freien Enden von C, D und E mit den verbleibenden zweiStreichhölzern.
Eine Abbildung der korrekten Anordnung finden Sie am Ende des Kapitels. Vermutlichhaben Sie die zweite Aufgabe schneller lösen können. Tatsächlich benötigen auch in derComputertechnik imperative Programme weniger Rechenzeit als deklarative.
Zum Schluss sei noch das Paradigma der funktionalen Programmierung erwähnt. Mit funk-tionalen Programmiersprachen wie z.B. Haskell oder Scheme kann man ein Programm als(mathematische) Funktion definieren. Einfache vorgegebene Funktionen werden zu einerkomplexen Funktion verknüpft, die das Gewünschte leistet. Mathematisch geschulten Men-schen fällt diese Art der Programmentwicklung bei bestimmten Problemen leichter.
Man kann mit Fug und Recht sagen, dass unter diesen drei Paradigmen der imperativeAnsatz am verbreitetesten ist. Funktionale und deklarative Sprachen spielen heute in derPraxis der Software-Entwicklung eher eine untergeordnete Rolle. Auch die objektorientierteProgrammierung (OOP) wird als eigenes Programmierparadigma beschrieben. Das hört sichso an, als wäre die objektorientierte Programmierung etwas ganz anderes als das imperativeoder funktionale Paradigma. Aber ganz so ist es eigentlich nicht. Vielmehr betrifft das Para-digma der Objektorientierung einen Aspekt der Programmentwicklung, den ich bishernoch nicht erwähnt habe. Es geht um die Beherrschung von Komplexität.
1.7 Objektorientierte Programmierung
1.7.1 Strukturelle ZerlegungDie ersten Computerprogramme waren einfach und dienten der Lösung eines relativ klei-nen, gut umgrenzten Problems. Die Situation wird ganz anders, wenn man umfangreicheSoftware erstellen möchte, etwa ein Textverarbeitungsprogramm oder ein Verwaltungspro-gramm für eine Bibliothek. Solche großen Systeme lassen sich nur beherrschen, wenn mansie zunächst in kleinere überschaubare Teile aufbricht. Abbildung 1.5 soll diesen Gedankenveranschaulichen.
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Kapitel 1Grundlagen
34
Abb. 1.5: Zerlegung eines komplexen Systems
Die Vorteile liegen auf der Hand:
Die kleineren Teile des Ganzen lassen sich einfacher programmieren. Die Wahrscheinlich-keit, dass sie Fehler enthalten, ist geringer. Mehrere Personen können zeitgleich und unab-hängig voneinander die Einzelteile erstellen. Das spart Zeit. Und es kann sein, dass manspäter einen Baustein, den man früher einmal programmiert hat, wieder verwenden kann.Das spart Kosten.
Das objektorientierte Paradigma bietet ein Verfahren, nach dem große Systeme in kleinereTeile zerlegt werden können.
1.7.2 Die Welt als System von ObjektenIn der objektorientierten Sichtweise stellt man sich die Welt als System von Objekten vor, dieuntereinander Botschaften austauschen. Zur Veranschaulichung betrachten wir ein Bei-spiel aus dem Alltag, das in Abbildung 1.6 illustriert wird.
Leonie in Bonn möchte ihrer Freundin Elena in Berlin einen Blumenstrauß schicken. Siegeht deshalb zu Mark, einem Blumenhändler, und erteilt ihm einen entsprechenden Auf-trag. Betrachten wir Mark als Objekt. In der Sprache der objektorientierten Programmie-rung sagt man: Leonie sendet an das Objekt Mark eine Botschaft, nämlich: »Sende siebengelbe Rosen an Elena, Markgrafenstr. 10 in Berlin.«. Damit hat sie getan, was sie tun konnte.Es liegt nun in Marks Verantwortung, den Auftrag zu bearbeiten. Mark versteht die Bot-schaft und weiß, was zu tun ist. Das heißt, er kennt einen Algorithmus für das Verschickenvon Blumen. Der erste Schritt ist, einen Blumenhändler in Berlin zu finden, der die Rosenan Elena liefern kann. In seinem Adressverzeichnis findet er den Floristen Sascha. Ihmsendet er eine leicht veränderte Botschaft, die nun zusätzlich noch den Absender enthält.Damit ist Mark fertig und hat die Verantwortung für den Prozess weitergegeben. AuchSascha hat einen zur Botschaft passenden Algorithmus parat. Er stellt den gewünschtenBlumenstrauß zusammen und beauftragt seinen Boten Daniel, die Rosen auszuliefern.Daniel muss nun den Weg zur Zieladresse finden und befragt seine Straßenkarte. Sie ant-wortet ihm mit einer Wegbeschreibung. Nachdem Daniel den Weg zu Elenas Wohnunggefunden hat, überreicht er die Blumen und teilt ihr in einer Botschaft mit, von wem siestammen. Damit ist der gesamte Vorgang, den Leonie angestoßen hat und an dem mehrereObjekte beteiligt waren, beendet.
Zerlegung
groß und komplex kleiner und weniger komplex
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
35
1.7Objektorientierte Programmierung
Abb. 1.6: Objektorientiertes Modell eines Blumenversandsystems
1.7.3 Objekte besitzen Attribute und beherrschen MethodenJedes Objekt besitzt Eigenschaften oder Attribute. Ein Attribut eines Blumenhändlers ist z.B.die Stadt, in der er sein Geschäft hat. Dieses Attribut ist auch für die Umwelt wichtig. Somusste Mark einen Blumenhändler mit dem Attribut »wohnhaft in Berlin« suchen. Weiteretypische Attribute von Blumenhändlern sind Name, Telefonnummer, Warenbestand oderÖffnungszeiten.
Abb. 1.7: Objekte besitzen Attribute und beherrschen Methoden.
KundinLeonie
KundinElena
BlumenhändlerMark
BoteDaniel
BlumenhändlerSascha
"Wo ist die Markgrafenstraße?"
Wegbeschreibung
"Die Blumen sind von Leonie"
"Schicke 7 gelbe Rosen anElena, Markgrafenstr.10 in Berlin."
"Schicke 7 gelbe Rosen von Leonie an Elena, Markgrafenstr.10"
"Bringe Blumen von Leonie zu Elena, Markgrafenstr.10"
StraßenkarteBerlin
Attribute(Daten)
Name: SaschaStadt: BerlinÖffnungszeiten: Mo bis Fr 10.00-19.00 Uhr
Methoden(Algorithmen)
Sascha
Blumensträuße bindenLieferauftrag entgegennehmenBoten schicken
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Kapitel 1Grundlagen
36
Objekte sind in der Lage, bestimmte Operationen auszuführen, die man Methoden nennt.Ein Blumenhändler z.B. kann einen Lieferauftrag für Blumen entgegennehmen, Sträußebinden, einen Boten schicken, beim Großhandel neue Blumen einkaufen usw. Wenn einObjekt eine geeignete Botschaft empfängt, wird eine zur Botschaft passende Operationgestartet. Man sagt: Die Methode wird aufgerufen. Der Umwelt, das heißt den anderenObjekten, ist bekannt, welche Methoden ein Objekt beherrscht. Die Umwelt weiß von denMethoden nur,
� was sie bewirken
� welche Daten sie als Eingabe benötigen
Die Umwelt weiß aber nicht, wie das Objekt funktioniert, das heißt, nach welchen Algorith-men die Botschaften verarbeitet werden. Dieses bleibt ein privates Geheimnis des Objektes.
Leonie hat keine Ahnung, wie Mark den Blumentransport bewerkstelligt. Es interessiert sieauch gar nicht. Ihre Aufgabe bestand allein darin, für ihr Problem ein geeignetes Objekt zufinden und ihm eine geeignete Botschaft zu senden. Ein ungeeignetes Objekt wäre zum Bei-spiel Tom, der Zahnarzt, oder Katrin, die Leiterin des Wasserwerks gewesen. Diese Objektehätten Leonis Nachricht gar nicht verstanden und zurückgewiesen. Außerdem ist für Leoniewichtig, wie sie die Botschaft an Mark formuliert. Sie muss ihm ihren Namen mitteilen(damit der Empfänger weiß, von wem die Blumen sind), die Adresse des Empfängers sowieAnzahl und Sorte der Blumen, die gesendet werden sollen.
Eine Methode ist die Implementierung (technische Realisierung) eines Algorithmus. Beider Programmierung einer Methode mit Python (oder einer anderen objektorientiertenSprache) wird also wieder das imperative Paradigma wichtig.
1.7.4 Objekte sind Instanzen von KlassenDie Objekte des Beispiels kann man in Gruppen einteilen. Sascha und Mark sind beide Blu-menhändler. Sie beherrschen beide dieselben Methoden und besitzen dieselben Attribute(z.B. die Stadt), allerdings mit unterschiedlichen Werten. Man sagt: Sascha und Mark sindInstanzen der Klasse »Blumenhändler«. In der objektorientierten Programmierung ist eineKlasse die Definition eines bestimmten Typs von Objekten. Sie ist so etwas wie ein Bauplan,in dem die Methoden und Attribute beschrieben werden. Nach diesem Schema könnenObjekte (Instanzen) einer Klasse erzeugt werden. Ein Objekt ist eine Konkretisierung, eineInkarnation einer Klasse. Alle Instanzen einer Klasse sind von der Struktur her gleich. Sieunterscheiden sich allein in der Belegung ihrer Attribute mit Werten. Die Objekte Saschaund Mark besitzen dasselbe Attribut »Stadt«, aber bei Sascha trägt es den Wert »Berlin« undbei Mark »Bonn«.
1.8 Hintergrund: Geschichte der objektorientierten Programmierung
Die Grundideen der Objektorientierung (wie z.B. die Begriffe Klasse und Objekt) tauchenzum ersten Mal in der Simulationssprache SIMULA auf. Sie wurde von Ole-Johan Dahl andKristen Nygaard am Norwegian Computing Centre (NCC) in Oslo zwischen 1962 und 1967entwickelt und diente zur Simulation komplexer Systeme der realen Welt. Die erste univer-sell verwendbare objektorientierte Programmiersprache wurde in den Jahren 1970 bis 1980
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
37
1.9Aufgaben
am Palo Alto Research Center der Firma Xerox von Alan Key und seinem Team entwickeltund unter dem Namen SmallTalk-80 in die Öffentlichkeit gebracht. Wenig später entstandin den Bell Laboratories (AT&T, USA) unter der Leitung von Bjarne Stroustrup die SpracheC++ als objektorientierte Erweiterung von C. Sie wurde zu Beginn der Neunzigerjahre zurdominierenden objektorientierten Sprache. Mitte der Neunzigerjahre etablierte sich Java(Sun Microsystems Inc.) auf dem Markt. Die Entwicklung von Python wurde 1989 von Guidovan Rossum am Centrum voor Wiskunde en Informatica (CWI) in Amsterdam begonnenund wird nun durch die nichtkommerzielle Organisation Python Software Foundation (PSF)koordiniert. Gegenwärtig gibt es eine rasch wachsende Communitiy von Python-Program-mierern.
Etwa parallel zur Entwicklung von objektorientierten Programmiersprachen wurden Kon-zepte der objektorientierten Analyse (OOA) und des objektorientierten Entwurfs (OOD) ver-öffentlicht. Im Prozess einer objektorientierten Software-Entwicklung sind OOA und OODder Implementierung in einer Programmiersprache vorgelagert. Im Gegensatz zur rein tex-tuellen Notation der Programmiersprachen verwenden objektorientierte Analyse- und Ent-wurfsmethoden auch visuelle Darstellungen. Besonders zu erwähnen ist die UnifiedModeling Language (UML), die in der Version 1.1 im September 1997 publiziert wurde undheute so etwas wie einen Industriestandard zur grafischen Beschreibung objektorientierterSoftware-Systeme darstellt.
1.9 Aufgaben
Aufgabe 1
Welche der folgenden Texte sind Algorithmen?
1. Liebesbrief
2. Formular zur Beantragung eines Personalausweises
3. Märchen
4. Musterlösung einer Mathematikaufgabe
5. Die christlichen Zehn Gebote
Aufgabe 2
Ordnen Sie den folgenden Beschreibungen einer Problemlösung passende Programmier-paradigmen zu (imperativ, objektorientiert, deklarativ).
1. Um ein Zündholz zu entzünden, reiben Sie den Kopf des Zündholzes über die Reibfläche.
2. Um eine Menge von Blumenvasen der Größe nach zu sortieren, sorgen Sie davor, dassjede Blumenvase entweder am Anfang der Reihe steht oder größer als ihr linker Nachbarist.
3. Der Betrieb in einem Restaurant funktioniert so: Es gibt einen Koch und einen Kellner.Der Kellner kümmert sich um die Gäste, säubert die Tische, bringt das Essen und kas-siert. Der Koch bereitet das Essen zu, wenn er vom Kellner einen Auftragzettel mit denNummern der bestellten Gerichte erhält.
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Kapitel 1Grundlagen
38
1.10 Lösungen
Lösung 1
1. Liebesbriefe können natürlich sehr unterschiedlich aussehen, manche sind leidenschaft-lich, andere poetisch und sensibel. Wenn auch nach Auffassung des Kommunikations-theoretikers Schulz von Thun jede sprachliche Botschaft (unter anderem) auch eineappellative Dimension hat, dürfte ein Liebesbrief insgesamt wohl kaum als Anweisungzur Lösung eines Problems zu sehen sein und ist damit kein Algorithmus.
2. Ein solches Formular besitzt die entscheidenden Merkmale eines Algorithmus. Esbeschreibt (einigermaßen unmissverständlich) alle Aktionen, die ausgeführt werdenmüssen, um das Problem »Wie komme ich an einen Personalausweis?« zu lösen.
3. Märchen erzählen, was vor langer Zeit passiert ist. Sie sind keine Algorithmen.
4. Eine gut formulierte Musterlösung beschreibt in der Regel einen Lösungsweg, führt alsodie mathematischen Operationen (in der richtigen Reihenfolge) auf, die man ausführenmuss, um die Aufgabe zu lösen. Sie kann somit als Algorithmus (mit Kommentarenzum besseren Verständnis) betrachtet werden.
5. Die Zehn Gebote sind zwar allgemeine Verhaltensvorschriften (soziale Normen), defi-nieren aber kein konkretes Verhalten, das zu einer Problemlösung führt.
Lösung 2
1. Imperativ. Es handelt sich um eine Folge von Anweisungen.
2. Deklarativ. Es wird beschrieben, welche Eigenschaften die Lösung (nach Größe sortierteBlumenvasen) haben muss, aber nicht, wie man dieses Ziel erreicht.
3. Objektorientiert. Das Restaurant wird als System interagierender Objekte beschrieben.
Lösung des Experimentes »Programmierparadigmen« (Abschnitt 1.6)
Abb. 1.8: Eine mögliche Lösung des Streichholz-Experiments
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
975
Stichwortverzeichnis
Symbole__abs__() 295__add__() 294__contains__() 295__debug__ 582__del__() 295__delitem__() 295__eq__() 295__float__() 295__ge__() 295__getitem__() 295__gt__() 295__init__() 284__le__() 295__len__() 295__lt__() 295__main__ 584__mod__() 295__mul__() 295__name__ 584__ne__() 295__neg__() 295__nonzero__() 295__str__() 295, 372_thread 564
AAbbruch
Schleife 139Abfangen
Laufzeitfehler 141Abstrakter Datentyp 755Abstraktion 299access() 413add_cascade() 547add_checkbutton() 547add_choice () 547add_command() 547add_radiobutton() 547add_separator() 547Additive Farbmischung 456
Adjazenzliste 761Aggregat 340Aggregation 340Aktueller Parameter 51, 153Algorithmus 27, 29Analyse 375
objektorientierte 664anchor 468and 125Animation 567Anonymes Objekt 287Ansichtskarte 829Anweisung 49
bedingte 128global 165
Anweisungsblock 71, 156Anwendungssoftware 28Apfelmännchen 505appendChild 729Arbeitsverzeichnis 412Argument 51, 153argv 407Arithmetischer Ausdruck 96Array 857
ändern 865Array-Funktion 871asctime() 423askokcancel() 551askopenfile() 550askopenfilename() 550asksaveasfile() 551asksaveasfilename() 551askyesno() 551assert 576AssertionError 576Assignment siehe ZuweisungAssoziation 332, 338
Aggregat 340Kardinalität 342reflexiv 338
Asynchrone Kommunikation 433
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Stichwortverzeichnis
976
Attribut 282, 287dynamische Erzeugung 293Klassenattribut 288Objektattribut 288öffentlich 288privat 289Zugriff 288
AttributError 576Ausdruck 50, 123
arithmetischer 96bedingter 132regulärer 378
Ausdruckanweisung 50Ausgabe 251Ausnahme 141, 575Authentifizieren 666
Bbackground 440backward() 177Basisklasse 300Baud 910Baum 179, 722bd 440, 443Bedingte Anweisung 128Bedingter Ausdruck 132Bedingung 119Befragung 688Begrenzungskasten 497Beliebige Anzahl von Parametern 172Benutzungsoberfläche 328, 477
grafische 433Betriebssystem 28, 411Bezeichner 47Beziehung 332bg 440Bildergalerie 517Binäre Suche 212binden 532Block 71bool 86, 87bool() 111borderwidth 440, 443Botschaft 53Bounding box 497Box-Layout 781break 139Breitensuche 765Bubblesort 214Bug 594
Built in function 54Button 447
Checkbutton 455Radiobutton 453Submit-Button 608
Bytestring 100
CCaesars Algorithmus 270Callable object 51Canvas 495
Display List 497ID 497Item 496Koordinatensystem 497Optionen der Items 498
capitalize 360center 360cgi 608cgi.FieldStorage() 608CGI-Skript 597, 670
auf Host installieren 603Aufbau 599debuggen 611erste Zeile 601interaktive Webseite 604Querystring 606Verarbeitung von Eingabedaten 608
cgitb 612cgitb.enable() 612Charts 217Chat Bot 375Chatroom 612chdir() 412Checkbutton 455
Erscheinungsformen 455Werte 455
childNodes 728chmod () 413choice() 488clear() 238Client-Server-System 631close() 254, 258, 639closed 258column 471columnspan 471ComboBox 788command 447, 458Compiler 30complex 86
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Stichwortverzeichnis
977
complex() 111COM-Port 908Container 86continue 140Cookie 618Coordinated Universal Time 422coords() 495count() 363CREATE TABLE 658create_arc() 495create_image() 495create_line() 495create_oval() 496create_polygon() 496create_rectangle () 496create_text() 496create_window() 496crop() 514CSV-Datei 918ctime() 423Current working directory 412Cursor 657cwd() 631
DDatei
anlegen 415externe 252Merkmale abfragen 416suchen 412
Datenbank 653relationale 655
Datenbank-Management-System 653Datenbanksystem 653Datenkommunikation 735Datentyp 83
abstrakter 755Datenverarbeitung
parallele 925Datum 422DBMS siehe Datenbank-Management-
SystemDebugger 594Debugging-Modus 581def 156Deklarativ 32delete() 451, 496, 543deselect() 454Dezimalbruch 90Dialog 827
Dialogbox 550Dialog-Widget 828dict() 112Dictionary 108, 237, 656
Display 238Operationen 237Schlüssel 108schrittweiser Aufbau 240Zugriff auf Daten 241
digest() 667Digitales Multimeter 899Digitaluhr 569, 812Disjunktion 126Display List 497Divide and conquer 215Division 94DMM 899Docstring 156, 189, 682doctest 682, 691Document Object Model siehe DOMDOM 723
createTextNode() 731Document 724, 730documentElement 731Element 730getElementsByTagName() 731tagName 731Text 730
Download 632Drag&Drop 534Duck-Typing 59dump() 265Dynamische Typisierung 59
EEditieren 65Eingabe 251Eingabefeld 606Einrückung 71Einwegfunktion 666elif 130Eliza 375Ellipse 692E-Mail 642E-Mail-Client 643end() 387Endlosschleife 133Endrekursion 179endswith() 361Entity-Relationship-Diagramm 654
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Stichwortverzeichnis
978
Entry 451delete() 451get() 451Passworteingabe 451show 451
Entwicklungsumgebung 554environ 419ER-Diagramm siehe Entity-Relationship-
DiagrammErweiterte Zuweisung 59Escape-Sequenz 99EVA-Prinzip 73Event 793
binden 532Taste 528
Eventhandler 530Event-Modifizierer 528Event-Sequenz 526exc_info() 408except 142Exception siehe Ausnahmeexec_prefix 408executable 408execute() 657exists() 416, 417exit() 408exitfunc 408expand 468Exponentialschreibweise 90Externe Datei 252Externes Modell 654Extreme Programming 681
FFallunterscheidung 130False 86, 87Farbe 442Farbmischung
additive 456Farbverlauf 798Farbwechselleuchte 793Fehler 78, 244, 308, 575
logischer 78, 575Syntaxfehler 78, 575
Fenstermehrere Fenster 554
fg 440FIFO 758File 251
laden 255
lesen und schreiben 258Modus 253speichern 254, 260
File Transfer Protocol 630file() 253fill 468finally 262find_all() 496find_closest() 496find_overlapping() 496find() 363findall() 383, 384Fingerabdruck 666Fingerprint 666firstChild 728Flash 735Flesch-Analyse 398FLOAT 658float 86float() 110flush() 258Folge
rekursive 139Font 441, 794font 440for 135foreground 440Formaler Parameter 156Formatierung
Tabelle 269Formatierungsoperator % 367Form-Layout 805Foto 506Frame 459Fremdschlüssel 656from 55from_ 458frozenset 107FTP 630ftplib 631FTP-Server 631, 634Funktion 51, 153
als Objekt 186Aufruf 153Ausführung 162beliebige Anzahl von Parametern 172Definition 156Kopf 156Körper 156Lambda-Form 187
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Stichwortverzeichnis
979
lokale Funktion 173Parameter 153Parameterübergabe 166rekursive 174Schlüsselwort-Argument 170Seiteneffekt 165voreingestellter Parameterwert 168
Funktionskopf 156Funktionskörper 156Funktionsplotter 518
GGanze Zahl 88Geheimnisprinzip 299Generator 221Generatorausdruck 222Generatorfunktion 222geopy 848Geräte-Manager 909Geschäftsprozess 329Geschäftsprozessdiagramm 329Geschwister 722Gesprächsroboter 376get() 451, 543getatime() 416, 417getcwd() 412getenv() 419getfirst() 610getlist() 610getmtime() 416, 417getPixel() 514getrefcount() 410getrefcount(objekt) 408getresponse() 639getsize() 416getvalue() 610Gleich 46Gleitkommazahl 90global 165Global Interpreter Lock (GIL) 926Globaler Name 162Globals 594gmtime() 423Go 595Grafik 495Grammatik 48Graph 759grid() 470GUI 433, 474
HHardware 28hasAttributes() 729hasChildNodes() 729height 440, 444Hexadezimalzahl 89hidden 607Hintergrundbild 510HTML
Checkbox 607Eingabefeld 606Formular 605Passworteingabe 606Radiobutton 606Submit-Button 608versteckte Variablen 607
HTML-Formular 605Checkbox 607Eingabefeld 606Radiobutton 606
HTTP 638HTTPConnection 638HTTP-Paket 598HTTP-Server 597, 602Hypertext Transfer Protocol 638
IIcon 509id() 123Identifier 47Identisch 46Identität 46IDLE 43, 65if 129if-else 129IGNORECASE 382image 440Imperativ 33import 54in 123, 197Index 543IndexError 576indicatoron 454, 456Informatik 27Information hiding 299insert() 543insertBefore(newChild, 729Installation 40Instanz 36, 285
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Stichwortverzeichnis
980
INT 658int 86, 88int() 109interaktive Webseite 604Interaktiver Modus 39, 42Internes Modell 654Internet-Programmierung 629Interpreter 30IOError 576isalnum() 361isalpha() 361isdigit() 361isdir() 412isfile() 412islower() 361isupper() 361Item 496itemcget () 496itemconfigure() 496items() 238Iteration 135Iterator 224Iterierbar 86
Jjustify 440, 541
KKalender 819Kamerabild 825Kante 759Kardinalität 342Keller 755Key siehe SchlüsselKeyError 576keys() 238, 610Keyword siehe SchlüsselwortKind 722Klasse 36, 281, 283
Beziehung zwischen Klassen 332Definition 283Dokumentation 308Fehler 308Konstruktor 284Kopf 283Oberklasse 283Programmierstil 306Spezialisierung 301
Klassenattribut 282
Klassenbibliothek 319Klassenstruktur 328Knoten 722, 759Kollektion 86Kommandozeilen-Argument 269Kommentar 69, 77Kommunikation 433, 629
asynchrone 433Komplexe Zahl 91Konjunktion 125Konkatenation 104Konstruktor 284Kontrollstruktur 119
Endlosschleife 133try 141
Kontrollvariable 449Konzeptuelles Modell 653Kopie
flache 209tiefe 209
Kreisdiagramm 500Kunststoff 460Kurze Zeichenkette 98
LLabel 448label 458Lambda-Form 187Landesumweltamt 645Lange Zeichenkette 99lastChild 728Laufzeitfehler
abfangen 141Laufzeitsystem 407Layout 76, 467Layout-Fehler 469Leerraum 445Leichtgewichtprozess 564Lichtschalter 459LIFO 755List comprehension 205list() 112listdir () 412Liste 102, 204, 656
erzeugen 205list comprehension 205Modellierung 217Operationen 204sortieren 210verändern 207
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Stichwortverzeichnis
981
Literal 45, 83ljust 360load() 265Locals 594localtime() 423Lock-Mechanismus 938Log 585Log-Datei 585Logger-Objekt 592logging 585Logging-Level 587login() 642Logischer Fehler 78, 575Lokaler Name 162long 86lower() 361lstrip ([chars]) 362
MMandelbrotmenge 505Maskieren 381Master-Slave-Hierarchie 438match() 383Match-Objekt 387Matrix 858Matrizenmultiplikation 870MD5 666Medianfilter 885Mehrere Fenster 554Memory 533Menge 107, 123Menu 546
Methoden 547Optionen der Choices 548
Menü 546Mergesort 588Messagebox 551Metasprache 719Methode 35, 53, 282, 293MIT-License 970mkdir() 415mktime() 423mode 258Modell
externes 654internes 654konzeptuelles 653
Modellieren 327Modul 319
importieren 321
kompilieren 324Programmierstil 325speichern 321Zugang sicherstellen 323
modules 408Modulo 95Modus
Debugging 581interaktiver 39, 42optimierter 581
move() 496Multimedial 433Multimeter
digitales 899Multiplikation 93Musical 341
NNachbedingung 576Name 46
globaler 162lokaler 162
NameError 576Navigieren 632Negation 124Netiquette 634next() 224nextSibling 729Node 728nodeType 729None 87NoneType 87not 124not in 123NumPy 857
OOberklasse 283Objekt 45, 83, 281
Abstraktion 299anonymes 287Attribut 282Botschaft 53callable object 51für reguläre Ausdrücke 382Geheimnisprinzip 299Identität 46Instanz 285laden 265Match-Objekte 387
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Stichwortverzeichnis
982
Methode 53, 293Name 46speichern 264textuelle Repräsentation 372Typ 45Verkapselung 299Wert 45Zustand 287
Objektattribut 288Objektdiagramm 287Objektorientierte Analyse 327, 664Objektorientierte Programmierung 33Objektorientierte Software-Entwicklung 327Objektorientierter Entwurf 327Objektorientiertes Modellieren 327Objektsymbol (UML) 287offvalue 456Online-Abstimmung 622Online-Redaktionssystem 662Online-Shop 646onvalue 456OOA siehe Objektorientierte AnalyseOOD siehe Objektorientierter EntwurfOOP siehe Objektorientierte Programmie-
rungOpenStreetView 848Operator
- 93% 367+ 93in 123, 197logischer Operator 124Priorität 97überladen 294Vergleichsoperatoren 120, 876Vorzeichenoperator 93
Optimierter Modus 581Option 269or 126orient 458, 545os 411Over 595Ozonkonzentration 645
Ppack() 467Packer 467padx 440, 468, 471pady 440, 468, 471Paradigma 32
Parallele Datenverarbeitung 925Parallele Programmierung 925Parameter 153
aktueller 51, 153formaler 156
Parameterliste 156Parameterübergabe 166, 167Parameterwert
voreingestellter 168parentNode 729parse() 727parseString() 727Passende Zeichenkette 378Passwort 451Passworteingabefeld 606path 408pendown() 177Performance-Analyse 701, 709Pfad 255, 257
absolut 255relativ 257
Pfadbezeichnung 254PhotoImage 503
copy() 503height() 503put 504width() 503write() 504
pickle 264PIL.Image
crop() 514resize() 515size 515
pip 967Pixelgrafik 504platform 408Platonisches Schriftzeichen 363Playlist 837Polymorphie 294Polymorphismus 294pop() 756Portable Pixmap 512Positionsargument 171Potenz 92PPM 512previousSibling 729Primfaktor 579print 53Priorität 97Problem 74
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Stichwortverzeichnis
983
Problemspezifikation 74Profiler 701Programm 27Programmieren
objektorientiertes 33Programmierparadigma 32Programmierstil 75, 128, 188, 306, 325Programmierung
parallele 925Programmverzweigung 128Protokoll 629Prozess 563
unterbrechen 426Pseudofile 266Pulldown-Menü 546push() 756put() 504putenv() 419PyPI 968PyQT5 775PySerial 908Python Package Index 968Python-Homepage 39Python-Interpreter 42Python-Shell 43
QQCalendarWidget 819, 824QCamera 827QCheckbox 785QFileDialog 829QIcon 799QInputDialog 829QLabel 783QMessageBox 799QPixmap 783QPlayList 840QRadiobutton 785Qt 775QTextEdit 819Qt-Fenster 791QTimer 800Qt-Layout 802Qt-Widgets 781Qualifizierer 526Querystring 606Queue 758Quicksort 215, 584Quit 595quit() 643
QVideoPlayer 839QVideoWidget 844QViewFinder 825QWebView 808
RRadiobutton 453
command 454Erscheinungsform 453Selektion 454variable 454
Rahmen 443raise 582range() 136Raster-Layout 470Raumplan 761re 387read() 258, 639readline() 258reason 639Regel 48Regulärer Ausdruck 378Rekursionstiefe 184Rekursive Folge 139Rekursive Funktion 174Relation 655Relationale Datenbank 655relief 440removeChild(oldChild) 729RE-Objekt 382replace() 363request() 638resolution 458reST 971reStructuredText 971retrbinary() 631retrlines() 632rjust 360Rollbalken 544row 471rowspan 471rstrip() 362run module 66run() 567
SScale 457Schiffe versenken 482Schlange 758
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Stichwortverzeichnis
984
SchleifeAbbruch 139
Schlüssel 108Schlüsselwort 48Schlüsselwort-Argument 170Schriftzeichen
platonische 363Scrollbar 544sdist 973search() 383see() 543seek() 258Seiteneffekt 165Sekundenformat 423Selbstähnlich 180Selbstdokumentation 583select() 454SELECT-Anweisung 659Semantik 30sendmail() 642Sequenz 97
gemeinsame Operationen 197in 197Konkatenation 104, 197Länge 105, 198not in 197Slicing 199veränderbar und unveränderbar 106Vervielfältigung 105Zugriff 103
serial 910set 107set_debuglevel() 643setup.py 969Shell 42Shell-Fenster 66show 451showerror() 551showinfo() 551showturtle() 177showvalue 458showwarning() 551Sicht 654Sichtbarkeit 288side 468Sierpinski-Dreieck 180Signal 784Simple Mail Transfer Protocol 642SimpleCookie 618Size Policy 840
Skript 65Ausführung beenden 411
sleep() 423Slicing 199, 201, 864slider 544Slot 784SMTP 642Software 28Sommerzeit 424Sortieren 210Sortierverfahren 213Soziogramm 771Speech SDK 389speed() 177Speichern
Files 260Objekte 264
Spezialisierung 301Spirale 177split() 362, 383, 385splitlines() 362Sprachsynthese 389SQL 657SQL-Injection 661sqlite3 657Stack 755Stand-alone-Skript 319Standardausgabe 409Standardeingabe 409Stapel 755start_new_thread() 564, 565start() 387, 567Statement siehe Anweisungstatus 639stderr 408stdin 408stdout 408Steganografie 515, 879Step 594Sternenhimmel 705sticky 471StopIteration 224str() 111String 98
kurze Zeichenkette 98lange Zeichenkette 99siehe auch Zeichenkette
strip() 362Stylesheet 796sub() 383, 386
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Stichwortverzeichnis
985
Subklasse 300Submit-Button 608Suche
binäre 212Suchroboter 634Synchronisation 937Syntax 30Syntaxfehler 78sys 407sys.argv 270sys.path 323sys.stdin 266sys.stdout 266Systemfunktion 407Systemsoftware 28Systemumgebung 408
TTabelle 269tabs 541tag_bind() 496Taschenrechner 471Tastenname 528TCP/IP-Modell 629tell() 259Test
Turing 375Vorkommenstest 376
Test Driven Development 681Testen 319, 681TestPyPI 968Testreihe 693Text
Index-Formate 544Methoden 542Optionen 541Rollbalken 544
text 440Textanalyse 376Texteditor 542, 548textvariable 440Thread 563, 566, 925threading 564, 566time 55time() 423title() 447Tk 447tkFileDialog 550Tkinter 433, 495tkMessageBox 551
top() 756toprettyxml() 727toxml() 727Trennstring 385trough 544True 86, 87try 141Tuning 701, 709Tupel 101, 203tuple() 112Turing-Test 375Türme von Hanoi 192Turtle-Grafik 176Typ 45
None 87TypeError 576Typumwandlung 108
UÜberladen 294Umgebungsvariable 419UML 287UML-Klassendiagramm 334underline 440Unicode 363
utf-8 720unicode() 111unittest 693Unix
Programmausführung 68unlink() 729Unterklasse 300update() 241upper() 361URL 598USB-to-Serial 909use case 329UTC 422utf-8 720
VValueError 576values() 238VARCHAR 658Variablenname 56Vektor 858Verarbeitungsschicht 630Verbinden
Zeilen 70Vererbung 300
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791
Stichwortverzeichnis
986
Verfeinerung 158Vergleich 119Vergleichsoperator 120, 876Verkapselung 299Verzeichnis 253
anlegen 415Merkmale abfragen 416suchen 412
Verzeichnisbaum 420Verzweigung 129Videoplayer 833Vokabeltrainer 242Vorbedingung 576Voreingestellter Parameterwert 168Vorkommenstest 376
WWahrheitswert 87Währungsumrechner 460walk() 420Webbrowser 778Webseite 604Wegenetz 762Wegsuche 765Weltkarte 846Wert 45while 132Widerstandsthermometer 916Widget 437, 446
Button 447einfach 437Farbe 442Font 441Größe 443konfigurieren 440Layout 467Leerraum 445Master-Slave-Hierarchie 438Methoden 446Option 439, 440Rahmen 443Text 541
width 440, 444Wiederholung 132
Windows 66Wort des Jahres 684Wörterbuch 108, 328Wörterraten 483wrap 541write() 254, 259
XXML 719
Attribute 732Datenkommunikation 735Tags 720
xml.dom.minidom 726xscrollcommand 541
Yyield 223yscrollcommand 541
ZZahl
ganze 88Gleitkommazahl 90Hexadezimalzahl 89komplexe 91
Zeichenkette 98, 359formatieren 360kurze 98lange 99passende 378zerlegen 385
ZeileEinrückung 71verbinden 70
Zeilenstruktur 69Zeit 422Zeitkomplexität 213Zeitstring 425Zeittupel 424ZeroDivisionError 576Zugriffsrecht 413Zuweisung 56
erweitert 59Zuweisungsoperator 56
© des Titels »Python 3« (ISBN 9783958457911) 2018 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/791