|
|||||||||||||||||||
Python 3 (Lernen und professionell anwenden) (8. erweiterte Auflage, 2019). 1.056 Seiten + Errata (Fehlerberichtigungen) von: 2021 (als PDF-download!). von Michael Weigend ISBN: 9783747500514 Michael Weigend promovierte an der Universität Potsdam in Informatik. In seinen 30 Jahren als Lehrer hat er auch 20 Jahre lang an der Fern-Uni Hagen Seminare zur Didaktik der Informatik gegeben. In Münster (Westf.) hält er im Rahmen eines Lehrauftrags Vorlesungen zur Python-Programmierung. So auch wieder ab Okt. 2021, wo ich ihn besuchen werde. Das Buch behandelt die Grundlagen von Python 3 (Version 3.7)! In der Welt der Computer-Bücher sticht ein Buch mit einem derartigen Umfang schon heraus und die 8. Auflage (wie bei diesem Buch) erreicht aber sicherlich kaum ein Buch dieser Kategorie. Deshalb hat es mich auch sehr gereizt, mir dieses Buch zu bestellen und ihm genau "auf den Zahn zu fühlen". Und ja, es ist - worauf ich mein besonderes Augenmerk gerichtet habe - m.M.n. sehr gut für Einsteiger*innen geeignet. Es ist klar strukturiert (siehe das hier angehängte sehr umfangreiche Inhaltsverzeichnis und den reichhaltigen Index!) Michael Weigend hat ein System entwickelt, mit dem alle wichtigten Elemente dieser Programmiersprache: vom interaktiven Modus (dem direktesten Zugang zu Python) über: Skripte, Klassen, Funktionen, Bibliotheken (dies sind Programmmodule mit Python-Funktionen, die die eigene Arbeit ungemein erleichtern können!), der speicherbaren Programmierung (etwa in PyCharm), bis hin zur Gestaltung von Benutzeroberflächen (wie mit tkinter) berücksichtigt werden. Alle Kapitel schließen mit einfachen und auch komplexeren Übungsaufgaben und haben gut beschriebene Musterlösungen. Das Buch ist auch gelungen gestaltet. So sind die sehr zahlreichen Beispiele in Kästchen (grau hinterlegt) dargestellt und lassen sich so sehr gut und schnell erfassen. Ich empfehle - gerade für die längeren Programmbeispiele (Listings) - sich (wie es im Buch auf S. 24 unten angegeben ist) die Programmbeispiele zu diesem Buch (kostenlos) herunterzuladen: http://www.mitp.de/0051 * Die Programmiersprache Python finde ich auch deshalb sehr interessant, weil die riesige, weltweite Python-Gemeinde Tausende von Bibliotheken (Python-Funktionen) entwickelt hat und immer weitere dazu kommen. So kann man es sich als Programmier*in sparen, alles selber erfinden zu müssen!!! ** Python "schwebt" übrigens ständig über unser aller Köpfen! Die Programmiersprache wird nämlich auf nur scheckkartengroßen Rasberry Pi-Einplatinen-Computern (die nur einen extrem geringen Stromverbrauch haben!) in der ISS-Raumstation für allerlei Aufgaben eingesetzt!!! |
|||||||||||||||||||
Inhaltsverzeichnis Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Warum Python? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Python 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . An wen wendet sich dieses Buch? . . . . . . . . . . . . . . . . . . . . . Inhalt und Aufbau . . . . . . . . . . . . . . . . . . . . . . . . . . . . Hinweise zur Typographie . . . . . . . . . . . . . . . . . . . . . . . . . Programmbeispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.1 Was ist Programmieren? . . . . . . . . . . . . . . . . . . . . . . . . 1.2 Hardware und Software. . . . . . . . . . . . . . . . . . . . . . . . . 1.3 Programm als Algorithmus . . . . . . . . . . . . . . . . . . . . . . . 1.4 Syntax und Semantik. . . . . . . . . . . . . . . . . . . . . . . . . . 1.5 Interpreter und Compiler . . . . . . . . . . . . . . . . . . . . . . . 1.6 Programmierparadigmen . . . . . . . . . . . . . . . . . . . . . . . . 1.7 Objektorientierte Programmierung . . . . . . . . . . . . . . . . . . . 1.7.1 Strukturelle Zerlegung . . . . . . . . . . . . . . . . . . . . . . . 1.7.2 Die Welt als System von Objekten . . . . . . . . . . . . . . . . . . 1.7.3 Objekte besitzen Attribute und beherrschen Methoden . . . . . . . . 1.7.4 Objekte sind Instanzen von Klassen . . . . . . . . . . . . . . . . . 1.8 Hintergrund: Geschichte der objektorientierten Programmierung . . . . 1.9 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.10 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 Der Einstieg – Python im interaktiven Modus . . . . . . . . . . . . . . 2.1 Python installieren. . . . . . . . . . . . . . . . . . . . . . . . . . 2.2 Python im interaktiven Modus . . . . . . . . . . . . . . . . . . . . . 2.2.1 Start des Python-Interpreters in einem Konsolenfenster . . . . . . . 2.2.2 Die Python-Shell von IDLE. . . . . . . . . . . . . . . . . . . . . . 2.2.3 Die ersten Python-Befehle ausprobieren . . . . . . . . . . . . . . . 2.2.4 Hotkeys . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.3 Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.4 Namen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.5 Hintergrund: Syntax-Regeln für Bezeichner . . . . . . . . . . . . . . 2.6 Schlüsselwörter . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.7 Anweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.7.1 Ausdruckanweisungen . . . . . . . . . . . . . . . . . . . . . . . . 2.7.2 Import-Anweisungen . . . . . . . . . . . . . . . . . . . . . . . . . 2.7.3 Zuweisungen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.7.4 Erweiterte Zuweisungen . . . . . . . . . . . . . . . . . . . . . . . Inhaltsverzeichnis 06 2.7.5 Hintergrund: Dynamische Typisierung . . . . . . . . . . . . . . . . 2.8 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.9 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 Python-Skripte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.1 Ausprobieren, nachmachen, besser machen! . . . . . . . . . . . . . . . 3.2 Skripte editieren und ausführen mit IDLE . . . . . . . . . . . . . . . 3.3 Ausführen eines Python-Skripts . . . . . . . . . . . . . . . . . . . . 3.4 Kommentare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.5 Die Zeilenstruktur von Python-Programmen . . . . . . . . . . . . . . . 3.6 Das EVA-Prinzip . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.7 Phasen der Programmentwicklung . . . . . . . . . . . . . . . . . . . . 3.8 Guter Programmierstil . . . . . . . . . . . . . . . . . . . . . . . . 3.9 Hintergrund: Die Kunst des Fehlerfindens . . . . . . . . . . . . . . . 3.10 Weitere Entwicklungsumgebungen für Python . . . . . . . . . . . . . . 3.11 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.12 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 Standard-Datentypen. . . . . . . . . . . . . . . . . . . . . . . . . . . 4.1 Daten als Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . 4.2 Fundamentale Datentypen im Überblick . . . . . . . . . . . . . . . . . 4.3 Typen und Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . 4.4 NoneType . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.5 Wahrheitswerte – der Datentyp bool . . . . . . . . . . . . . . . . . . 4.6 Ganze Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.7 Gleitkommazahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.8 Komplexe Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.9 Arithmetische Operatoren für Zahlen. . . . . . . . . . . . . . . . . . 4.10 Sequenzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.10.1 Zeichenketten (Strings) . . . . . . . . . . . . . . . . . . . . . . 4.10.2 Bytestrings . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.10.3 Tupel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.10.4 Liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.10.5 Bytearray . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.10.6 Einige Grundoperationen für Sequenzen . . . . . . . . . . . . . . . 4.10.7 Veränderbare und unveränderbare Sequenzen . . . . . . . . . . . . . 4.11 Mengen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.12 Dictionaries . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.13 Typumwandlungen . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.13.1 int() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.13.2 float() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.13.3 complex() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.13.4 bool() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.13.5 str() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.13.6 dict(), list() und tuple() . . . . . . . . . . . . . . . . . . . . Inhaltsverzeichnis 07 4.14 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.15 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 Kontrollstrukturen . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.1 Einfache Bedingungen . . . . . . . . . . . . . . . . . . . . . . . . . 5.1.1 Vergleiche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.1.2 Zugehörigkeit zu einer Menge (in, not in) . . . . . . . . . . . . . 5.1.3 Beliebige Ausdrücke als Bedingungen . . . . . . . . . . . . . . . . 5.2 Zusammengesetzte Bedingungen – logische Operatoren . . . . . . . . . . 5.2.1 Negation (not) . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.2.2 Konjunktion (and). . . . . . . . . . . . . . . . . . . . . . . . . . 5.2.3 Disjunktion (or) . . . . . . . . . . . . . . . . . . . . . . . . . . 5.2.4 Formalisierung von Bedingungen . . . . . . . . . . . . . . . . . . . 5.2.5 Hinweis zum Programmierstil . . . . . . . . . . . . . . . . . . . . 5.3 Programmverzweigungen (bedingte Anweisungen) . . . . . . . . . . . . . 5.3.1 Einseitige Verzweigung (if) . . . . . . . . . . . . . . . . . . . . 5.3.2 Zweiseitige Verzweigung (if-else) . . . . . . . . . . . . . . . . . 5.3.3 Mehrfache Fallunterscheidung (elif) . . . . . . . . . . . . . . . . 5.3.4 Bedingte Ausdrücke . . . . . . . . . . . . . . . . . . . . . . . . . 5.4 Bedingte Wiederholung (while) . . . . . . . . . . . . . . . . . . . . 5.4.1 Endlosschleifen . . . . . . . . . . . . . . . . . . . . . . . . . . 5.5 Iteration über eine Kollektion (for) . . . . . . . . . . . . . . . . . 5.5.1 Zählschleifen – Verwendung von range() . . . . . . . . . . . . . . . 5.5.2 Verschachtelte Iterationen . . . . . . . . . . . . . . . . . . . . . 5.5.3 Vertiefung: Iterative Berechnung rekursiver Folgen . . . . . . . . . 5.6 Abbruch einer Schleife mit break . . . . . . . . . . . . . . . . . . . 5.6.1 Abbruch eines Schleifendurchlaufs mit continue . . . . . . . . . . . 5.7 Abfangen von Ausnahmen mit try . . . . . . . . . . . . . . . . . . . . 5.7.1 try...except . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.8 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.9 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.1 Aufruf von Funktionen . . . . . . . . . . . . . . . . . . . . . . . . 6.2 Definition von Funktionen . . . . . . . . . . . . . . . . . . . . . . 6.3 Schrittweise Verfeinerung. . . . . . . . . . . . . . . . . . . . . . . 6.4 Ausführung von Funktionen . . . . . . . . . . . . . . . . . . . . . . 6.4.1 Globale und lokale Namen . . . . . . . . . . . . . . . . . . . . . . 6.4.2 Seiteneffekte – die global-Anweisung . . . . . . . . . . . . . . . . 6.4.3 Parameterübergabe . . . . . . . . . . . . . . . . . . . . . . . . . 6.5 Voreingestellte Parameterwerte . . . . . . . . . . . . . . . . . . . . 6.5.1 Schlüsselwort-Argumente . . . . . . . . . . . . . . . . . . . . . . 6.6 Funktionen mit beliebiger Anzahl von Parametern . . . . . . . . . . . 6.7 Lokale Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . 6.8 Rekursive Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . Inhaltsverzeichnis 08 6.9 Experimente zur Rekursion mit der Turtle-Grafik . . . . . . . . . . . 6.9.1 Turtle-Befehle im interaktiven Modus . . . . . . . . . . . . . . . . 6.9.2 Eine rekursive Spirale . . . . . . . . . . . . . . . . . . . . . . . 6.9.3 Baumstrukturen . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.9.4 Künstlicher Blumenkohl – selbstähnliche Bilder . . . . . . . . . . . 6.10 Rekursive Zahlenfunktionen . . . . . . . . . . . . . . . . . . . . . 6.11 Hintergrund: Wie werden rekursive Funktionen ausgeführt? . . . . . . 6.11.1 Execution Frames . . . . . . . . . . . . . . . . . . . . . . . . . 6.11.2 Rekursionstiefe . . . . . . . . . . . . . . . . . . . . . . . . . . 6.12 Funktionen als Objekte. . . . . . . . . . . . . . . . . . . . . . . . 6.12.1 Hintergrund: Typen sind keine Funktionen . . . . . . . . . . . . . 6.13 Lambda-Formen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.14 Funktionsannotationen: Typen zuordnen . . . . . . . . . . . . . . . . 6.15 Hinweise zum Programmierstil. . . . . . . . . . . . . . . . . . . . . 6.15.1 Allgemeines . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.15.2 Funktionsnamen. . . . . . . . . . . . . . . . . . . . . . . . . . . 6.15.3 Kommentierte Parameter. . . . . . . . . . . . . . . . . . . . . . . 6.15.4 Docstrings . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.16 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.17 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 Sequenzen, Mengen und Generatoren . . . . . . . . . . . . . . . . . . . 7.1 Gemeinsame Operationen für Sequenzen . . . . . . . . . . . . . . . . . 7.1.1 Zugriff auf Elemente einer Sequenz . . . . . . . . . . . . . . . . . 7.1.2 Slicing von Sequenzen . . . . . . . . . . . . . . . . . . . . . . . 7.1.3 Auspacken (unpacking) . . . . . . . . . . . . . . . . . . . . . . . 7.2 Vertiefung: Rekursive Funktionen für Sequenzen . . . . . . . . . . . . 7.2.1 Rekursives Summieren . . . . . . . . . . . . . . . . . . . . . . . . 7.2.2 Rekursive Suche . . . . . . . . . . . . . . . . . . . . . . . . . . 7.3 Tupel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.4 Listen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.4.1 Eine Liste erzeugen. . . . . . . . . . . . . . . . . . . . . . . . . 7.4.2 Eine Liste verändern . . . . . . . . . . . . . . . . . . . . . . . . 7.4.3 Flache und tiefe Kopien . . . . . . . . . . . . . . . . . . . . . . 7.4.4 Listen sortieren . . . . . . . . . . . . . . . . . . . . . . . . . . 7.4.5 Binäre Suche in einer sortierten Liste . . . . . . . . . . . . . . . 7.4.6 Zwei Sortierverfahren im Vergleich . . . . . . . . . . . . . . . . . 7.4.7 Modellieren mit Listen – Beispiel: die Charts . . . . . . . . . . . 7.5 Generatoren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.5.1 Generatorausdrücke . . . . . . . . . . . . . . . . . . . . . . . . . 7.5.2 Generatorfunktionen . . . . . . . . . . . . . . . . . . . . . . . . 7.5.3 Iteratoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.5.4 Verwendung von Generatoren . . . . . . . . . . . . . . . . . . . . . 7.6 Mengen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.6.1 Operationen für Mengen . . . . . . . . . . . . . . . . . . . . . . . Inhaltsverzeichnis 09 7.6.2 Modellieren mit Mengen – Beispiel: Graphen . . . . . . . . . . . . . 7.7 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.8 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 Dictionaries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.1 Operationen für Dictionaries . . . . . . . . . . . . . . . . . . . . . 8.2 Wie erstellt man ein Dictionary? . . . . . . . . . . . . . . . . . . . 8.2.1 Definition mit einem Dictionary-Display . . . . . . . . . . . . . . 8.2.2 Schrittweiser Aufbau eines Dictionarys . . . . . . . . . . . . . . . 8.2.3 Ein Dictionary aus anderen Dictionaries zusammensetzen – update() . 8.3 Zugriff auf Daten in einem Dictionary . . . . . . . . . . . . . . . . 8.3.1 Vergebliche Zugriffsversuche . . . . . . . . . . . . . . . . . . . . 8.4 Praxisbeispiel: Vokabeltrainer . . . . . . . . . . . . . . . . . . . . 8.5 Typische Fehler . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.6 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.7 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 Ein- und Ausgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.1 Files. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.1.1 Die Rolle der Files bei E/A-Operationen . . . . . . . . . . . . . . 9.1.2 Was ist ein File?. . . . . . . . . . . . . . . . . . . . . . . . . . 9.1.3 Ein File-Objekt erzeugen . . . . . . . . . . . . . . . . . . . . . . 9.1.4 Speichern einer Zeichenkette . . . . . . . . . . . . . . . . . . . . 9.1.5 Laden einer Zeichenkette aus einer Datei . . . . . . . . . . . . . . 9.1.6 Absolute und relative Pfade . . . . . . . . . . . . . . . . . . . . 9.1.7 Zwischenspeichern, ohne zu schließen . . . . . . . . . . . . . . . . 9.1.8 Zugriff auf Files (lesen und schreiben) . . . . . . . . . . . . . . 9.1.9 Speichern beliebiger Daten auf Files . . . . . . . . . . . . . . . . 9.2 Mehr Zuverlässigkeit durch try- und with-Anweisungen . . . . . . . . . 9.2.1 try...finally . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.2.2 with-Anweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . 9.3 Objekte speichern mit pickle . . . . . . . . . . . . . . . . . . . . . 9.3.1 Funktionen zum Speichern und Laden . . . . . . . . . . . . . . . . . 9.4 Die Pseudofiles sys.stdin und sys.stdout . . . . . . . . . . . . . . . 9.5 Ausgabe von Werten mit der print()-Funktion . . . . . . . . . . . . . 9.5.1 Anwendung: Ausgabe von Tabellen . . . . . . . . . . . . . . . . . . 9.6 Kommandozeilen-Argumente (Optionen). . . . . . . . . . . . . . . . . . 9.7 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.8 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 Definition eigener Klassen . . . . . . . . . . . . . . . . . . . . . . 10.1 Klassen und Objekte . . . . . . . . . . . . . . . . . . . . . . . . . 10.2 Definition von Klassen . . . . . . . . . . . . . . . . . . . . . . . 10.3 Objekte (Instanzen) . . . . . . . . . . . . . . . . . . . . . . . . . Inhaltsverzeichnis 10 10.4 Zugriff auf Attribute – Sichtbarkeit . . . . . . . . . . . . . . . . 10.4.1 Öffentliche Attribute . . . . . . . . . . . . . . . . . . . . . . . 10.4.2 Private Attribute . . . . . . . . . . . . . . . . . . . . . . . . . 10.4.3 Properties . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.4.4 Dynamische Erzeugung von Attributen . . . . . . . . . . . . . . . . 10.5 Methoden. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.5.1 Polymorphismus – Überladen von Operatoren . . . . . . . . . . . . . 10.5.2 Vertiefung: Objekte ausführbar machen – die Methode __call__() . . 10.5.3 Statische Methoden . . . . . . . . . . . . . . . . . . . . . . . . 10.6 Abstraktion, Verkapselung und Geheimnisprinzip . . . . . . . . . . . 10.7 Vererbung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.7.1 Spezialisierungen . . . . . . . . . . . . . . . . . . . . . . . . . 10.7.2 Beispiel: Die Klasse Konto – eine Spezialisierung der Klasse Geld . 10.7.3 Vertiefung: Standardklassen als Basisklassen . . . . . . . . . . . 10.8 Hinweise zum Programmierstil. . . . . . . . . . . . . . . . . . . . . 10.8.1 Bezeichner. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.8.2 Sichtbarkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.8.3 Dokumentation von Klassen . . . . . . . . . . . . . . . . . . . . . 10.9 Typische Fehler . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.10 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.11 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 Klassenbibliotheken in Modulen speichern . . . . . . . . . . . . . . . 11.1 Testen einer Klasse in einem lauffähigen Stand-alone-Skript . . . . . 11.2 Module speichern und importieren. . . . . . . . . . . . . . . . . . . 11.3 Den Zugang zu einem Modul sicherstellen . . . . . . . . . . . . . . . 11.4 Programmierstil: Verwendung und Dokumentation von Modulen . . . . . . 12 Objektorientiertes Modellieren . . . . . . . . . . . . . . . . . . . . 12.1 Phasen einer objektorientierten Software-Entwicklung . . . . . . . . 12.2 Fallstudie: Modell eines Wörterbuchs . . . . . . . . . . . . . . . . 12.2.1 OOA: Entwicklung einer Klassenstruktur . . . . . . . . . . . . . . 12.2.2 OOD: Entwurf einer Klassenstruktur: Implementierung in Python . . . 12.2.3 OOP: Implementierung der Klassenstruktur . . . . . . . . . . . . . 12.3 Assoziationen zwischen Klassen . . . . . . . . . . . . . . . . . . . 12.3.1 Reflexive Assoziationen . . . . . . . . . . . . . . . . . . . . . . 12.3.2 Aggregation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.4 Beispiel: Management eines Musicals . . . . . . . . . . . . . . . . . 12.4.1 OOA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.4.2 OOD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.4.3 OOP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.5 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.6 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Inhaltsverzeichnis 11 13 Textverarbeitung . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.1 Standardmethoden zur Verarbeitung von Zeichenketten . . . . . . . . . 13.1.1 Formatieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.1.2 Schreibweise . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.1.3 Tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.1.4 Entfernen und Aufspalten . . . . . . . . . . . . . . . . . . . . . 13.1.5 Suchen und Ersetzen . . . . . . . . . . . . . . . . . . . . . . . . 13.2 Codierung und Decodierung . . . . . . . . . . . . . . . . . . . . . . 13.2.1 Platonische Zeichen und Unicode . . . . . . . . . . . . . . . . . . 13.2.2 Vertiefung: Zeichenketten durch Bytefolgen darstellen . . . . . . . 13.3 Automatische Textproduktion . . . . . . . . . . . . . . . . . . . . . 13.3.1 Texte mit variablen Teilen – Anwendung: String-Methode format() . . 13.3.2 Vertiefung: Eine Tabelle erstellen . . . . . . . . . . . . . . . . 13.3.3 Mahnbriefe . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.3.4 Textuelle Repräsentation eines Objektes . . . . . . . . . . . . . . 13.3.5 F-Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.4 Analyse von Texten . . . . . . . . . . . . . . . . . . . . . . . . . 13.4.1 Chat Bots . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.4.2 Textanalyse mit einfachen Vorkommenstests . . . . . . . . . . . . . 13.5 Reguläre Ausdrücke. . . . . . . . . . . . . . . . . . . . . . . . . . 13.5.1 Aufbau eines regulären Ausdrucks . . . . . . . . . . . . . . . . . 13.5.2 Objekte für reguläre Ausdrücke (RE-Objekte) . . . . . . . . . . . . 13.5.3 Analyse von Strings mit match() und search() . . . . . . . . . . . 13.5.4 Textpassagen extrahieren mit findall() . . . . . . . . . . . . . . 13.5.5 Zeichenketten zerlegen mit split(). . . . . . . . . . . . . . . . . 13.5.6 Teilstrings ersetzen mit sub(). . . . . . . . . . . . . . . . . . . 13.5.7 Match-Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.6 Den Computer zum Sprechen bringen – Sprachsynthese . . . . . . . . . 13.6.1 Buchstabieren . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.6.2 Den Klang der Stimme verändern . . . . . . . . . . . . . . . . . . 13.7 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.8 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 Systemfunktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.1 Das Modul sys – die Schnittstelle zum Laufzeitsystem . . . . . . . . 14.1.1 Informationen über die aktuelle Systemumgebung. . . . . . . . . . . 14.1.2 Standardeingabe und -ausgabe. . . . . . . . . . . . . . . . . . . . 14.1.3 Die Objektverwaltung beobachten mit getrefcount() . . . . . . . . . 14.1.4 Ausführung eines Skripts beenden . . . . . . . . . . . . . . . . . 14.2 Das Modul os – die Schnittstelle zum Betriebssystem . . . . . . . . . 14.2.1 Dateien und Verzeichnisse suchen . . . . . . . . . . . . . . . . . 14.2.2 Hintergrund: Zugriffsrechte abfragen und ändern (Windows und Unix). 14.2.3 Dateien und Verzeichnisse anlegen und modifizieren . . . . . . . . Inhaltsverzeichnis 12 14.2.4 Merkmale von Dateien und Verzeichnissen abfragen. . . . . . . . . . 14.2.5 Pfade verarbeiten . . . . . . . . . . . . . . . . . . . . . . . . . 14.2.6 Hintergrund: Umgebungsvariablen . . . . . . . . . . . . . . . . . . 14.2.7 Systematisches Durchlaufen eines Verzeichnisbaumes . . . . . . . . 14.3 Datum und Zeit. . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.3.1 Funktionen des Moduls time. . . . . . . . . . . . . . . . . . . . . 14.3.2 Sekundenformat . . . . . . . . . . . . . . . . . . . . . . . . . . 14.3.3 Zeit-Tupel . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.3.4 Zeitstrings . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.3.5 Einen Prozess unterbrechen mit sleep(). . . . . . . . . . . . . . . 14.4 Zeitberechnungen mit dem Modul datetime . . . . . . . . . . . . . . . 14.4.1 Die Klasse datetime . . . . . . . . . . . . . . . . . . . . . . . . 14.4.2 Die Zeitzone . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.4.3 Die Klasse timedelta . . . . . . . . . . . . . . . . . . . . . . . 14.5 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.6 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 Grafische Benutzungsoberflächen mit tkinter . . . . . . . . . . . . . . 15.1 Ein einführendes Beispiel . . . . . . . . . . . . . . . . . . . . . . 15.2 Einfache Widgets . . . . . . . . . . . . . . . . . . . . . . . . . . 15.3 Die Master-Slave-Hierarchie . . . . . . . . . . . . . . . . . . . . . 15.4 Optionen der Widgets . . . . . . . . . . . . . . . . . . . . . . . . 15.4.1 Optionen bei der Instanziierung setzen . . . . . . . . . . . . . . 15.4.2 Widget-Optionen nachträglich konfigurieren . . . . . . . . . . . . 15.4.3 Fonts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.4.4 Farben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.4.5 Rahmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.4.6 Die Größe eines Widgets . . . . . . . . . . . . . . . . . . . . . . 15.4.7 Leerraum um Text . . . . . . . . . . . . . . . . . . . . . . . . . 15.5 Gemeinsame Methoden der Widgets . . . . . . . . . . . . . . . . . . . 15.6 Die Klasse Tk . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.7 Die Klasse Button . . . . . . . . . . . . . . . . . . . . . . . . . . 15.8 Die Klasse Label. . . . . . . . . . . . . . . . . . . . . . . . . . . 15.8.1 Dynamische Konfiguration der Beschriftung . . . . . . . . . . . . . 15.8.2 Verwendung von Kontrollvariablen. . . . . . . . . . . . . . . . . . 15.9 Die Klasse Entry. . . . . . . . . . . . . . . . . . . . . . . . . . . 15.10 Die Klasse Radiobutton . . . . . . . . . . . . . . . . . . . . . . . 15.11 Die Klasse Checkbutton . . . . . . . . . . . . . . . . . . . . . . . 15.12 Die Klasse Scale . . . . . . . . . . . . . . . . . . . . . . . . . . 15.13 Die Klasse Frame . . . . . . . . . . . . . . . . . . . . . . . . . . 15.14 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.15 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 Layout. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16.1 Der Packer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Inhaltsverzeichnis 13 16.2 Layout-Fehler . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16.3 Raster-Layout . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16.4 Vorgehensweise bei der GUI-Entwicklung . . . . . . . . . . . . . . . 16.4.1 Die Benutzungsoberfläche gestalten . . . . . . . . . . . . . . . . 16.4.2 Funktionalität hinzufügen . . . . . . . . . . . . . . . . . . . . . 16.5 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16.6 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 Grafik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17.1 Die tkinter-Klasse Canvas . . . . . . . . . . . . . . . . . . . . . . 17.1.1 Generierung grafischer Elemente – ID, Positionierung/Display-Liste. 17.1.2 Grafische Elemente gestalten. . . . . . . . . . . . . . . . . . . . 17.1.3 Visualisieren mit Kreisdiagrammen . . . . . . . . . . . . . . . . . 17.2 Die Klasse PhotoImage . . . . . . . . . . . . . . . . . . . . . . . . 17.2.1 Eine Pixelgrafik erzeugen. . . . . . . . . . . . . . . . . . . . . 17.2.2 Fotos analysieren und verändern . . . . . . . . . . . . . . . . . . 17.3 Bilder in eine Benutzungsoberfläche einbinden . . . . . . . . . . . . 17.3.1 Icons auf Schaltflächen . . . . . . . . . . . . . . . . . . . . . . 17.3.2 Hintergrundbilder . . . . . . . . . . . . . . . . . . . . . . . . . 17.3.3 Hintergrund: Das PPM-Format . . . . . . . . . . . . . . . . . . . . 17.4 Die Python Imaging Library (PIL) . . . . . . . . . . . . . . . . . . 17.4.1 Installation eines Moduls mit pip . . . . . . . . . . . . . . . . . 17.4.2 Mit PIL beliebige Bilddateien einbinden . . . . . . . . . . . . . . 17.4.3 Steganografie – Informationen in Bildern verstecken . . . . . . . . 17.5 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17.6 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 Event-Verarbeitung . . . . . . . . . . . . . . . . . . . . . . . . . . 18.1 Einführendes Beispiel . . . . . . . . . . . . . . . . . . . . . . . . 18.2 Event-Sequenzen . . . . . . . . . . . . . . . . . . . . . . . . . . . 18.2.1 Event-Typen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18.2.2 Qualifizierer für Maus- und Tastatur-Events . . . . . . . . . . . . 18.2.3 Modifizierer. . . . . . . . . . . . . . . . . . . . . . . . . . . . 18.3 Beispiel: Tastaturereignisse verarbeiten. . . . . . . . . . . . . . . 18.4 Programmierung eines Eventhandlers . . . . . . . . . . . . . . . . . 18.4.1 Beispiel für eine Event-Auswertung . . . . . . . . . . . . . . . . 18.5 Bindemethoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18.6 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18.7 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 Komplexe Benutzungsoberflächen. . . . . . . . . . . . . . . . . . . . . 19.1 Text-Widgets. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19.1.1 Methoden der Text-Widgets . . . . . . . . . . . . . . . . . . . . . 19.2 Rollbalken (Scrollbars) . . . . . . . . . . . . . . . . . . . . . . . Inhaltsverzeichnis 14 19.3 Menüs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19.3.1 Die Klasse Menu . . . . . . . . . . . . . . . . . . . . . . . . . . 19.3.2 Methoden der Klasse Menu . . . . . . . . . . . . . . . . . . . . . 19.4 Texteditor mit Menüleiste und Pulldown-Menü . . . . . . . . . . . . . 19.5 Dialogboxen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19.6 Applikationen mit mehreren Fenstern . . . . . . . . . . . . . . . . . 19.7 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19.8 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 Threads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20.1 Funktionen in einem Thread ausführen . . . . . . . . . . . . . . . . 20.2 Thread-Objekte erzeugen – die Klasse Thread . . . . . . . . . . . . . 20.3 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20.4 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 Fehler finden und vermeiden . . . . . . . . . . . . . . . . . . . . . . 21.1 Testen von Bedingungen . . . . . . . . . . . . . . . . . . . . . . . 21.1.1 Ausnahmen (Exceptions) . . . . . . . . . . . . . . . . . . . . . . 21.1.2 Testen von Vor- und Nachbedingungen mit assert . . . . . . . . . . 21.1.3 Vertiefung: Programmabstürze ohne Fehlermeldung . . . . . . . . . . 21.2 Debugging-Modus und optimierter Modus . . . . . . . . . . . . . . . . 21.3 Ausnahmen gezielt auslösen . . . . . . . . . . . . . . . . . . . . . 21.4 Selbstdokumentation . . . . . . . . . . . . . . . . . . . . . . . . . 21.5 Dokumentation eines Programmlaufs mit Log-Dateien . . . . . . . . . . 21.5.1 Grundfunktionen . . . . . . . . . . . . . . . . . . . . . . . . . . 21.5.2 Beispiel: Logging in der GUI-Programmierung. . . . . . . . . . . . 21.6 Vertiefung: Professionelles Arbeiten mit Logging . . . . . . . . . . 21.6.1 Logging-Levels. . . . . . . . . . . . . . . . . . . . . . . . . . . 21.6.2 Logger-Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . 21.6.3 Das Format der Logging-Meldungen konfigurieren . . . . . . . . . . 21.7 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.8 Aufgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.9 Lösung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 Dynamische Webseiten – CGI und WSGI . . . . . . . . . . . . . . . . . . 22.1 Wie funktionieren dynamische Webseiten? . . . . . . . . . . . . . . . 22.2 Wie spät ist es? Aufbau eines CGI-Skripts . . . . . . . . . . . . . . 22.2.1 Ein einfacher HTTP-Server . . . . . . . . . . . . . . . . . . . . . 22.3 Kommunikation über interaktive Webseiten . . . . . . . . . . . . . . 22.3.1 Aufbau eines HTML-Formulars . . . . . . . . . . . . . . . . . . . . 22.3.2 Eingabekomponenten in einem HTML-Formular. . . . . . . . . . . . . 22.4 Verarbeitung von Eingabedaten mit FieldStorage . . . . . . . . . . . 22.5 Sonderzeichen handhaben . . . . . . . . . . . . . . . . . . . . . . . 22.6 CGI-Skripte debuggen . . . . . . . . . . . . . . . . . . . . . . . . 22.7 Der Apache-Webserver . . . . . . . . . . . . . . . . . . . . . . . . 22.7.1 Den Apache-Server installieren . . . . . . . . . . . . . . . . . . Inhaltsverzeichnis 15 22.7.2 CGI-Skripte auf dem Apache-Server . . . . . . . . . . . . . . . . . 22.8 Dynamische Webseiten mit WSGI. . . . . . . . . . . . . . . . . . . . 22.8.1 Einfacher geht’s nicht: Ein Stand-alone-WSGI-Webserver: wsgiref . . 22.9 mod_wscgi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22.9.1 Installation. . . . . . . . . . . . . . . . . . . . . . . . . . . . 22.9.2 Vorbereitung . . . . . . . . . . . . . . . . . . . . . . . . . . . 22.9.3 Den Apache-Server konfigurieren . . . . . . . . . . . . . . . . . . 22.9.4 Ein WSGI-Skript für den Apache-Server . . . . . . . . . . . . . . . 22.9.5 Tipps zum Debuggen . . . . . . . . . . . . . . . . . . . . . . . . 22.9.6 Zugriff von einem entfernten Rechner im WLAN . . . . . . . . . . . 22.10 Verarbeitung von Eingabedaten aus Formularen . . . . . . . . . . . . 22.11 Objektorientierte WSGI-Skripte – Beispiel: ein Chatroom. . . . . . . 22.11.1 Die HTML-Seiten . . . . . . . . . . . . . . . . . . . . . . . . . 22.11.2 Die Klassen für den Chatroom. . . . . . . . . . . . . . . . . . . 22.11.3 Skript (Teil 2): . . . . . . . . . . . . . . . . . . . . . . . . . 22.12 WSGI-Skripte mit Cookies . . . . . . . . . . . . . . . . . . . . . . 22.12.1 Besuche zählen . . . . . . . . . . . . . . . . . . . . . . . . . . 22.13 Aufgabe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22.14 Lösung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 Internet-Programmierung. . . . . . . . . . . . . . . . . . . . . . . . 23.1 Was ist ein Protokoll? . . . . . . . . . . . . . . . . . . . . . . . 23.2 Übertragung von Dateien mit FTP. . . . . . . . . . . . . . . . . . . 23.2.1 Das Modul ftplib . . . . . . . . . . . . . . . . . . . . . . . . . 23.2.2 Navigieren und Downloaden . . . . . . . . . . . . . . . . . . . . . 23.2.3 Ein Suchroboter für FTP-Server. . . . . . . . . . . . . . . . . . . 23.3 Zugriff auf Webseiten mit HTTP und HTTPS . . . . . . . . . . . . . . 23.3.1 Automatische Auswertung von Webseiten . . . . . . . . . . . . . . . 23.4 Zugriff auf Ressourcen im Internet über deren URL . . . . . . . . . . 23.4.1 Webseite herunterladen und verarbeiten . . . . . . . . . . . . . . 23.4.2 Projekt: Wie warm wird es heute? . . . . . . . . . . . . . . . . . 23.4.3 Datei herunterladen und speichern . . . . . . . . . . . . . . . . . 23.4.4 Projekt: Filme herunterladen . . . . . . . . . . . . . . . . . . . 23.5 E-Mails senden mit SMTP . . . . . . . . . . . . . . . . . . . . . . . 23.6 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23.7 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 Datenbanken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24.1 Was ist ein Datenbanksystem? . . . . . . . . . . . . . . . . . . . . 24.2 Entity-Relationship-Diagramme (ER-Diagramme) . . . . . . . . . . . . 24.3 Relationale Datenbanken . . . . . . . . . . . . . . . . . . . . . . . 24.4 Darstellung von Relationen als Listen oder Dictionaries . . . . . . . 24.5 Das Modul sqlite3 . . . . . . . . . . . . . . . . . . . . . . . . . . 24.5.1 Eine Tabelle anlegen . . . . . . . . . . . . . . . . . . . . . . . Inhaltsverzeichnis 16 24.5.2 Anfragen an eine Datenbank . . . . . . . . . . . . . . . . . . . . 24.5.3 SQL-Anweisungen mit variablen Teilen . . . . . . . . . . . . . . . 24.5.4 SQL-Injections . . . . . . . . . . . . . . . . . . . . . . . . . . 24.6 Online-Redaktionssystem mit Datenbankanbindung . . . . . . . . . . . 24.6.1 Objektorientierte Analyse (OOA). . . . . . . . . . . . . . . . . . 24.6.2 Objektorientierter Entwurf des Systems (OOD). . . . . . . . . . . . 24.6.3 Hintergrund: Authentifizieren mit MD5-Fingerprints . . . . . . . . 24.6.4 Implementierung des Redaktionssystems mit Python (OOP) . . . . . 24.7 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24.8 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 Testen und Tuning . . . . . . . . . . . . . . . . . . . . . . . . . . . 25.1 Automatisiertes Testen . . . . . . . . . . . . . . . . . . . . . . . 25.2 Testen mit Docstrings – das Modul doctest . . . . . . . . . . . . . . 25.3 Praxisbeispiel: Suche nach dem Wort des Jahres . . . . . . . . . . . 25.4 Klassen testen mit doctest. . . . . . . . . . . . . . . . . . . . . . 25.4.1 Wie testet man eine Klasse?. . . . . . . . . . . . . . . . . . . . 25.4.2 Normalisierte Whitespaces – doctest-Direktiven . . . . . . . . . . 25.4.3 Ellipsen verwenden. . . . . . . . . . . . . . . . . . . . . . . . . 25.4.4 Dictionaries testen . . . . . . . . . . . . . . . . . . . . . . . . 25.5 Gestaltung von Testreihen mit unittest. . . . . . . . . . . . . . . . 25.5.1 Einführendes Beispiel mit einem Testfall . . . . . . . . . . . . . 25.5.2 Klassen des Moduls unittest . . . . . . . . . . . . . . . . . . . . 25.5.3 Weiterführendes Beispiel . . . . . . . . . . . . . . . . . . . . . 25.6 Tuning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25.6.1 Performance-Analyse mit dem Profiler . . . . . . . . . . . . . . . 25.6.2 Praxisbeispiel: Auswertung astronomischer Fotografien . . . . . . . 25.6.3 Performance-Analyse und Tuning . . . . . . . . . . . . . . . . . . 25.7 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25.8 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 XML und JSON . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26.1 Was ist XML? . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26.2 XML-Dokumente. . . . . . . . . . . . . . . . . . . . . . . . . . . . 26.3 Ein XML-Dokument als Baum . . . . . . . . . . . . . . . . . . . . . . 26.4 DOM. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26.5 Das Modul xml.dom.minidom. . . . . . . . . . . . . . . . . . . . . . 26.5.1 XML-Dokumente und DOM-Objekte . . . . . . . . . . . . . . . . . . . 26.5.2 Die Basisklasse Node . . . . . . . . . . . . . . . . . . . . . . . 26.5.3 Die Klassen Document, Element und Text. . . . . . . . . . . . . . . 26.6 Attribute von XML-Elementen . . . . . . . . . . . . . . . . . . . . . 26.7 Anwendungsbeispiel 1: Eine XML-basierte Klasse . . . . . . . . . . . 26.8 Anwendungsbeispiel 2: Datenkommunikation mit XML . . . . . . . . . . 26.8.1 Überblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26.8.2 Das Client-Programm. . . . . . . . . . . . . . . . . . . . . . . . Inhaltsverzeichnis 17 26.8.3 Das Server-Programm. . . . . . . . . . . . . . . . . . . . . . . . 26.9 JSON . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26.9.1 JSON-Texte decodieren. . . . . . . . . . . . . . . . . . . . . . . 26.9.2 Decodierungsfehler. . . . . . . . . . . . . . . . . . . . . . . . . 26.9.3 Ein Dictionary als JSON-Objekt speichern: Kompakt oder gut lesbar? 26.9.4 Projekt: Verarbeitung von Wetterdaten . . . . . . . . . . . . . . . 26.10 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26.11 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 Modellieren mit Kellern, Schlangen und Graphen . . . . . . . . . . . . 27.1 Stack (Keller, Stapel) . . . . . . . . . . . . . . . . . . . . . . . 27.2 Queue (Schlange). . . . . . . . . . . . . . . . . . . . . . . . . . . 27.3 Graphen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27.4 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27.5 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 Benutzungsoberflächen mit Qt. . . . . . . . . . . . . . . . . . . . . . 28.1 Was bietet PyQT5? . . . . . . . . . . . . . . . . . . . . . . . . . . 28.1.1 PyQt5 erkunden. . . . . . . . . . . . . . . . . . . . . . . . . . . 28.2 Wie arbeitet PyQt? Applikation und Fenster . . . . . . . . . . . . . 28.3 Eine objektorientierte Anwendung mit PyQt5. . . . . . . . . . . . . . 28.4 Ein Webbrowser . . . . . . . . . . . . . . . . . . . . . . . . . . . 28.5 Interaktive Widgets . . . . . . . . . . . . . . . . . . . . . . . . . 28.6 Label – Ausgabe von Text und Bild . . . . . . . . . . . . . . . . . . 28.7 Signale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28.8 Checkboxen und Radiobuttons . . . . . . . . . . . . . . . . . . . . . 28.9 Auswahlliste (ComboBox) . . . . . . . . . . . . . . . . . . . . . . . 28.10 Gemeinsame Operationen der Widgets . . . . . . . . . . . . . . . . . 28.11 Spezielle Methoden eines Fensters . . . . . . . . . . . . . . . . . 28.12 Events . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28.13 Fonts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28.14 Stylesheets . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28.15 Icons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28.16 Messageboxen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28.17 Timer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28.18 Das Qt-Layout unter der Lupe. . . . . . . . . . . . . . . . . . . . 28.18.1 Absolute Positionierung und Größe . . . . . . . . . . . . . . . . 28.18.2 Raster-Layout . . . . . . . . . . . . . . . . . . . . . . . . . . 28.18.3 Form-Layout. . . . . . . . . . . . . . . . . . . . . . . . . . . . 28.19 Browser für jeden Zweck . . . . . . . . . . . . . . . . . . . . . . 28.19.1 Die Klasse QWebEngineView . . . . . . . . . . . . . . . . . . . . 28.20 Ein Webbrowser mit Filter . . . . . . . . . . . . . . . . . . . . . 28.21 Surfen mit Geschichte – der Verlauf einer Sitzung . . . . . . . . . 28.22 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28.23 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Inhaltsverzeichnis 18 29 Multimediaanwendungen mit Qt . . . . . . . . . . . . . . . . . . . . . 29.1 Kalender und Textfeld – ein digitales Tagebuch . . . . . . . . . . . 29.1.1 Programmierung . . . . . . . . . . . . . . . . . . . . . . . . . . 29.2 Kamerabilder . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29.3 Dialoge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29.3.1 Projekt Ansichtskarte . . . . . . . . . . . . . . . . . . . . . . . 29.4 Videoplayer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29.4.1 Ein einfacher Videoplayer . . . . . . . . . . . . . . . . . . . . . 29.4.2 Videoplayer mit Playlist . . . . . . . . . . . . . . . . . . . . . 29.4.3 Regeln zur Änderung der Größe (Size Policy) . . . . . . . . . . . . 29.4.4 Das Dashboard bei Mausbewegungen einblenden . . . . . . . . . . . . 29.5 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29.6 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 Rechnen mit NumPy. . . . . . . . . . . . . . . . . . . . . . . . . . . 30.1 NumPy installieren . . . . . . . . . . . . . . . . . . . . . . . . . 30.2 Arrays erzeugen. . . . . . . . . . . . . . . . . . . . . . . . . . . 30.2.1 Arrays. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30.2.2 Matrizen und Vektoren . . . . . . . . . . . . . . . . . . . . . . . 30.2.3 Zahlenfolgen. . . . . . . . . . . . . . . . . . . . . . . . . . . . 30.2.4 Zufallsarrays . . . . . . . . . . . . . . . . . . . . . . . . . . . 30.2.5 Spezielle Arrays. . . . . . . . . . . . . . . . . . . . . . . . . . 30.3 Indizieren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30.4 Slicing. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30.5 Arrays verändern . . . . . . . . . . . . . . . . . . . . . . . . . . 30.6 Arithmetische Operationen . . . . . . . . . . . . . . . . . . . . . . 30.7 Funktionen, die elementweise ausgeführt werden. . . . . . . . . . . . 30.8 Einfache Visualisierung . . . . . . . . . . . . . . . . . . . . . . . 30.9 Matrizenmultiplikation mit dot() . . . . . . . . . . . . . . . . . . 30.10 Array-Funktionen und Achsen. . . . . . . . . . . . . . . . . . . . . 30.11 Projekt: Diffusion . . . . . . . . . . . . . . . . . . . . . . . . . 30.12 Vergleiche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30.13 Projekt: Wolken am Himmel . . . . . . . . . . . . . . . . . . . . . 30.14 Projekt: Wie versteckt man ein Buch in einem Bild? . . . . . . . . . 30.15 Datenanalyse mit Histogrammen . . . . . . . . . . . . . . . . . . . 30.16 Wie funktioniert ein Medianfilter? . . . . . . . . . . . . . . . . . 30.17 Rechnen mit SciPy . . . . . . . . . . . . . . . . . . . . . . . . . 30.17.1 Lineare Gleichungssysteme lösen . . . . . . . . . . . . . . . . . 30.17.2 Integration. . . . . . . . . . . . . . . . . . . . . . . . . . . . 30.18 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30.19 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 Messdaten verarbeiten . . . . . . . . . . . . . . . . . . . . . . . . . 31.1 Messwerte in einem Diagramm darstellen – Matplotlib und tkinter . . . 31.1.1 Basisprojekt. . . . . . . . . . . . . . . . . . . . . . . . . . . . Inhaltsverzeichnis 19 31.1.2 Erweiterung: Den letzten Wert löschen. . . . . . . . . . . . . . . 31.1.3 Das Aussehen eines Diagramms gestalten . . . . . . . . . . . . . . 31.2 Messwerte aus einem Multimeter lesen und darstellen . . . . . . . . . 31.2.1 Vorbereitung . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.2.2 Werte auslesen . . . . . . . . . . . . . . . . . . . . . . . . . . 31.2.3 Welche Ziffern zeigt das Display des Multimeters? . . . . . . . . . 31.3 Anzeige der Temperatur . . . . . . . . . . . . . . . . . . . . . . . 31.4 Messreihen aufzeichnen . . . . . . . . . . . . . . . . . . . . . . . 31.5 Aufgabe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.6 Lösung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 Parallele Datenverarbeitung . . . . . . . . . . . . . . . . . . . . . . 32.1 Was sind parallele Programme? . . . . . . . . . . . . . . . . . . . . 32.2 Prozesse starten und abbrechen . . . . . . . . . . . . . . . . . . . 32.3 Funktionen in eigenen Prozessen starten . . . . . . . . . . . . . . . 32.4 Prozesse zusammenführen – join() . . . . . . . . . . . . . . . . . . 32.5 Wie können Prozesse Objekte austauschen? . . . . . . . . . . . . . . 32.5.1 Objekte als Argumente übergeben . . . . . . . . . . . . . . . . . . 32.5.2 Objekte über eine Pipe senden und empfangen. . . . . . . . . . . . 32.5.3 Objekte über eine Queue austauschen . . . . . . . . . . . . . . . . 32.6 Daten im Pool bearbeiten . . . . . . . . . . . . . . . . . . . . . . 32.6.1 Mit dem Pool geht’s schneller – ein Zeitexperiment . . . . . . . . 32.6.2 Forschen mit Big Data aus dem Internet . . . . . . . . . . . . . . 32.7 Synchronisation . . . . . . . . . . . . . . . . . . . . . . . . . . . 32.8 Produzenten und Konsumenten . . . . . . . . . . . . . . . . . . . . . 32.8.1 Sprücheklopfer . . . . . . . . . . . . . . . . . . . . . . . . . . 32.9 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32.10 Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 Django. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33.1 Django aus der Vogelperspektive . . . . . . . . . . . . . . . . . . . 33.2 Start eines Projekts . . . . . . . . . . . . . . . . . . . . . . . . 33.2.1 Den Server starten. . . . . . . . . . . . . . . . . . . . . . . . . 33.2.2 Startseite und View einrichten . . . . . . . . . . . . . . . . . . 33.3 Datenbankanbindung . . . . . . . . . . . . . . . . . . . . . . . . . 33.4 Modelle erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . 33.5 Modelle aktivieren . . . . . . . . . . . . . . . . . . . . . . . . . 33.6 In der Python-Shell die Datenbank bearbeiten . . . . . . . . . . . . 33.6.1 Objekte durch Aufruf der Klasse erzeugen . . . . . . . . . . . . . 33.6.2 Auf Attribute eines Objektes zugreifen . . . . . . . . . . . . . . 33.6.3 Objekte finden. . . . . . . . . . . . . . . . . . . . . . . . . . . 33.6.4 Objekte erzeugen und Beziehungen herstellen . . . . . . . . . . . . 33.6.5 Den Beziehungsmanager nutzen. . . . . . . . . . . . . . . . . . . . 33.6.6 Objekte löschen . . . . . . . . . . . . . . . . . . . . . . . . . . 33.7 Django-Modelle unter der Lupe . . . . . . . . . . . . . . . . . . . . Inhaltsverzeichnis 20 33.8 Der Manager unter der Lupe – Objekte erzeugen und suchen . . . . . . 33.9 Administration . . . . . . . . . . . . . . . . . . . . . . . . . . . 33.9.1 Eine Applikation der Website-Verwaltung zugänglich machen . . . .. 33.10 Views einrichten – die Grundstruktur. . . . . . . . . . . . . . . . 33.10.1 Was sind Views? . . . . . . . . . . . . . . . . . . . . . . . . . 33.10.2 Funktionen für Views . . . . . . . . . . . . . . . . . . . . . . . 33.10.3 URL-Patterns . . . . . . . . . . . . . . . . . . . . . . . . . . . 33.11 View-Funktionen erweitern . . . . . . . . . . . . . . . . . . . . . 33.11.1 Startseite . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33.11.2 Auflistung der Ideen zu einer Frage – question_index . . . . . . . 33.11.3 Die Templates verbessern: Namen statt expliziter URLs. . . . . . . 33.12 Interaktive Webseiten – Views mit Formularen . . . . . . . . . . . . 33.12.1 Eingabe einer neuen Frage . . . . . . . . . . . . . . . . . . . . 33.12.2 Eingabe einer neuen Idee . . . . . . . . . . . . . . . . . . . . . 33.12.3 View-Funktion für das Speichern einer neuen Idee . . . . . . . . . 33.12.4 Fertig!. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33.13 Die nächsten Schritte . . . . . . . . . . . . . . . . . . . . . . . 33.14 Aufgabe Suche nach Ideen . . . . . . . . . . . . . . . . . . . . . . 33.15 Lösung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A Anhang. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A.1 Zeichencodierung . . . . . . . . . . . . . . . . . . . . . . . . . . . A.1.1 Codierung von Sonderzeichen in HTML . . . . . . . . . . . . . . . . A.2 Quellen im WWW. . . . . . . . . . . . . . . . . . . . . . . . . . . . A.3 Standardfunktionen und Standardklassen . . . . . . . . . . . . . . . . A.4 Mathematische Funktionen . . . . . . . . . . . . . . . . . . . . . . . A.4.1 Das Modul math . . . . . . . . . . . . . . . . . . . . . . . . . . . A.4.2 Das Modul random. . . . . . . . . . . . . . . . . . . . . . . . . . A.5 EBNF-Grammatik . . . . . . . . . . . . . . . . . . . . . . . . . . . . B Glossar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . C Download der Programmbeispiele. . . . . . . . . . . . . . . . . . . . . D Ein Python-Modul veröffentlichen: PyPI. . . . . . . . . . . . . . . . . D.1 Bei PyPI und TestPyPI registrieren . . . . . . . . . . . . . . . . . . D.2 Ein Paket für die Veröffentlichung vorbereiten . . . . . . . . . . . . D.2.1 Die Programmdatei setup.py . . . . . . . . . . . . . . . . . . . . . D.2.2 Die Lizenz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . D.2.3 Die Datei README.txt . . . . . . . . . . . . . . . . . . . . . . . . D.2.4 Die Datei __init__.py . . . . . . . . . . . . . . . . . . . . . . . D.3 Das Paket auf PyPI veröffentlichen . . . . . . . . . . . . . . . . . . D.3.1 Das Paket aktualisieren . . . . . . . . . . . . . . . . . . . . . . Stichwortverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . © des Titels »Python 3« (ISBN 9783747500514) 2019 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://ww© des Titels »Python 3« (ISBN 9783747500514) 2019 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/0051 |
|||||||||||||||||||
|
Effektiv Python programmieren 90 Wege für bessere Python-Programme
Verlag – mitp Verlag
Author – Brett Slatkin
2. Auflage, 2020
504 Seiten
Preise:
E-Book – 33,99€
Buch – 39,99€
Buch & E-Book – 44,99€
ISBN – 20074750176
Author Der Autor des Buches: Brett Slatkin, starte seine Karriere bei Google und hat dort schon über 10 Jahre Erfahrungen mit Python gesammelt. Das Buch befasst sich intensiv mit der Erstellung von "sauberem" Python Code. Dieses Buch wendet sich dabei zwar vor allem an die fortgeschritteneren Anwender der jetzt schon seit Jahren sehr beliebten Interpreter-Programmiersprache Python, ist aber auch schon von Beginnern mit einzusetzen. Siehe dazu auch meine Hinweise unter: Weigend, 'Python 3' (8. Aufl.) So beginnt Slatkin das Buch im 1. Kapitel mit dem sogenannten "Python Style Guide" (auch PEP8 genannt). Sich daran von Anfang an zu halten, ist eine prima Idee, weil man so beim Programmieren immer auf der richtigen Seite ist: wenn zum Beispiel mehrere Leute an einem Projekt arbeiten und die Scripte ausgetauscht werden sollen ... Slatkin bezieht sich in allen Scripten stets auf die Python-Version 3.8. Dies erleichtert ebenfalls das Nachvollziehen des erstellten Codes. Die 10 Kapitel sind: Pythons Sicht der Dinge (mit: PEP8), Listen und Dictionaries, Funktionen, Listen-Abstraktionen und Generatoren, Klassen und Schnittstellen, Metaklassen und Attribute, Nebenläufigkeiten und parallele Ausführung, Robustheit und Performance, Testen und Debuggen, Zusammenarbeit Wer sich vorab noch ein wenig genauer über dieses Buch informieren will, kann unter der Web-Adresse: https://www.mitp.de/out/media/9783747501764_Leseprobe.pdf sich das ganze 1. Kapitel durchlesen und so vielleicht noch besser eine Kaufentscheidung treffen. Auf der WebSite: http://www.effectivepython.com kann man sogar als Ergänzung zum Buch die kompletten Codes aus diesem Buch kostenlos herunterladen! Das erspart so manchen Tippfehler. Alles in Allem ist dies ein Buchtitel, der aus der Masse heraussticht, weil er die Probleme, die in dieser sehr sehr umfangreichen Programmiersprache auftauchen können (und es bei umfassender Anwendung auch werden!) beim Namen nennt. Und zwar so, dass nicht nur eine Lösung für das Problem geliefert wird, sondern auch die Zusammenhänge der Problematiken beschrieben werden ... |
|||||||||||||||||||
|
Python lernen mit KI-Tools Einstieg in die Programmierung mit KI-Unterstützung
Verlag – O'Reilly:
angeboten über mitp
Author – Allen B. Downey
1. Auflage, 2025
375 Seiten
Preise:
E-Book – 29,90€
Buch – 29,90€
Buch & E-Book – €
ISBN – 978-3-96009-259-9
Author Der Autor des Buches: Allen B. Downey (* 11.Mai 1967 in New York City) ist ein US-amerikanischer Informatiker. Er hat umfangreiche Erfahrungen im universitären Umfeld gesammelt. So hat er 1989 seinen Bachelor of Science (MIT) und 1990 seinen Master in Bauingenieurwesen (MIT) erhalten. 1995 begann er als Research Fellow am San Diego Supercomputer Center. 1997 erlangte er seinen Ph.D. (Philosophical Doctorate / ähnlich dem dt. Doktortitel) in Informatik von der University of California in Berkeley. 1997 wurde er Assistenzprofessor für Informatik am Colby College. 2000 war er Assistenzprofessor für Informatik am Wellesley College. 2002 war er Research Fellow an der Boston University. Seit 2003 ist Allen Downey Professor für Informatik am Franklin W. Olin College of Engineering. 2009-2010 war er auch noch Gastwissenschaftler bei der Google Inc. Er arbeitet jetzt als Principal Data Scientist bei den PyMC Labs. Dieses Buch ist eines der ersten, das sich mit dem Erlernen der Programmiersprache Python unter Einbeziehung von KI-Assistenten (ChatGPT, Copilot, Colab, GitHub) befasst. Es basiert vor allem auf der Erstellung und Bearbeitung von Beispielen, so dass das Geschehen immer sehr schön anschaulich ist. * Sehr interessant fanden wir hier auch die Tipps für Lehrkräfte auf S. 17. So finden sich dort ein paar sehr nützliche Hinweise und "weiterführende Ressourcen" per Links. Dass sind: die Lösungen zu den Übungen, Rätsel zu jedem Kapitel, ein Abschluss-Quiz zu den Themen des ganzen Buches, dann noch ein ganzes Online-Buch "Teaching und Learning with Yupiter". Der Autor ist davon überzeugt, dass KI-Assistenten sich als ein prima Mittel nutzen lassen, um Python schneller und effektiver zu lernen! |
|||||||||||||||||||
|
|
|||||||||||||||||||
siehe auch: