Python 3 – Lernen und professionell anwenden · 5 Inhaltsverzeichnis Einleitung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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()


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)


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.


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


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.


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")


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)


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


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.


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


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


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


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.


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


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



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



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



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



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



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



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



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



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



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



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



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


Documents

Python 3 – Lernen und professionell anwenden · 5 Inhaltsverzeichnis Einleitung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23