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

Lernen und professionell anwenden

  • Klassen, Objekte und Vererbung praktisch angewendet

  • Datenbanken, grafische Benutzungsoberflächen und Internet-Programmierung

  • Übungen mit Musterlösungen zu jedem Kapitel

Die Skriptsprache Python mit ihrer einfachen Syntax ist hervorragend geeignet, um modernes Programmieren zu lernen. Mit diesem Buch erhalten Sie einen umfassenden Einblick in Python 3.

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.3) und zusätzlich auch weiterführende Themen wie die Gestaltung grafischer Benutzungsoberflächen, Threads, CGI- und Internetprogrammierung, automatisiertes Testen, Datenmodellierung mit XML und Datenbanken.

Der Autor wendet sich sowohl an ambitionierte 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.

Table of Contents

  1. Cover
  2. Titel
  3. Impressum
  4. Inhaltsverzeichnis (1/4)
  5. Inhaltsverzeichnis (2/4)
  6. Inhaltsverzeichnis (3/4)
  7. Inhaltsverzeichnis (4/4)
  8. Einleitung
    1. Warum Python?
    2. Python 3
    3. An wen wendet sich dieses Buch?
    4. Inhalt und Aufbau
    5. Hinweise zur Typographie
    6. Programmbeispiele
  9. Kapitel 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
  10. Kapitel 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
  11. Kapitel 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
  12. Kapitel 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
  13. Kapitel 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
  14. Kapitel 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
  15. Kapitel 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
  16. Kapitel 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
  17. Kapitel 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 (1/2)
    9. 9.8 Lösungen (2/2)
  18. Kapitel 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 (1/2)
    13. 10.12 Lösungen (2/2)
  19. Kapitel 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
  20. Kapitel 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
  21. Kapitel 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
    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 (1/2)
    9. 13.8 Lösungen (2/2)
  22. Kapitel 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
  23. Kapitel 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 (1/2)
    16. 15.15 Lösungen (2/2)
  24. Kapitel 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 (1/3)
    7. 16.6 Lösungen (2/3)
    8. 16.6 Lösungen (3/3)
  25. Kapitel 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
  26. Kapitel 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 (1/2)
    8. 18.7 Lösungen (2/2)
  27. Kapitel 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
  28. Kapitel 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
  29. Kapitel 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
  30. Kapitel 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 (1/2)
    8. 22.7 Objektorientierte CGI-Skripte – Beispiel: ein Chatroom (2/2)
    9. 22.8 CGI-Skripte mit Cookies
    10. 22.9 Aufgaben
    11. 22.10 Lösungen (1/2)
    12. 22.10 Lösungen (2/2)
  31. Kapitel 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 (1/2)
    7. 23.6 Lösungen (2/2)
  32. Kapitel 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) (1/2)
      5. 24.6.4 Implementierung des Redaktionssystems mit Python (OOP) (2/2)
    7. 24.7 Aufgaben
    8. 24.8 Lösungen
  33. Kapitel 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 (1/2)
    4. 25.3 Praxisbeispiel: Suche nach dem Wort des Jahres (2/2)
    5. 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
    6. 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
    7. 25.6 Tuning
      1. 25.6.1 Performance-Analyse mit dem Profiler
      2. 25.6.2 Praxisbeispiel: Auswertung astronomischer Fotografien (1/2)
      3. 25.6.2 Praxisbeispiel: Auswertung astronomischer Fotografien (2/2)
      4. 25.6.3 Performance-Analyse und Tuning
    8. 25.7 Aufgaben
    9. 25.8 Lösungen (1/2)
    10. 25.8 Lösungen (2/2)
  34. Kapitel 26: XML
    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 Aufgaben
    10. 26.10 Lösungen
  35. Kapitel 27: Modellieren mit Kellern, Schlangen und Graphen
    1. 27.1 Stack (Keller, Stapel)
    2. 27.2 Queue (Schlange)
    3. 27.3 Graphen (1/2)
    4. 27.3 Graphen (2/2)
    5. 27.4 Aufgaben
    6. 27.5 Lösungen
  36. Kapitel 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 QWebView
    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 (1/2)
    24. 28.23 Lösungen (2/2)
  37. Kapitel 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 (1/2)
    7. 29.6 Lösungen (2/2)
  38. Kapitel 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
  39. Kapitel 31: Messdaten verarbeiten
    1. 31.1 Messwerte aus einem Multimeter lesen und darstellen
      1. 31.1.1 Vorbereitung
      2. 31.1.2 Werte auslesen
      3. 31.1.3 Welche Ziffern zeigt das Display des Multimeters?
    2. 31.2 Anzeige der Temperatur
    3. 31.3 Messreihen aufzeichnen
    4. 31.4 Aufgabe
    5. 31.5 Lösung
  40. Kapitel 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
  41. Anhang 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
  42. Anhang B: Glossar (1/3)
  43. Anhang B: Glossar (2/3)
  44. Anhang B: Glossar (3/3)
    1. D.1 Bei PyPI und TextPyPI 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
  45. Stichwortverzeichnis (1/4)
  46. Stichwortverzeichnis (2/4)
  47. Stichwortverzeichnis (3/4)
  48. Stichwortverzeichnis (4/4)