Python 3 Lernen und professionell anwenden. Das umfassende Praxisbuch
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 beh...
| Autor principal: | |
|---|---|
| Formato: | Libro electrónico |
| Idioma: | Alemán |
| Publicado: |
Frechen :
mitp
2022.
|
| Edición: | 1st ed |
| Materias: | |
| Ver en Biblioteca Universitat Ramon Llull: | https://discovery.url.edu/permalink/34CSUC_URL/1im36ta/alma991009701332906719 |
Tabla de Contenidos:
- Intro
- Python 3
- Impressum
- Einleitung
- Warum Python?
- Python 3
- An wen wendet sich dieses Buch?
- Inhalt und Aufbau
- Hinweise zur Typographie
- Programmbeispiele
- 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.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
- Kapitel 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 IDLE-Shell
- 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
- 2.7.5 Hintergrund: Dynamische Typisierung
- 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.10.1 Thonny - eine Entwicklungsumgebung für Python-Einsteiger
- 3.10.2 Python in der Cloud
- 3.10.3 Jupyter Notebook und Google Colab.
- 3.10.4 Entwicklungsumgebungen für Profis
- 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.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()
- 4.14 Aufgaben
- 4.15 Lösungen
- Kapitel 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
- Kapitel 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
- 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
- Kapitel 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
- 7.6.2 Modellieren mit Mengen - Beispiel: Graphen
- 7.7 Aufgaben
- 7.8 Lösungen
- Kapitel 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
- Kapitel 9: Ein- und Ausgabe
- 9.1 Streams
- 9.1.1 Die Rolle der Streams bei E/A-Operationen
- 9.1.2 Was ist ein Stream?
- 9.1.3 Eine Datei öffnen
- 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 Streams (lesen und schreiben)
- 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 Streams 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.6.1 Zugriff auf Optionen
- 9.6.2 Beispiel
- 9.6.3 Skripte mit Optionen testen
- 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.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.6.1 Abstraktion
- 10.6.2 Verkapselung
- 10.6.3 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 Schreibweise
- 10.8.2 Sichtbarkeit
- 10.8.3 Dokumentation von Klassen
- 10.9 Typische Fehler
- 10.9.1 Versehentliches Erzeugen neuer Attribute
- 10.9.2 Verwechseln von Methoden und Attributen
- 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.3.1 Erweitern der Verzeichnisliste sys.path
- 11.3.2 Anwendungsbeispiel: Eine interaktive Testumgebung
- 11.3.3 Kompilieren von Modulen
- 11.4 Programmierstil: Verwendung und Dokumentation von Modulen
- Kapitel 12: Objektorientiertes Modellieren
- 12.1 Phasen einer objektorientierten Software-Entwicklung
- 12.1.1 Objektorientierte Analyse (OOA)
- 12.1.2 Objektorientierter Entwurf (OOD)
- 12.1.3 Objektorientierte Programmierung (OOP)
- 12.2 Beispiel: Modell eines Wörterbuchs
- 12.2.1 OOA: Entwicklung einer Klassenstruktur
- 12.2.2 OOD: Entwurf einer Klassenstruktur zur 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.
- Kapitel 13: Textverarbeitung.
