Python 3

Lernen und professionell anwenden. Das umfassende Praxisbuch

Michael Weigend

Diese Publikation zitieren

Michael Weigend, Python 3 (2022), mitp-Verlag, Frechen, ISBN: 9783747505458

5123
Accesses
11
Quotes

Beschreibung

Michael Weigend hat an der Universität Potsdam in Informatik promoviert. Er war für mehr als 30 Jahre als Lehrer tätig und hat 20 Jahre lang an der FernUniversität Hagen Seminare zur Didaktik der Informatik gegeben. An der Universität Münster hält er im Rahmen eines Lehrauftrags Vorlesungen zur Python-Programmierung. Michael Weigend engagiert sich in mehreren nationalen und internationalen Communities für den Computer-Einsatz in der Bildung, darunter Constructionism, International Federation for Information Processing (TC 3 Computers in Education) , Bebras – International Contest on Informatics and Computational Thinking. Er hat über 60 wissenschaftliche Artikel veröffentlicht und mehrere Bücher zu den Themen Programmierung, Web Development und visuelle Modellierung geschrieben.

Beschreibung / Abstract




  • Einführung in alle Sprachgrundlagen: Klassen, Objekte, Vererbung, Kollektionen, Dictionaries


  • Benutzungsoberflächen und Multimediaanwendungen mit PyQt, Datenbanken, XML, Internet-Programmierung mit CGI, WSGI und Django


  • 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 dahinterstehenden 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.


Der Autor wendet sich sowohl an Einsteiger als auch an Leser, die bereits mit einer höheren Programmiersprache vertraut sind.



Aus dem Inhalt:

  • Datentypen, Kontroll-strukturen, 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

  • Datenmodellierung, Datenbanken, XML und JSON

  • Grafische Benutzungsoberflächen mit tkinter und PyQt

  • Threads und Events, Bildverarbeitung mit PIL

  • Systemfunktionen, Testen und Performance-Analyse

  • CGI, WSGI und Rapid Web-Development mit Django

  • Wissenschaftliche Projekte mit NumPy

  • Datenvisualisierung mit Matplotlib und Messwerterfassung

  • Parallele Programmierung: Pipes, Queues, Pools


Inhaltsverzeichnis

  • Cover
  • Titel
  • Impressum
  • Inhalt
  • Einleitung
  • Kapitel 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.8 Hintergrund: Geschichte der objektorientierten Programmierung
  • 1.9 Aufgaben
  • 1.10 Lösungen
  • Kapitel 2: Der Einstieg – Python im interaktiven Modus
  • 2.1 Python installieren
  • 2.2 Python im interaktiven Modus
  • 2.3 Objekte
  • 2.4 Namen
  • 2.5 Hintergrund: Syntax-Regeln für Bezeichner
  • 2.6 Schlüsselwörter
  • 2.7 Anweisungen
  • 2.8 Aufgaben
  • 2.9 Lösungen
  • Kapitel 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
  • Kapitel 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.11 Mengen
  • 4.12 Dictionaries
  • 4.13 Typumwandlungen
  • 4.14 Aufgaben
  • 4.15 Lösungen
  • Kapitel 5: Kontrollstrukturen
  • 5.1 Einfache Bedingungen
  • 5.2 Zusammengesetzte Bedingungen – logische Operatoren
  • 5.3 Programmverzweigungen (bedingte Anweisungen)
  • 5.4 Bedingte Wiederholung (while)
  • 5.5 Iteration über eine Kollektion (for)
  • 5.6 Abbruch einer Schleife mit break
  • 5.7 Abfangen von Ausnahmen mit try
  • 5.8 Aufgaben
  • 5.9 Lösungen
  • Kapitel 6: Funktionen
  • 6.1 Aufruf von Funktionen
  • 6.2 Definition von Funktionen
  • 6.3 Schrittweise Verfeinerung
  • 6.4 Ausführung von Funktionen
  • 6.5 Voreingestellte Parameterwerte
  • 6.6 Funktionen mit beliebiger Anzahl von Parametern
  • 6.7 Lokale Funktionen
  • 6.8 Rekursive Funktionen
  • 6.9 Experimente zur Rekursion mit der Turtle-Grafik
  • 6.10 Rekursive Zahlenfunktionen
  • 6.11 Hintergrund: Wie werden rekursive Funktionen ausgeführt?
  • 6.12 Funktionen als Objekte
  • 6.13 Lambda-Formen
  • 6.14 Funktionsannotationen: Typen zuordnen
  • 6.15 Hinweise zum Programmierstil
  • 6.16 Aufgaben
  • 6.17 Lösungen
  • Kapitel 7: Sequenzen, Mengen und Generatoren
  • 7.1 Gemeinsame Operationen für Sequenzen
  • 7.2 Vertiefung: Rekursive Funktionen für Sequenzen
  • 7.3 Tupel
  • 7.4 Listen
  • 7.5 Generatoren
  • 7.6 Mengen
  • 7.7 Aufgaben
  • 7.8 Lösungen
  • Kapitel 8: Dictionaries
  • 8.1 Operationen für Dictionaries
  • 8.2 Wie erstellt man ein Dictionary?
  • 8.3 Zugriff auf Daten in einem Dictionary
  • 8.4 Praxisbeispiel: Vokabeltrainer
  • 8.5 Typische Fehler
  • 8.6 Aufgaben
  • 8.7 Lösungen
  • Kapitel 9: Ein- und Ausgabe
  • 9.1 Streams
  • 9.2 Mehr Zuverlässigkeit durch try- und with-Anweisungen
  • 9.3 Objekte speichern mit pickle
  • 9.4 Die Streams sys.stdin und sys.stdout
  • 9.5 Ausgabe von Werten mit der print()-Funktion
  • 9.6 Kommandozeilen-Argumente (Optionen)
  • 9.7 Aufgaben
  • 9.8 Lösungen
  • Kapitel 10: Definition eigener Klassen
  • 10.1 Klassen und Objekte
  • 10.2 Definition von Klassen
  • 10.3 Objekte (Instanzen)
  • 10.4 Zugriff auf Attribute – Sichtbarkeit
  • 10.5 Methoden
  • 10.6 Abstraktion, Verkapselung und Geheimnisprinzip
  • 10.7 Vererbung
  • 10.8 Hinweise zum Programmierstil
  • 10.9 Typische Fehler
  • 10.10 Aufgaben
  • 10.11 Lösungen
  • Kapitel 11: Klassen wiederverwenden – Module
  • 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
  • Kapitel 12: Objektorientiertes Modellieren
  • 12.1 Phasen einer objektorientierten Software-Entwicklung
  • 12.2 Beispiel: Modell eines Wörterbuchs
  • 12.3 Assoziationen zwischen Klassen
  • 12.4 Beispiel: Management eines Musicals
  • 12.5 Aufgaben
  • 12.6 Lösungen
  • Kapitel 13: Textverarbeitung
  • 13.1 Standardmethoden zur Verarbeitung von Zeichenketten
  • 13.2 Codierung und Decodierung
  • 13.3 Automatische Textproduktion
  • 13.4 Analyse von Texten
  • 13.5 Reguläre Ausdrücke
  • 13.6 Den Computer zum Sprechen bringen – Sprachsynthese
  • 13.7 Aufgaben
  • 13.8 Lösungen
  • Kapitel 14: Systemfunktionen
  • 14.1 Das Modul sys – die Schnittstelle zum Laufzeitsystem
  • 14.2 Das Modul os – die Schnittstelle zum Betriebssystem
  • 14.3 Datum und Zeit
  • 14.4 Zeitberechnungen mit dem Modul datetime
  • 14.5 Aufgaben
  • 14.6 Lösungen
  • Kapitel 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.5 Gemeinsame Methoden der Widgets
  • 15.6 Die Klasse Tk
  • 15.7 Die Klasse Button
  • 15.8 Die Klasse Label
  • 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
  • Kapitel 16: Layout
  • 16.1 Der Packer
  • 16.2 Layout-Fehler
  • 16.3 Raster-Layout
  • 16.4 Vorgehensweise bei der GUI-Entwicklung
  • 16.5 Aufgaben
  • 16.6 Lösungen
  • Kapitel 17: Grafik
  • 17.1 Die tkinter-Klasse Canvas
  • 17.2 Die Klasse PhotoImage
  • 17.3 Bilder in eine Benutzungsoberfläche einbinden
  • 17.4 Die Python Imaging Library (PIL)
  • 17.5 Aufgaben
  • 17.6 Lösungen
  • Kapitel 18: Event-Verarbeitung
  • 18.1 Einführendes Beispiel
  • 18.2 Event-Sequenzen
  • 18.3 Beispiel: Tastaturereignisse verarbeiten
  • 18.4 Programmierung eines Eventhandlers
  • 18.5 Bindemethoden
  • 18.6 Aufgaben
  • 18.7 Lösungen
  • Kapitel 19: Komplexe Benutzungsoberflächen
  • 19.1 Text-Widgets
  • 19.2 Rollbalken (Scrollbars)
  • 19.3 Menüs
  • 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
  • Kapitel 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
  • Kapitel 21: Fehler finden und vermeiden
  • 21.1 Testen von Bedingungen
  • 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.6 Vertiefung: Professionelles Arbeiten mit Logging
  • 21.7 Debugging
  • Kapitel 22: Dynamische Webseiten – CGI und WSGI
  • 22.1 Wie funktionieren dynamische Webseiten?
  • 22.2 Wie spät ist es? Aufbau eines CGI-Skripts
  • 22.3 Kommunikation über interaktive Webseiten
  • 22.4 Verarbeitung von Eingabedaten mit FieldStorage
  • 22.5 Sonderzeichen handhaben
  • 22.6 CGI-Skripte debuggen
  • 22.7 Der Apache-Webserver
  • 22.8 Dynamische Webseiten mit WSGI
  • 22.9 mod_wsgi
  • 22.10 Verarbeitung von Eingabedaten aus Formularen
  • 22.11 Objektorientierte WSGI-Skripte – Beispiel: ein Chatroom
  • 22.12 WSGI-Skripte mit Cookies
  • Kapitel 23: Internet-Programmierung
  • 23.1 Was ist ein Protokoll?
  • 23.2 Übertragung von Dateien mit FTP
  • 23.3 Zugriff auf Webseiten mit HTTP und HTTPS
  • 23.4 Zugriff auf Ressourcen im Internet über deren URL
  • 23.5 E-Mails senden mit SMTP
  • 23.6 Aufgaben
  • 23.7 Lösungen
  • Kapitel 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 Mengen oder Dictionaries
  • 24.5 Das Modul sqlite3
  • 24.6 Online-Redaktionssystem mit Datenbankanbindung
  • 24.7 Aufgaben
  • 24.8 Lösungen
  • Kapitel 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.5 Gestaltung von Testreihen mit unittest
  • 25.6 Tuning
  • 25.7 Aufgaben
  • 25.8 Lösungen
  • Kapitel 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.6 Attribute von XML-Elementen
  • 26.7 Anwendungsbeispiel 1: Eine XML-basierte Klasse
  • 26.8 Anwendungsbeispiel 2: Datenkommunikation mit XML
  • 26.9 JSON
  • 26.10 Aufgaben
  • 26.11 Lösungen
  • Kapitel 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
  • Kapitel 28: Benutzungsoberflächen mit Qt
  • 28.1 Was bietet PyQt5?
  • 28.2 PyQt5 erkunden
  • 28.3 Wie arbeitet PyQt? Applikation und Fenster
  • 28.4 Eine objektorientierte Anwendung mit PyQt5
  • 28.5 Ein Webbrowser
  • 28.6 Interaktive Widgets
  • 28.7 Label – Ausgabe von Text und Bild
  • 28.8 Signale
  • 28.9 Checkboxen und Radiobuttons
  • 28.10 Auswahlliste (ComboBox)
  • 28.11 Gemeinsame Operationen der Widgets
  • 28.12 Spezielle Methoden eines Fensters
  • 28.13 Events
  • 28.14 Fonts
  • 28.15 Stylesheets
  • 28.16 Icons
  • 28.17 Messageboxen
  • 28.18 Timer
  • 28.19 Das Qt-Layout unter der Lupe
  • 28.20 Browser für jeden Zweck
  • 28.21 Ein Webbrowser mit Filter
  • 28.22 Surfen mit Geschichte – der Verlauf einer Sitzung
  • 28.23 Aufgaben
  • 28.24 Lösungen
  • Kapitel 29: Multimediaanwendungen mit Qt
  • 29.1 Kalender und Textfeld – ein digitales Tagebuch
  • 29.2 Kamerabilder
  • 29.3 Dialoge
  • 29.4 Videoplayer
  • 29.5 Aufgaben
  • 29.6 Lösungen
  • Kapitel 30: Rechnen mit NumPy
  • 30.1 NumPy installieren
  • 30.2 Arrays erzeugen
  • 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.18 Aufgaben
  • 30.19 Lösungen
  • Kapitel 31: Messdaten verarbeiten
  • 31.1 Messwerte in einem Diagramm darstellen – Matplotlib und tkinter
  • 31.2 Messwerte aus einem Multimeter lesen und darstellen
  • 31.3 Anzeige der Temperatur
  • 31.4 Messreihen aufzeichnen
  • 31.5 Aufgabe
  • 31.6 Lösung
  • Kapitel 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.6 Daten im Pool bearbeiten
  • 32.7 Synchronisation
  • 32.8 Produzenten und Konsumenten
  • 32.9 Aufgaben
  • 32.10 Lösungen
  • Kapitel 33: Django
  • 33.1 Django aus der Vogelperspektive
  • 33.2 Ein Projekt anlegen
  • 33.3 Datenbankanbindung
  • 33.4 Modelle erstellen
  • 33.5 Modelle aktivieren
  • 33.6 In der Python-Shell die Datenbank bearbeiten
  • 33.7 Django-Modelle unter der Lupe
  • 33.8 Der Manager unter der Lupe – Objekte erzeugen und suchen
  • 33.9 Administration
  • 33.10 Views einrichten – die Grundstruktur
  • 33.11 View-Funktionen erweitern
  • 33.12 Interaktive Webseiten – Views mit Formularen
  • 33.13 Die nächsten Schritte
  • 33.14 Aufgabe
  • 33.15 Lösung
  • A Anhang
  • A.1 Codierung von Sonderzeichen in HTML
  • A.2 Quellen im WWW
  • A.3 Standardfunktionen und Standardklassen
  • A.4 Mathematische Funktionen
  • 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.3 Das Paket auf PyPI veröffentlichen
  • Stichwortverzeichnis

Mehr von dieser Serie

    Ähnliche Titel

      Mehr von diesem Autor