O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

Python 3 - Lernen und professionell anwenden

Book Description

  • Einführung in alle Sprachgrundlagen: Klassen, Objekte, Vererbung, Dictionaries
  • Benutzungsoberflächen und Multimediaanwendungen mit PyQt, Datenbanken, XML und Internet-Programmierung
  • Wissenschaftliches Rechnen mit NumPy, parallele Verarbeitung großer Datenmengen, Datenvisualisierung mit Matplotlib
  • Übungen mit Musterlösungen zu jedem Kapitel

Die Skriptsprache Python ist mit ihrer einfachen Syntax hervorragend für Einsteiger geeignet, um modernes Programmieren zu lernen. Mit diesem Buch erhalten Sie einen umfassenden Einstieg in Python 3 und lernen darüber hinaus auch weiterführende Anwendungsmöglichkeiten kennen. Michael Weigend behandelt Python von Grund auf und erläutert die wesentlichen Sprachelemente. Er geht dabei besonders auf die Anwendung von Konzepten der objektorientierten Programmierung ein.

Insgesamt liegt der Schwerpunkt auf der praktischen Arbeit mit Python. Ziel ist es, die wesentlichen Techniken und dahinter stehenden Ideen anhand zahlreicher anschaulicher Beispiele verständlich zu machen. Zu typischen Problemstellungen werden Schritt für Schritt Lösungen erarbeitet. So erlernen Sie praxisorientiert die Programmentwicklung mit Python und die Anwendung von Konzepten der objektorientierten Programmierung.

Alle Kapitel enden mit einfachen und komplexen Übungsaufgaben mit vollständigen Musterlösungen.

Das Buch behandelt die Grundlagen von Python 3 (Version 3.6) und zusätzlich auch weiterführende Themen wie die Gestaltung grafischer Benutzungsoberflächen mit tkinter und PyQt, Threads und Multiprocessing, CGI- und Internet-Programmierung, automatisiertes Testen, Datenmodellierung mit XML und JSON, Datenbanken, Datenvisualisierung mit Matplotlib und wissenschaftliches Rechnen mit NumPy.

Der Autor wendet sich sowohl an Einsteiger als auch an Leser, die bereits mit einer höheren Programmiersprache vertraut sind. Zugleich bietet sich dieses Lehrbuch als Textgrundlage oder nützliche Ergänzung zu Universitätskursen an.

Aus dem Inhalt:
  • Datentypen, Kontrollstrukturen, Funktionen, Generatoren
  • Modellieren mit Sequenzen, Dictionaries und Mengen
  • Klassen, Objekte, Vererbung, Polymorphie
  • Module nutzen und auf PyPI veröffentlichen
  • Zeichenketten und reguläre Ausdrücke
  • Grafische Benutzungsoberflächen mit tkinter und PyQt
  • Threads und Events, Bildverarbeitung mit PIL
  • Systemfunktionen, Testen und Performance-Analyse
  • XML, CGI- und Internet-Programmierung, Datenbanken
  • Wissenschaftliche Projekte mit NumPy
  • Datenvisualisierung mit Matplotlib und Messwerterfassung
  • Parallele Programmierung: Pipes, Queues, Pools

Table of Contents

  1. Umschlag
  2. Titel
  3. Impressum
  4. Inhaltsverzeichnis
  5. Einleitung
    1. Warum Python?
    2. Python 3
    3. An wen wendet sich dieses Buch?
    4. Inhalt und Aufbau
    5. Hinweise zur Typographie
    6. Programmbeispiele
  6. 1 Grundlagen
    1. 1.1 Was ist Programmieren?
    2. 1.2 Hardware und Software
    3. 1.3 Programm als Algorithmus
    4. 1.4 Syntax und Semantik
    5. 1.5 Interpreter und Compiler
    6. 1.6 Programmierparadigmen
    7. 1.7 Objektorientierte Programmierung
      1. 1.7.1 Strukturelle Zerlegung
      2. 1.7.2 Die Welt als System von Objekten
      3. 1.7.3 Objekte besitzen Attribute und beherrschen Methoden
      4. 1.7.4 Objekte sind Instanzen von Klassen
    8. 1.8 Hintergrund: Geschichte der objektorientierten Programmierung
    9. 1.9 Aufgaben
    10. 1.10 Lösungen
  7. 2 Der Einstieg – Python im interaktiven Modus
    1. 2.1 Python installieren
    2. 2.2 Python im interaktiven Modus
      1. 2.2.1 Start des Python-Interpreters in einem Konsolenfenster
      2. 2.2.2 Die Python-Shell von IDLE
      3. 2.2.3 Die ersten Python-Befehle ausprobieren
      4. 2.2.4 Hotkeys
    3. 2.3 Objekte
    4. 2.4 Namen
    5. 2.5 Hintergrund: Syntax-Regeln für Bezeichner
    6. 2.6 Schlüsselwörter
    7. 2.7 Anweisungen
      1. 2.7.1 Ausdruckanweisungen
      2. 2.7.2 Import-Anweisungen
      3. 2.7.3 Zuweisungen
      4. 2.7.4 Erweiterte Zuweisungen
      5. 2.7.5 Hintergrund: Dynamische Typisierung
    8. 2.8 Aufgaben
    9. 2.9 Lösungen
  8. 3 Python-Skripte
    1. 3.1 Skripte editieren und ausführen mit IDLE
    2. 3.2 Ausführen eines Python-Skripts
    3. 3.3 Kommentare
    4. 3.4 Die Zeilenstruktur von Python-Programmen
    5. 3.5 Das EVA-Prinzip
    6. 3.6 Phasen der Programmentwicklung
    7. 3.7 Guter Programmierstil
    8. 3.8 Hintergrund: Die Kunst des Fehlerfindens
    9. 3.9 Aufgaben
    10. 3.10 Lösungen
  9. 4 Standard-Datentypen
    1. 4.1 Daten als Objekte
    2. 4.2 Fundamentale Datentypen im Überblick
    3. 4.3 Typen und Klassen
    4. 4.4 NoneType
    5. 4.5 Wahrheitswerte – der Datentyp bool
    6. 4.6 Ganze Zahlen
    7. 4.7 Gleitkommazahlen
    8. 4.8 Komplexe Zahlen
    9. 4.9 Arithmetische Operatoren für Zahlen
    10. 4.10 Sequenzen
      1. 4.10.1 Zeichenketten (Strings)
      2. 4.10.2 Bytestrings
      3. 4.10.3 Tupel
      4. 4.10.4 Liste
      5. 4.10.5 Bytearray
      6. 4.10.6 Einige Grundoperationen für Sequenzen
      7. 4.10.7 Veränderbare und unveränderbare Sequenzen
    11. 4.11 Mengen
    12. 4.12 Dictionaries
    13. 4.13 Typumwandlungen
      1. 4.13.1 int()
      2. 4.13.2 float()
      3. 4.13.3 complex()
      4. 4.13.4 bool()
      5. 4.13.5 str()
      6. 4.13.6 dict(), list() und tuple()
    14. 4.14 Aufgaben
    15. 4.15 Lösungen
  10. 5 Kontrollstrukturen
    1. 5.1 Einfache Bedingungen
      1. 5.1.1 Vergleiche
      2. 5.1.2 Zugehörigkeit zu einer Menge (in, not in)
      3. 5.1.3 Beliebige Ausdrücke als Bedingungen
    2. 5.2 Zusammengesetzte Bedingungen – logische Operatoren
      1. 5.2.1 Negation (not)
      2. 5.2.2 Konjunktion (and)
      3. 5.2.3 Disjunktion (or)
      4. 5.2.4 Formalisierung von Bedingungen
      5. 5.2.5 Hinweis zum Programmierstil
    3. 5.3 Programmverzweigungen (bedingte Anweisungen)
      1. 5.3.1 Einseitige Verzweigung (if)
      2. 5.3.2 Zweiseitige Verzweigung (if-else)
      3. 5.3.3 Mehrfache Fallunterscheidung (elif)
      4. 5.3.4 Bedingte Ausdrücke
    4. 5.4 Bedingte Wiederholung (while)
      1. 5.4.1 Endlosschleifen
    5. 5.5 Iteration über eine Kollektion (for)
      1. 5.5.1 Zählschleifen – Verwendung von range()
      2. 5.5.2 Verschachtelte Iterationen
      3. 5.5.3 Vertiefung: Iterative Berechnung rekursiver Folgen
    6. 5.6 Abbruch einer Schleife mit break
      1. 5.6.1 Abbruch eines Schleifendurchlaufs mit continue
    7. 5.7 Abfangen von Ausnahmen mit try
      1. 5.7.1 try...except
    8. 5.8 Aufgaben
    9. 5.9 Lösungen
  11. 6 Funktionen
    1. 6.1 Aufruf von Funktionen
    2. 6.2 Definition von Funktionen
    3. 6.3 Schrittweise Verfeinerung
    4. 6.4 Ausführung von Funktionen
      1. 6.4.1 Globale und lokale Namen
      2. 6.4.2 Seiteneffekte – die global-Anweisung
      3. 6.4.3 Parameterübergabe
    5. 6.5 Voreingestellte Parameterwerte
      1. 6.5.1 Schlüsselwort-Argumente
    6. 6.6 Funktionen mit beliebiger Anzahl von Parametern
    7. 6.7 Lokale Funktionen
    8. 6.8 Rekursive Funktionen
    9. 6.9 Experimente zur Rekursion mit der Turtle-Grafik
      1. 6.9.1 Turtle-Befehle im interaktiven Modus
      2. 6.9.2 Eine rekursive Spirale
      3. 6.9.3 Baumstrukturen
      4. 6.9.4 Künstlicher Blumenkohl – selbstähnliche Bilder
    10. 6.10 Rekursive Zahlenfunktionen
    11. 6.11 Hintergrund: Wie werden rekursive Funktionen ausgeführt?
      1. 6.11.1 Execution Frames
      2. 6.11.2 Rekursionstiefe
    12. 6.12 Funktionen als Objekte
      1. 6.12.1 Hintergrund: Typen sind keine Funktionen
    13. 6.13 Lambda-Formen
    14. 6.14 Hinweise zum Programmierstil
      1. 6.14.1 Allgemeines
      2. 6.14.2 Funktionsnamen
      3. 6.14.3 Kommentierte Parameter
      4. 6.14.4 Docstrings
    15. 6.15 Aufgaben
    16. 6.16 Lösungen
  12. 7 Sequenzen, Mengen und Generatoren
    1. 7.1 Gemeinsame Operationen für Sequenzen
      1. 7.1.1 Zugriff auf Elemente einer Sequenz
      2. 7.1.2 Slicing von Sequenzen
      3. 7.1.3 Auspacken (unpacking)
    2. 7.2 Vertiefung: Rekursive Funktionen für Sequenzen
      1. 7.2.1 Rekursives Summieren
      2. 7.2.2 Rekursive Suche
    3. 7.3 Tupel
    4. 7.4 Listen
      1. 7.4.1 Eine Liste erzeugen
      2. 7.4.2 Eine Liste verändern
      3. 7.4.3 Flache und tiefe Kopien
      4. 7.4.4 Listen sortieren
      5. 7.4.5 Binäre Suche in einer sortierten Liste
      6. 7.4.6 Zwei Sortierverfahren im Vergleich
      7. 7.4.7 Modellieren mit Listen – Beispiel: die Charts
    5. 7.5 Generatoren
      1. 7.5.1 Generatorausdrücke
      2. 7.5.2 Generatorfunktionen
      3. 7.5.3 Iteratoren
      4. 7.5.4 Verwendung von Generatoren
    6. 7.6 Mengen
      1. 7.6.1 Operationen für Mengen
      2. 7.6.2 Modellieren mit Mengen – Beispiel: Graphen
    7. 7.7 Aufgaben
    8. 7.8 Lösungen
  13. 8 Dictionaries
    1. 8.1 Operationen für Dictionaries
    2. 8.2 Wie erstellt man ein Dictionary?
      1. 8.2.1 Definition mit einem Dictionary-Display
      2. 8.2.2 Schrittweiser Aufbau eines Dictionarys
      3. 8.2.3 Ein Dictionary aus anderen Dictionaries zusammensetzen – update()
    3. 8.3 Zugriff auf Daten in einem Dictionary
      1. 8.3.1 Vergebliche Zugriffsversuche
    4. 8.4 Praxisbeispiel: Vokabeltrainer
    5. 8.5 Typische Fehler
    6. 8.6 Aufgaben
    7. 8.7 Lösungen
  14. 9 Ein- und Ausgabe
    1. 9.1 Files
      1. 9.1.1 Die Rolle der Files bei E/A-Operationen
      2. 9.1.2 Was ist ein File?
      3. 9.1.3 Ein File-Objekt erzeugen
      4. 9.1.4 Speichern einer Zeichenkette
      5. 9.1.5 Laden einer Zeichenkette aus einer Datei
      6. 9.1.6 Absolute und relative Pfade
      7. 9.1.7 Zwischenspeichern, ohne zu schließen
      8. 9.1.8 Zugriff auf Files (lesen und schreiben)
      9. 9.1.9 Speichern beliebiger Daten auf Files
    2. 9.2 Mehr Zuverlässigkeit durch try- und with-Anweisungen
      1. 9.2.1 try...finally
      2. 9.2.2 With-Anweisungen
    3. 9.3 Objekte speichern mit pickle
      1. 9.3.1 Funktionen zum Speichern und Laden
    4. 9.4 Die Pseudofiles sys.stdin und sys.stdout
    5. 9.5 Ausgabe von Werten mit der print()-Funktion
      1. 9.5.1 Anwendung: Ausgabe von Tabellen
    6. 9.6 Kommandozeilen-Argumente (Optionen)
    7. 9.7 Übungen
    8. 9.8 Lösungen
  15. 10 Definition eigener Klassen
    1. 10.1 Klassen und Objekte
    2. 10.2 Definition von Klassen
    3. 10.3 Objekte (Instanzen)
    4. 10.4 Zugriff auf Attribute – Sichtbarkeit
      1. 10.4.1 Öffentliche Attribute
      2. 10.4.2 Private Attribute
      3. 10.4.3 Properties
      4. 10.4.4 Dynamische Erzeugung von Attributen
    5. 10.5 Methoden
      1. 10.5.1 Polymorphismus – Überladen von Operatoren
    6. 10.6 Statische Methoden
    7. 10.7 Abstraktion, Verkapselung und Geheimnisprinzip
    8. 10.8 Vererbung
      1. 10.8.1 Spezialisierungen
      2. 10.8.2 Beispiel: Die Klasse Konto – eine Spezialisierung der Klasse Geld
      3. 10.8.3 Vertiefung: Standardklassen als Basisklassen
    9. 10.9 Hinweise zum Programmierstil
      1. 10.9.1 Bezeichner
      2. 10.9.2 Sichtbarkeit
      3. 10.9.3 Dokumentation von Klassen
    10. 10.10 Typische Fehler
    11. 10.11 Aufgaben
    12. 10.12 Lösungen
  16. 11 Klassenbibliotheken in Modulen speichern
    1. 11.1 Testen einer Klasse in einem lauffähigen Stand-alone-Skript
    2. 11.2 Module speichern und importieren
    3. 11.3 Den Zugang zu einem Modul sicherstellen
    4. 11.4 Programmierstil: Verwendung und Dokumentation von Modulen
  17. 12 Objektorientiertes Modellieren
    1. 12.1 Phasen einer objektorientierten Software-Entwicklung
    2. 12.2 Fallstudie: Modell eines Wörterbuchs
      1. 12.2.1 OOA: Entwicklung einer Klassenstruktur
      2. 12.2.2 OOD: Entwurf einer Klassenstruktur für eine Implementierung in Python
      3. 12.2.3 OOP: Implementierung der Klassenstruktur
    3. 12.3 Assoziationen zwischen Klassen
      1. 12.3.1 Reflexive Assoziationen
      2. 12.3.2 Aggregation
    4. 12.4 Beispiel: Management eines Musicals
      1. 12.4.1 OOA
      2. 12.4.2 OOD
      3. 12.4.3 OOP
    5. 12.5 Aufgaben
    6. 12.6 Lösungen
  18. 13 Verarbeitung von Zeichenketten
    1. 13.1 Standardmethoden zur Verarbeitung von Zeichenketten
      1. 13.1.1 Formatieren
      2. 13.1.2 Schreibweise
      3. 13.1.3 Tests
      4. 13.1.4 Entfernen und Aufspalten
      5. 13.1.5 Suchen und Ersetzen
    2. 13.2 Codierung und Decodierung
      1. 13.2.1 Platonische Zeichen und Unicode
      2. 13.2.2 Vertiefung: Zeichenketten durch Bytefolgen darstellen
    3. 13.3 Automatische Textproduktion
      1. 13.3.1 Texte mit variablen Teilen – Anwendung der String-Methode format()
      2. 13.3.2 Vertiefung: Eine Tabelle erstellen
      3. 13.3.3 Mahnbriefe
      4. 13.3.4 Textuelle Repräsentation eines Objektes
      5. 13.3.5 F-Strings
    4. 13.4 Analyse von Texten
      1. 13.4.1 Chat Bots
      2. 13.4.2 Textanalyse mit einfachen Vorkommenstests
    5. 13.5 Reguläre Ausdrücke
      1. 13.5.1 Aufbau eines regulären Ausdrucks
      2. 13.5.2 Objekte für reguläre Ausdrücke (RE-Objekte)
      3. 13.5.3 Analyse von Strings mit match() und search()
      4. 13.5.4 Textpassagen extrahieren mit findall()
      5. 13.5.5 Zeichenketten zerlegen mit split()
      6. 13.5.6 Teilstrings ersetzen mit sub()
      7. 13.5.7 Match-Objekte
    6. 13.6 Den Computer zum Sprechen bringen – Sprachsynthese
      1. 13.6.1 Buchstabieren
      2. 13.6.2 Den Klang der Stimme verändern
    7. 13.7 Aufgaben
    8. 13.8 Lösungen
  19. 14 Systemfunktionen
    1. 14.1 Das Modul sys – die Schnittstelle zum Laufzeitsystem
      1. 14.1.1 Informationen über die aktuelle Systemumgebung
      2. 14.1.2 Standardeingabe und -ausgabe
      3. 14.1.3 Die Objektverwaltung beobachten mit getrefcount()
      4. 14.1.4 Ausführung eines Skripts beenden
    2. 14.2 Das Modul os – die Schnittstelle zum Betriebssystem
      1. 14.2.1 Dateien und Verzeichnisse suchen
      2. 14.2.2 Hintergrund: Zugriffsrechte abfragen und ändern (Windows und Unix)
      3. 14.2.3 Dateien und Verzeichnisse anlegen und modifizieren
      4. 14.2.4 Merkmale von Dateien und Verzeichnissen abfragen
      5. 14.2.5 Pfade verarbeiten
      6. 14.2.6 Hintergrund: Umgebungsvariablen
      7. 14.2.7 Systematisches Durchlaufen eines Verzeichnisbaumes
    3. 14.3 Datum und Zeit
      1. 14.3.1 Funktionen des Moduls time
      2. 14.3.2 Sekundenformat
      3. 14.3.3 Zeit-Tupel
      4. 14.3.4 Zeitstrings
      5. 14.3.5 Einen Prozess unterbrechen mit sleep()
    4. 14.4 Aufgaben
    5. 14.5 Lösungen
  20. 15 Grafische Benutzungsoberflächen mit tkinter
    1. 15.1 Ein einführendes Beispiel
    2. 15.2 Einfache Widgets
    3. 15.3 Die Master-Slave-Hierarchie
    4. 15.4 Optionen der Widgets
      1. 15.4.1 Optionen bei der Instanziierung setzen
      2. 15.4.2 Widget-Optionen nachträglich konfigurieren
      3. 15.4.3 Fonts
      4. 15.4.4 Farben
      5. 15.4.5 Rahmen
      6. 15.4.6 Die Größe eines Widgets
      7. 15.4.7 Leerraum um Text
    5. 15.5 Gemeinsame Methoden der Widgets
    6. 15.6 Die Klasse Tk
    7. 15.7 Die Klasse Button
    8. 15.8 Die Klasse Label
      1. 15.8.1 Dynamische Konfiguration der Beschriftung
      2. 15.8.2 Verwendung von Kontrollvariablen
    9. 15.9 Die Klasse Entry
    10. 15.10 Die Klasse Radiobutton
    11. 15.11 Die Klasse Checkbutton
    12. 15.12 Die Klasse Scale
    13. 15.13 Die Klasse Frame
    14. 15.14 Aufgaben
    15. 15.15 Lösungen
  21. 16 Layout
    1. 16.1 Der Packer
    2. 16.2 Layout-Fehler
    3. 16.3 Raster-Layout
    4. 16.4 Vorgehensweise bei der GUI-Entwicklung
      1. 16.4.1 Die Benutzungsoberfläche gestalten
      2. 16.4.2 Funktionalität hinzufügen
    5. 16.5 Aufgaben
    6. 16.6 Lösungen
  22. 17 Grafik
    1. 17.1 Die tkinter-Klasse Canvas
      1. 17.1.1 Generierung grafischer Elemente – ID, Positionierung und Display-Liste
      2. 17.1.2 Grafische Elemente gestalten
      3. 17.1.3 Visualisieren mit Kreisdiagrammen
    2. 17.2 Die Klasse PhotoImage
      1. 17.2.1 Eine Pixelgrafik erzeugen
      2. 17.2.2 Fotos analysieren und verändern
    3. 17.3 Bilder in eine Benutzungsoberfläche einbinden
      1. 17.3.1 Icons auf Schaltflächen
      2. 17.3.2 Hintergrundbilder
      3. 17.3.3 Hintergrund: Das PPM-Format
    4. 17.4 Die Python Imaging Library (PIL)
      1. 17.4.1 Installation eines Moduls mit pip
      2. 17.4.2 Mit PIL beliebige Bilddateien einbinden
      3. 17.4.3 Steganografie – Informationen in Bildern verstecken
    5. 17.5 Aufgaben
    6. 17.6 Lösungen
  23. 18 Event-Verarbeitung
    1. 18.1 Einführendes Beispiel
    2. 18.2 Event-Sequenzen
      1. 18.2.1 Event-Typen
      2. 18.2.2 Qualifizierer für Maus- und Tastatur-Events
      3. 18.2.3 Modifizierer
    3. 18.3 Beispiel: Tastaturereignisse verarbeiten
    4. 18.4 Programmierung eines Eventhandlers
      1. 18.4.1 Beispiel für eine Event-Auswertung
    5. 18.5 Bindemethoden
    6. 18.6 Aufgaben
    7. 18.7 Lösungen
  24. 19 Komplexe Benutzungsoberflächen
    1. 19.1 Text-Widgets
      1. 19.1.1 Methoden der Text-Widgets
    2. 19.2 Rollbalken (Scrollbars)
    3. 19.3 Menüs
      1. 19.3.1 Die Klasse Menu
      2. 19.3.2 Methoden der Klasse Menu
    4. 19.4 Texteditor mit Menüleiste und Pulldown-Menü
    5. 19.5 Dialogboxen
    6. 19.6 Applikationen mit mehreren Fenstern
    7. 19.7 Aufgaben
    8. 19.8 Lösungen
  25. 20 Threads
    1. 20.1 Funktionen in einem Thread ausführen
    2. 20.2 Thread-Objekte erzeugen – die Klasse Thread
    3. 20.3 Aufgaben
    4. 20.4 Lösungen
  26. 21 Fehler finden und vermeiden
    1. 21.1 Testen von Bedingungen
      1. 21.1.1 Ausnahmen (Exceptions)
      2. 21.1.2 Testen von Vor- und Nachbedingungen mit assert
      3. 21.1.3 Vertiefung: Programmabstürze ohne Fehlermeldung
    2. 21.2 Debugging-Modus und optimierter Modus
    3. 21.3 Ausnahmen gezielt auslösen
    4. 21.4 Selbstdokumentation
    5. 21.5 Dokumentation eines Programmlaufs mit Log-Dateien
      1. 21.5.1 Grundfunktionen
      2. 21.5.2 Beispiel: Logging in der GUI-Programmierung
    6. 21.6 Vertiefung: Professionelles Arbeiten mit Logging
      1. 21.6.1 Logging-Levels
      2. 21.6.2 Logger-Objekte
      3. 21.6.3 Das Format der Logging-Meldungen konfigurieren
    7. 21.7 Debugging
    8. 21.8 Aufgabe
    9. 21.9 Lösung
  27. 22 CGI-Programmierung
    1. 22.1 Wie funktionieren CGI-Skripte?
    2. 22.2 Wie spät ist es? Aufbau eines CGI-Skripts
      1. 22.2.1 Ein einfacher HTTP-Server
      2. 22.2.2 Hintergrund: CGI-Skripte auf einem Host im Internet installieren
    3. 22.3 Kommunikation über interaktive Webseiten
      1. 22.3.1 Aufbau eines HTML-Formulars
      2. 22.3.2 Eingabekomponenten in einem HTML-Formular
    4. 22.4 Verarbeitung von Eingabedaten in einem CGI-Skript
    5. 22.5 Sonderzeichen handhaben
    6. 22.6 CGI-Skripte debuggen
    7. 22.7 Objektorientierte CGI-Skripte – Beispiel: ein Chatroom
    8. 22.8 CGI-Skripte mit Cookies
    9. 22.9 Aufgaben
    10. 22.10 Lösungen
  28. 23 Internet-Programmierung
    1. 23.1 Was ist ein Protokoll?
    2. 23.2 Übertragung von Dateien mit FTP
      1. 23.2.1 Das Modul ftplib
      2. 23.2.2 Navigieren und Downloaden
      3. 23.2.3 Ein Suchroboter für FTP-Server
    3. 23.3 Zugriff auf Webseiten mit HTTP
      1. 23.3.1 Automatische Auswertung von Webseiten
    4. 23.4 E-Mails senden mit SMTP
    5. 23.5 Aufgaben
    6. 23.6 Lösungen
  29. 24 Datenbanken
    1. 24.1 Was ist ein Datenbanksystem?
    2. 24.2 Entity-Relationship-Diagramme (ER-Diagramme)
    3. 24.3 Relationale Datenbanken
    4. 24.4 Darstellung von Relationen als Listen oder Dictionaries
    5. 24.5 Das Modul sqlite3
      1. 24.5.1 Eine Tabelle anlegen
      2. 24.5.2 Anfragen an eine Datenbank
      3. 24.5.3 SQL-Anweisungen mit variablen Teilen
      4. 24.5.4 SQL-Injections
    6. 24.6 Online-Redaktionssystem mit Datenbankanbindung
      1. 24.6.1 Objektorientierte Analyse (OOA)
      2. 24.6.2 Objektorientierter Entwurf des Systems (OOD)
      3. 24.6.3 Hintergrund: Authentifizieren mit MD5-Fingerprints
      4. 24.6.4 Implementierung des Redaktionssystems mit Python (OOP)
    7. 24.7 Aufgaben
    8. 24.8 Lösungen
  30. 25 Testen und Tuning
    1. 25.1 Automatisiertes Testen
    2. 25.2 Testen mit Docstrings – das Modul doctest
    3. 25.3 Praxisbeispiel: Suche nach dem Wort des Jahres
    4. 25.4 Klassen testen mit doctest
      1. 25.4.1 Wie testet man eine Klasse?
      2. 25.4.2 Normalisierte Whitespaces – doctest-Direktiven
      3. 25.4.3 Ellipsen verwenden
      4. 25.4.4 Dictionaries testen
    5. 25.5 Gestaltung von Testreihen mit unittest
      1. 25.5.1 Einführendes Beispiel mit einem Testfall
      2. 25.5.2 Klassen des Moduls unittest
      3. 25.5.3 Weiterführendes Beispiel
    6. 25.6 Tuning
      1. 25.6.1 Performance-Analyse mit dem Profiler
      2. 25.6.2 Praxisbeispiel: Auswertung astronomischer Fotografien
      3. 25.6.3 Performance-Analyse und Tuning
    7. 25.7 Aufgaben
    8. 25.8 Lösungen
  31. 26 XML und JSON
    1. 26.1 Was ist XML?
    2. 26.2 XML-Dokumente
    3. 26.3 Ein XML-Dokument als Baum
    4. 26.4 DOM
    5. 26.5 Das Modul xml.dom.minidom
      1. 26.5.1 XML-Dokumente und DOM-Objekte
      2. 26.5.2 Die Basisklasse Node
      3. 26.5.3 Die Klassen Document, Element und Text
    6. 26.6 Attribute von XML-Elementen
    7. 26.7 Anwendungsbeispiel 1: Eine XML-basierte Klasse
    8. 26.8 Anwendungsbeispiel 2: Datenkommunikation mit XML
      1. 26.8.1 Überblick
      2. 26.8.2 Das Client-Programm
      3. 26.8.3 Das Server-Programm
    9. 26.9 JSON
      1. 26.9.1 JSON-Texte decodieren
      2. 26.9.2 Decodierungsfehler
      3. 26.9.3 Ein Dictionary als JSON-Objekt speichern: Kompakt oder gut lesbar?
      4. 26.9.4 Projekt: Verarbeitung von Wetterdaten
    10. 26.10 Aufgaben
    11. 26.11 Lösungen
  32. 27 Modellieren mit Kellern, Schlangen und Graphen
    1. 27.1 Stack (Keller, Stapel)
    2. 27.2 Queue (Schlange)
    3. 27.3 Graphen
    4. 27.4 Aufgaben
    5. 27.5 Lösungen
  33. 28 Benutzungsoberflächen mit Qt
    1. 28.1 Was bietet PyQT5?
      1. 28.1.1 PyQt5 erkunden
    2. 28.2 Wie arbeitet PyQt? Applikation und Fenster
    3. 28.3 Eine objektorientierte Anwendung mit PyQt5
    4. 28.4 Ein Webbrowser
    5. 28.5 Interaktive Widgets
    6. 28.6 Label – Ausgabe von Text und Bild
    7. 28.7 Signale
    8. 28.8 Checkboxen und Radiobuttons
    9. 28.9 Auswahlliste (ComboBox)
    10. 28.10 Gemeinsame Operationen der Widgets
    11. 28.11 Spezielle Methoden eines Fensters
    12. 28.12 Events
    13. 28.13 Fonts
    14. 28.14 Stylesheets
    15. 28.15 Icons
    16. 28.16 Messageboxen
    17. 28.17 Timer
    18. 28.18 Das Qt-Layout unter der Lupe
      1. 28.18.1 Absolute Positionierung und Größe
      2. 28.18.2 Raster-Layout
      3. 28.18.3 Form-Layout
    19. 28.19 Browser für jeden Zweck
      1. 28.19.1 Die Klasse QWebEngineView
    20. 28.20 Ein Webbrowser mit Filter
    21. 28.21 Surfen mit Geschichte – der Verlauf einer Sitzung
    22. 28.22 Aufgaben
    23. 28.23 Lösungen
  34. 29 Multimediaanwendungen mit Qt
    1. 29.1 Kalender und Textfeld – ein digitales Tagebuch
      1. 29.1.1 Programmierung
    2. 29.2 Kamerabilder
    3. 29.3 Dialoge
      1. 29.3.1 Projekt Ansichtskarte
    4. 29.4 Videoplayer
      1. 29.4.1 Ein einfacher Videoplayer
      2. 29.4.2 Videoplayer mit Playlist
      3. 29.4.3 Regeln zur Änderung der Größe (Size Policy)
      4. 29.4.4 Das Dashboard bei Mausbewegungen einblenden
    5. 29.5 Aufgaben
    6. 29.6 Lösungen
  35. 30 Rechnen mit NumPy
    1. 30.1 NumPy installieren
    2. 30.2 Arrays erzeugen
      1. 30.2.1 Arrays
      2. 30.2.2 Matrizen und Vektoren
      3. 30.2.3 Zahlenfolgen
      4. 30.2.4 Zufallsarrays
      5. 30.2.5 Spezielle Arrays
    3. 30.3 Indizieren
    4. 30.4 Slicing
    5. 30.5 Arrays verändern
    6. 30.6 Arithmetische Operationen
    7. 30.7 Funktionen, die elementweise ausgeführt werden
    8. 30.8 Einfache Visualisierung
    9. 30.9 Matrizenmultiplikation mit dot()
    10. 30.10 Array-Funktionen und Achsen
    11. 30.11 Projekt: Diffusion
    12. 30.12 Vergleiche
    13. 30.13 Projekt: Wolken am Himmel
    14. 30.14 Projekt: Wie versteckt man ein Buch in einem Bild?
    15. 30.15 Datenanalyse mit Histogrammen
    16. 30.16 Wie funktioniert ein Medianfilter?
    17. 30.17 Rechnen mit SciPy
      1. 30.17.1 Lineare Gleichungssysteme lösen
      2. 30.17.2 Integration
    18. 30.18 Aufgaben
    19. 30.19 Lösungen
  36. 31 Messdaten verarbeiten
    1. 31.1 Messwerte in einem Diagramm darstellen – Matplotlib und tkinter
      1. 31.1.1 Basisprojekt
      2. 31.1.2 Erweiterung: Den letzten Wert löschen
      3. 31.1.3 Das Aussehen eines Diagramms gestalten
    2. 31.2 Messwerte aus einem Multimeter lesen und darstellen
      1. 31.2.1 Vorbereitung
      2. 31.2.2 Werte auslesen
      3. 31.2.3 Welche Ziffern zeigt das Display des Multimeters?
    3. 31.3 Anzeige der Temperatur
    4. 31.4 Messreihen aufzeichnen
    5. 31.5 Aufgabe
    6. 31.6 Lösung
  37. 32 Parallele Datenverarbeitung
    1. 32.1 Was sind parallele Programme?
    2. 32.2 Prozesse starten und abbrechen
    3. 32.3 Funktionen in eigenen Prozessen starten
    4. 32.4 Prozesse zusammenführen – join()
    5. 32.5 Wie können Prozesse Objekte austauschen?
      1. 32.5.1 Objekte als Argumente übergeben
      2. 32.5.2 Objekte über eine Pipe senden und empfangen
      3. 32.5.3 Objekte über eine Queue austauschen
    6. 32.6 Daten im Pool bearbeiten
      1. 32.6.1 Mit dem Pool geht’s schneller – ein Zeitexperiment
      2. 32.6.2 Forschen mit Big Data aus dem Internet
    7. 32.7 Synchronisation
    8. 32.8 Produzenten und Konsumenten
      1. 32.8.1 Sprücheklopfer
    9. 32.9 Aufgaben
    10. 32.10 Lösungen
  38. A Anhang
    1. A.1 Zeichencodierung
      1. A.1.1 Codierung von Sonderzeichen in HTML
    2. A.2 Quellen im WWW
    3. A.3 Standardfunktionen und Standardklassen
    4. A.4 Mathematische Funktionen
      1. A.4.1 Das Modul math
      2. A.4.2 Das Modul random
  39. B Glossar
  40. C Download der Programmbeispiele
  41. D Ein Python-Modul veröffentlichen: PyPI
    1. D.1 Bei PyPI und TestPyPI registrieren
    2. D.2 Ein Paket für die Veröffentlichung vorbereiten
      1. D.2.1 Die Programmdatei setup.py
      2. D.2.2 Die Lizenz
      3. D.2.3 Die Datei README.txt
      4. D.2.4 Die Datei __init__.py
    3. D.3 Das Paket auf PyPI veröffentlichen
      1. D.3.1 Das Paket aktualisieren