Heim | Themen | !zurück!


 Rezensionen: 

   Brockhaus, Duden, Meyer, Harenberg, rororo, dtv ...:

Biografien | Flora & Fauna & Mineralien | Fotografie | Geschichte |
Kunst | Lexika | Mathematik | Naturwissenschaften | Religion |
Philosophie | Programmieren | Psychologie | Soziales | Sprache | Wirtschaft



 

Digibib Bücher auf CD/DVD










 Programmieren:   siehe auch: 






mitp
HANSER
Galileo
Computing
mitp
Rheinwerk
Rheinwerk






Buch
Buch
Buch

Buch
Buch Buch


Programmieren: 

'Python 3' (8. Aufl.)
'Einführung in Python 3' (3. Aufl.)
'Einstieg in Python 3' (6. Aufl.)

'Effektiv Python programmieren' (2. Aufl.)
'Linux. Das umfassende Handbuch'
'Mathematische Algorithmen mit Python' ''




 Prof. Michael Weigend
 Bernd Klein
 Thomas Theis

 Brett Slatkin
 Prof. Michael Kofler
 Dr. Veit Steinkamp
 





 (Jan.2019)
 (2018)
 (2019)

 (2020)
 (2021)
 (2022)
 ()
 ()







 -
 -
.:

''
''


 
 


()
()


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



Mathematische Algorithmen mit Python
Aufgaben vom Sieb des Eratosthenes bis zur RSA-Verschlüsselung
Verlag – Rheinwerk
    Author – Dr. Veit Steinkamp
    2022
    512 Seiten
    Preise:
    Buch – € 34,90
    E-Book - € 34,90
    Bundle Buch + E-Book nur € 39,90

    ISBN – 978-3-8362-8574-2


Zum Autor:

Dr. Veit Steinkamp: Studium der Elektrotechnik und Deutsch für das Lehramt. Praxis: an Berufs-Schulen und Fachhochschulen. Unterricht: in E-Technik, Anwendungsentwicklung und Maschinenbautechnik.
Dazu hat er: Lehraufträge in 'Theoretischer Elektrotechnik' und den 'Grundlagen der Elektrotechnik' durchgeführt.

Zum Buch:

Dr. Steinkamp nutzt für alle Beispielaufgaben die Programmiersprache Python. Wohl aus gutem Grund: Die Programmiersprache (die jetzt auch 'schon' 30 Jahre alt ist) hat in den letzten Jahren einen rasanten Aufstieg gemacht. U.a. ist sie wegen ihrer relativ leichten Erlernbarkeit sehr beliebt. Dies drückt sich auch darin aus, dass sie eine riesige Fan-Gemeinde weltweit hat.

Daraus ergibt sich für alle Anwender dieser 'Sprache', dass man fast immer eine Lösung für die eigenen Programmierprobleme findet. Sei es in Form von Code-Schnippseln oder auch der Hilfe im Dialog mit hunderten von Python-Foren weltweit.

Zusätzlich eine großartige Hilfe sind die tausende von Modulen, die auf der ganzen Welt für die Ergänzung der Fähigkeiten von Python - meist für spezielle Unterthemen gedacht - erstellt werden und allen Python-Liebhabern zur Verfügung gestellt werden!

So arbeitet auch Professor Steinkamp mit den Mathematik-Modulen: NumPy, SymPy und Mathplotlib in diesem Buch. Diese umfangreichen Module sorgen halt dafür, dass man nicht beim Programmieren das Rad immer wieder neu erfinden muss, sondern sehr viele Standard-Funktionen quasi frei Haus geliefert bekommt.

Professor Steinkamp führt in diesem Buch zunächst in die grundlegenden Programm- und Datenstrukturen der Programmiersprache Python ein.

Wie Sie weiter unten in der Inhaltsangabe zu diesem Buch lesen können, werden von ihm Lösungen für:

Ausgleichsrechnungen
Differenzial- und Integralrechnung
Differenzialgleichungen
Folgen und Reihen
Fraktale Geometrie
Funktionen
Gleichungssysteme
Statistik

und viele weitere Themen mit dem entsprechenden Programmcode vorgestellt.

Sehr gut finde ich auch die Rubrik Analyse zu jedem Programmbeispiel. Dort gibt Professor Steinkamp nocheinmal wertvolle Hinweise darauf, was wichtige Programmteile machen, wie sie zu verstehen sind.

Außerdem sehe ich es genauso, dass die Einübung einer Programmiersprache und die Sichtbarmachung von Funktionen etc. auch das Verständnis der Mathematik sehr unterstützt.

* Auf Seite 13 im Buch wird auch auf den herunterladbaren Quellcode zu allen im Buch abgebildeten Programm-Codes beim Verlag Rheinwerk hingewiesen. Das erspart so manchen Tippfehler ...

Hier noch das komplette Inhaltsverzeichnis als Kaufentscheidungshilfe:

Inhalt

Materialien zum Buch ........................................... 13

1 Einführung ................................................... 15
1.1 Entwicklungsumgebungen ..................................... 20
1.1.1 IDLE ..................................................... 21
1.1.2 Thonny ................................................... 22
1.2 Die Installation der Module ................................ 23
1.3 Schlüsselwörter von Python ................................. 26
1.4 Maschinengenauigkeit, Rundungsfehler und Stellenauslöschung .28
1.4.1 Maschinengenauigkeit ......................................29
1.4.2 Rundungsfehler ........................................... 30
1.4.3 Stellenauslöschung ....................................... 31
1.5 Algorithmenbegriffe ........................................ 32

2 Datentypen und Datenstrukturen ............................... 35
2.1 Tupel ...................................................... 36
2.1.1 Exkurs: Elementare Datentypen von Python ................. 38
2.1.2 Würfelsimulation ......................................... 41
2.1.3 Vertauschen von Objekten ..................................41
2.2 Sets ....................................................... 43
2.2.1 Mengenlehre .............................................. 44
2.2.2 Vereinigungsmenge ........................................ 44
2.2.3 Schnittmenge ............................................. 44
2.2.4 Differenzmenge ........................................... 45
2.3 Listen ..................................................... 47
2.4 Dictionary ................................................. 52
2.5 Zusammenfassung ............................................ 57
2.6 Aufgaben ................................................... 58

Inhalt  6
3 Programmstrukturen ........................................... 59
3.1 Mathematische Operatoren ................................... 60
3.2 Die lineare Programmstruktur ............................... 61
3.3 Verzweigungsstrukturen ..................................... 64
3.3.1 Einfachauswahl ........................................... 65
3.3.2 Mehrfachauswahl .......................................... 66
3.4 Wiederholstrukturen ........................................ 68
3.4.1 Die while-Schleife ....................................... 68
3.4.2 Die for-Schleife ......................................... 71
3.5 Unterprogrammtechnik mit Funktionen ........................ 79
3.5.1 Eingebaute Funktionen .................................... 80
3.5.2 Selbst erstellte Funktionen .............................. 81
3.5.3 Funktionen ohne Rückgabewert ............................. 82
3.5.4 Funktionen mit einem Rückgabewert ........................ 83
3.5.5 Funktionen mit mehreren Rückgabewerten ................... 84
3.5.6 Rekursion: Eine Funktion ruft sich selbst auf ............ 86
3.6 Laufzeitkomplexität ........................................ 86
3.7 Aufgaben ................................................... 89

4 Python-Erweiterungsmodule NumPy, Matplotlib, SymPy und SciPy . 91
4.1 NumPy ...................................................... 92
4.1.1 Wichtige NumPy-Methoden .................................. 92
4.1.2 Wertetabellen für mathematische Funktionen erstellen ..... 95
4.1.3 Die Datenstruktur von ndarray ............................ 96
4.1.4 Rechnen mit Matrizen ..................................... 96
4.2 Matplotlib ................................................ 100
4.2.1 Einfache 2D-Funktionsplots .............................. 102
4.2.2 Die objektorientierte API ............................... 104
4.3 SymPy ..................................................... 107
4.3.1 Symbolische Operationen mit Matrizen .................... 108
4.3.2 Symbolisches Differenzieren und Integrieren ............. 109

Inhalt  7
4.4 SciPy ..................................................... 110
4.4.1 Nullstellen berechnen ................................... 112
4.4.2 Numerisches Integrieren ................................. 113
4.5 Aufgaben .................................................. 114

5 Zahlen 117
5.1 Natürliche Zahlen ......................................... 121
5.1.1 Teilbarkeit ............................................. 121
5.1.2 Der größte gemeinsame Teiler ............................ 127
5.1.3 Primzahlen .............................................. 132
5.1.4 RSA-Verschlüsselung ..................................... 144
5.2 Rationale Zahlen .......................................... 152
5.3 Irrationale Zahlen ........................................ 155
5.4 Transzendente Zahlen ...................................... 160
5.4.1 Die Kreiszahl p ......................................... 160
5.4.2 Die eulersche Zahl e .................................... 168
5.5 Aufgaben .................................................. 170

6 Gleichungssysteme 171
6.1 Lineare Gleichungssysteme ................................. 171
6.1.1 Lösbarkeit eines linearen Gleichungssystems ............. 172
6.1.2 Der Gauß-Algorithmus .................................... 176
6.1.3 Der Gauß-Jordan-Algorithmus ............................. 182
6.1.4 Lösung mit Determinanten: Die cramersche Regel .......... 186
6.1.5 Lösung mit der Inversen einer Matrix .................... 192
6.1.6 Lösung mit der NumPy-Methode solve() .................... 195
6.1.7 Lösung mit SymPy-Methoden ............................... 196
6.2 Iterative Verfahren ....................................... 201
6.2.1 Das Jacobi-Verfahren .................................... 202
6.2.2 Das Gauß-Seidel-Verfahren ............................... 207
6.2.3 Konvergenzverhalten ..................................... 211

Inhalt   8
6.3 Nichtlineare Gleichungssysteme ............................ 213
6.3.1 Lösung mit SciPy ........................................ 214
6.3.2 Lösung mit SymPy ........................................ 215
6.4 Aufgaben .................................................. 216

7 Folgen 219
7.1 Divergente Folgen ......................................... 219
7.2 Differenzfolgen ........................................... 223
7.3 Konvergente Folgen ........................................ 225
7.4 Rekursive Folgen .......................................... 229
7.5 Geometrische Folgen ....................................... 230
7.6 Der Grenzwert von Folgen .................................. 234
7.6.1 Grenzwertdarstellung im Koordinatensystem................ 235
7.6.2 Symbolische Berechnung des Grenzwertes .................. 237
7.7 Aufgaben .................................................. 238

8 Stetige Funktionen 239
8.1 2D-Funktionsplots ......................................... 240
8.1.1 Elementare Funktionstypen ............................... 240
8.1.2 Parabel ................................................. 243
8.1.3 Exponentialfunktion ..................................... 246
8.1.4 Sinusfunktion ........................................... 247
8.2 3D-Funktionsplots ......................................... 249
8.2.1 Paraboloid .............................................. 249
8.2.2 Ellipsoid ............................................... 252
8.3 Animationen ............................................... 255
8.3.1 2D-Animationen .......................................... 255
8.3.2 3D-Animationen .......................................... 259
8.4 Aufgaben .................................................. 262

Inhalt  9
9 Differenzialrechnung 263
9.1 Der Differenzenquotient ................................... 265
9.1.1 Vorwärts- und Rückwärtsdifferenzenquotient .............. 265
9.1.2 Der zentrale Differenzenquotient ........................ 267
9.2 Optimale Schrittweite ..................................... 269
9.3 Simulation des Grenzwertprozesses ......................... 271
9.4 Tangenten- und Normalengleichung .......................... 274
9.4.1 Tangentengleichung ...................................... 275
9.4.2 Normalengleichung ....................................... 277
9.5 Höhere Ableitungen ........................................ 280
9.6 Berechnung von Nullstellen mit dem Newton-Verfahren ....... 282
9.6.1 Numerische Berechnung einer Nullstelle .................. 283
9.6.2 Numerische Berechnung mehrerer Nullstellen .............. 286
9.7 Kurvendiskussion .......................................... 288
9.7.1 Statische Darstellung von Extremwerten und Wendepunkt ... 289
9.7.2 Kriterien für Extremstellen ............................. 291
9.7.3 Simulation der Tangentensteigung (Polynom 3. Grades) .... 294
9.7.4 Kurvendiskussion mit SciPy .............................. 297
9.7.5 Kurvendiskussion mit SymPy .............................. 301
9.7.6 Umgekehrte Kurvendiskussion ............................. 303
9.8 Aufgaben .................................................. 306

10 Reihen 307
10.1 Divergierende Reihen ..................................... 308
10.1.1 Die Reihe der Quadratzahlen ............................ 308
10.1.2 Harmonische Reihe ...................................... 311
10.2 Konvergente Reihen ....................................... 313
10.2.1 Die eulersche Zahl e ................................... 314
10.2.2 Vergleich von Konvergenzgeschwindigkeiten .............. 317
10.2.3 Konvergenzkriterien .................................... 319
10.3 Geometrische Reihen ...................................... 322

Inhalt  10
10.4 Potenzreihen und die Taylor-Entwicklung .................. 327
10.4.1 Potenzreihen ........................................... 327
10.4.2 Taylor-Entwicklung ..................................... 331
10.5 Aufgaben ................................................. 336

11 Integralrechnung 337
11.1 Die Stammfunktion ........................................ 337
11.2 Flächenberechnung ........................................ 341
11.3 Verfahren der numerischen Integration .................... 344
11.3.1 Rechtecksummen ......................................... 344
11.3.2 Trapezsummen ........................................... 348
11.3.3 Das Simpson-Verfahren .................................. 351
11.3.4 Vergleich der Verfahren ................................ 353
11.3.5 Der Flächeninhalt zwischen zwei Funktionsgraphen ....... 355
11.3.6 Uneigentliches Integral ................................ 358
11.4 Bogenlängen .............................................. 360
11.5 Rotationskörper .......................................... 364
11.6 Zweifachintegrale ........................................ 370
11.6.1 Zweifachintegrale mit konstanten Integrationsgrenzen ... 370
11.6.2 Zweifachintegrale mit variablen Integrationsgrenzen .... 375
11.7 Aufgaben ................................................. 377

12 Differenzialgleichungen 379
12.1 Das eulersche Polygonzug-Verfahren ....................... 380
12.2 Richtungsfelder .......................................... 385
12.3 Differenzialgleichungen 1. Ordnung ....................... 387
12.3.1 Die konstante Wachstumsrate ............................ 387
12.3.2 Die konstante Wachstumsrate mit oberer Wachstumsschranke 390
12.3.3 Die logistische Wachstumsrate .......................... 392
12.4 Nichtlineare Differenzialgleichungen 2. Ordnung .......... 394

Inhalt  11
12.5 DGL-System für ein gekoppeltes Fadenpendel ............... 399
12.6 DGL-System mit zwei Unbekannten .......................... 402
12.7 DGL-System mit drei Unbekannten .......................... 404
12.8 Optimierungen des Euler-Verfahrens ....................... 407
12.8.1 Das Heun-Verfahren ..................................... 407
12.8.2 Das vierstufige Runge-Kutta-Verfahren .................. 408
12.8.3 Vergleich der Verfahren ................................ 408
12.9 Lösung von Differenzialgleichungen mit SymPy ............. 410
12.10 Aufgaben ................................................ 414

13 Ausgleichsrechnungen 415
13.1 Lineare Ausgleichsprobleme ............................... 415
13.1.1 Lösung mit linearen Gleichungssystemen ................. 416
13.1.2 Lösung mit dem Vektoransatz ............................ 422
13.1.3 Lösung mit dem erweiterten Vektoransatz ................ 425
13.1.4 Anwendungsbeispiel: Bremsweg ........................... 428
13.1.5 Anwendungsbeispiel: Planetenbahn ....................... 431
13.2 Nichtlineare Ausgleichsprobleme .......................... 434
13.2.1 Exponentialfunktion .................................... 435
13.2.2 Potenzfunktion ......................................... 437
13.3 Aufgaben ................................................. 439

14 Algorithmen für die Berechnung statistischer Kennzahlen .... 441
14.1 Normalverteilte Zufallszahlen erzeugen ................... 442
14.1.1 Histogramm ............................................. 444
14.1.2 Normalverteilung ....................................... 445
14.2 Lageparameter ............................................ 446
14.2.1 Modus .................................................. 446
14.2.2 Median ..................................................447
14.2.3 Arithmetischer Mittelwert .............................. 452

Inhalt  12
14.2.4 Harmonischer Mittelwert ................................ 453
14.2.5 Geometrischer Mittelwert ............................... 454
14.3 Streuparameter ........................................... 456
14.3.1 Spannweite ............................................. 456
14.3.2 Standardabweichung ..................................... 458
14.4 Strukturparameter ........................................ 460
14.4.1 Schiefe ................................................ 460
14.4.2 Wölbung ................................................ 463
14.5 Aufgaben ................................................. 465

15 Fraktale 467
15.1 Turtle-Grafik ............................................ 468
15.2 Die kochsche Schneeflocke ................................ 471
15.3 Das Sierpinski-Dreieck ................................... 476
15.4 Der Pythagoras-Baum ...................................... 480
15.5 Mandelbrot- und Julia-Mengen ............................. 484
15.5.1 Mandelbrot-Menge ....................................... 484
15.5.2 Julia-Menge ............................................ 490
15.5.3 Farbige Darstellung von Julia-Mengen ................... 493
15.6 Aufgaben ................................................. 496

A Anhang ...................................................... 497
A.1 Wichtige mathematische Begriffe und Sätze ................. 497
A.1.1 Grundlegende Begriffe der Mathematik .................... 497
A.1.2 Wichtige Sätze der Mathematik ........................... 498
A.2 Matplotlib-Eigenschaften .................................. 500
A.3 Literaturverzeichnis ...................................... 502
Index ......................................................... 504













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












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.



LINUX. Das umfassende Handbuch
Rheinwerk-Verlag

    Author – Prof. Michael Kofler
    17. aktualisierte Auflage 2021
    1.452 Seiten
    Preis (D): 49,90 €

    ISBN – 978-3-8362-8442-4

Zum Autor:

Prof. Dr. Michael Kofler hat Telematik an der TU Graz studiert und ist ein sehr erfolgreicher IT-Fachbuchautor.

Seine Haupt-Themengebiete sind: Linux, IT-Sicherheit, die Programmiersprachen: Python, Java und Swift und der Einplatinen-Computer: Raspberry Pi.

Er ist Entwickler, berät Firmen und arbeitet auch als Lehrbeauftragter.

Michael Kofler. LINUX. Das umfassende Handbuch 17., aktualisierte Auflage 2021, 1.452 Seiten:

Natürlich, im Internet findet man (gerade auch auf den englisch-sprachigen Seiten sehr viele Informationen zu Linux). Aber dieses anarchisch-demokratisches Gebilde, das niemanden gehört, hat auch deshalb so seine Tücken. Jeder kennt das: Genau die Antwort, die man sucht ist auch nach stundenlangem Suchen einfach nicht zu finden - egal welche Suchbegriffe man eingibt ... Und die meisten Treffer erzielt man auf Englisch, was auch mitunter dann schwierig ist.

Bei dieser Linux-Bibel von Professor Kofler ist das aber anders: Er geht sehr systematisch vor. Ein Hauptwerkzeug ist dabei das Terminal. Dies garantiert uns, dass die angegebenen Befehlssequenzen auf allen Linux-Distributionen laufen und man nicht immer wieder neu irgendwelche Programme bedienen lernen muss.

Das Buch befasst sich mit: der Installation von Linux, der Anwendung von Linux und reicht bis hin zu Systemkonfiguration und Administration und Serverkonfiguration.

Weitere Themen sind: Text- und Code-Editoren, Virtualisierung und natürlich die System-Sicherheit.

Wer noch tiefer in die "Eingeweide" von Linux herab will, kann natürlich auf einen recht großen Fundus von Büchern zugreifen. Michael Kofler hat ja darauf auch schon reagiert und z.B. eine Linux Kommandoreferenz (die wir hier auch im Einsatz haben!) heraus gegeben, die jetzt (2022) auch schon in der 5. Auflage erschienen ist. Diese Referenz behandelt auch so 'mal eben über 500 Befehle für die Kommandozeilen-Ebene.

Diese Auslagerung belegt auch deutlich, dass die Kofler-Linux-Bibel mit 1.450 Seiten ihre Kapazitätsgrenze
mehr als erreicht hat und dass eine Aufnahme z.B. der Kommandozeilen-Referenz (mit auch noch 'mal
530? Seiten) deutlich zuviel des Guten wäre.

Die Basis der Beschreibungen liefert auch hier die am weitesten verbreitete Linux-Distribution: Ubuntu.

Der Preis (knapp 50 Euro) für die "Linux-Bibel" ist u.M.n. fair und eine wirklich gute Investition
für alle Linux-Nutzer - Beginner wie Fortgeschrittene.



INHALTSVERZEICHNIS der "Linux-Bibel": LINUX. Das umfassende Handbuch, Michael Kofler, 17. Aufl., 2021:

0019 Vorwort

0021 Konzeption

0023 TEIL I Installation

0025 1 Was ist Linux?

0037 2 Installationsgrundlagen

0071 3 Installationsanleitungen

0115 TEIL II Linux anwenden

0117 4 Gnome

0163 5 KDE
* Gnome und KDE sind Desktop-Varianten (wispor.de)

0179 6 Desktop-Apps und Tools

0241 7 Raspberry Pi
* Der Raspberry Pi ist ein Einplatinen-Computer im Scheckkartenformat,
* den man für ein Taschengeld kaufen kann! Auf ihm läuft auch Linux! (wispor.de)

0297 TEIL III Linux-Grundlagen

0299 8 Arbeiten im Terminal
* Das Terminal unter Linux entspricht dem
* Befehlseingabefenster unter Windows. (wispor.de)

0313 9 bash (Shell)

0363 10 zsh (Shell)

0375 11 Dateien und Verzeichnisse

0419 12 Prozessverwaltung

0451 13 Konverter für Grafik, Text und Multimedia

0467 14 Netzwerk-Tools

0487 TEIL IV Text- und Code-Editoren

0489 15 Visual Studio Code

0503 16 Vim

0521 17 Emacs

0543 TEIL V Systemkonfiguration und Administration

0545 18 Basiskonfiguration

0627 19 Netzwerkkonfiguration

0675 20 Software- und Paketverwaltung

0731 21 Grafiksystem

0765 22 Administration des Dateisystems

0863 23 GRUB
* GRUB ist ein Bootloader; quasi das Startprogramm von Linux. (wispor.de)

0887 24 Das Init-System

0909 25 Kernel und Module

0947 TEIL VI Server-Konfiguration

0949 26 Server-Installation

0995 27 Secure Shell (SSH)

1013 28 Apache
* Apache ist der meistgenutzte Webserver im Internet. (wispor.de)

1063 29 MySQL und MariaDB
* MySQL und MariaDB sind Datenbanksysteme. (wispor.de)

1087 30 Postfix und Dovecot

1155 31 Nextcloud

1173 32 Samba
* "Fast alle Linux-Distributionen enthalten Samba und bieten damit Zugriff
* auf Dateifreigaben in gemischten Netzwerken, in denen z. B. auch Windows
* eingesetzt wird." (Quelle: Wikipedia, 18.Mär.2022)

1215 TEIL VII Sicherheit

1217 33 Backups

1255 34 Firewalls

1285 35 SELinux und AppArmor

1301 TEIL VIII Virtualisierung & Co.

1303 36 VirtualBox

1321 37 QEMU/KVM

1361 38 Docker
* Docker Container sind eine Art light-Version von Virtuellen Maschinen.
* Vorteile von Containern: sie brauchen deutlich weniger Speicher und sie
* laufen deutlich schneller. (wispor.de)

1407 39 Linux on Windows

1421 Index
* (ca. 1.500 Stichwörter!) (wispor.de)



* Das Programm WINE ist in diesem Buch nicht erwähnt, deshalb hole ich das hier kurz
* nach: WINE erlaubt es unter sehr vielen Linux-Distributionen zahlreiche Windows-
* Programme laufen zu lassen. So sind wir hier Fans des Grafikbetrachters: Irfanview
* und des Übersetzungsprogramms: Quickdic. Beide laufen unter WINE auf Ubuntu.
* Je einfacher die zu verwendenden Programme sind, desto größer ist auch die
* Chance, dass sie auch unter WINE lauffähig sind ... Hier hilft nur: ausprobieren
.

D:\Wispor\Rezensionen\Linux_Kofler17_ari.txt





















'Leitfaden Alg II / Sozialhilfe von A-Z'

ISBN 3-932246-68-5
31. neu bearbeitete Auflage (Stand: Feb.2021), 848 Seiten.

19,00 € [D] (Keine Versandkosten innerhalb von Deutschland!)

Inhaltsverzeichnis (Hauptschlagwörter):

Zuständigkeit

Rezension: - Arrist Spieß (wispor.de ) - letzte Korrekturen: 21.Mai 2021

'Effektiv Python programmieren'

90 Wege für bessere Python-Programme





Bestellung der Broschüre:
'Leitfaden Sozialhilfe für Behinderte und Pflegebedürftige von A-Z'

DVS
Schumannstr. 51
60325 Frankfurt


oder per E-Mail:

d.v.s@t-online.de

oder per E-Mail:

agtuwas@web.de
www.agtuwas.de


'Leitfaden Sozialhilfe für Behinderte und Pflegebedürftige von A-Z'

ISBN 3-932246-47-0
08. Auflage (März 2005) 131 Seiten.
5,00 € [D] (einschließlich Versandkosten!)


Rezension: - Arrist Spieß (wispor.de ) - letzte Korrekturen: 10. Dez. 2005

'Sozialhilfemißbrauch'

Michael Kofler. LINUX. Das umfassende Handbuch 17., aktualisierte Auflage 2021, 1.452 Seiten: Natürlich, im Internet findet man (gerade auch auf den englisch-sprachigen Seiten sehr viele Informationen zu Linux). Aber dieses anarchisch-demokratisches Gebilde, das niemanden gehört, hat auch deshalb so seine Tücken. Jeder kennt das: Genau die Antwort, die man sucht ist auch nach stundenlangem Suchen einfach nicht zu finden - egal welche Suchbegriffe man eingibt ... Und die meisten Treffer erzielt man auf englisch, was auch mitunter dann schwierig ist. Bei dieser Linux-Bibel von Professor Kofler ist das aber anders: Er geht sehr systematisch vor. Ein Hauptwerkzeug ist dabei das Terminal. Dies garantiert uns, dass die angegebenen Befehlssequenzen auf allen Linux-Distributionen laufen und man nicht immer wieder neu irgendwelche Programme bedienen lernen muss. Das Buch befasst sich mit: der Installation von Linux, der Anwendung von Linux und reicht bis hin zu Systemkonfiguration und Administration und Serverkonfiguration. Weitere Themen sind: Text- und Code-Editoren, Virtualisierung und natürlich die System-Sicherheit. Wer noch tiefer in die "Eingeweide" von Linux herab will, kann natürlich auf einen recht großen Fundus von Büchern zugreifen. Michael Kofler hat ja darauf auch schon reagiert und z.B. eine Linux Kommandoreferenz (die wir hier auch im Einsatz haben!) heraus gegeben, die jetzt (2022) auch schon in der 5. Auflage erschienen ist. Diese Referenz behandelt auch so 'mal eben über 500 Befehle für die Kommandozeilen-Ebene. Diese Auslagerung belegt auch deutlich, dass die Kofler-Linux-Bibel mit 1.450 Seiten ihre Kapazitätsgrenze mehr als erreicht hat und dass eine Aufnahme z.B. der Kommandozeilen-Referenz (mit auch noch 'mal 530? Seiten) deutlich zuviel des Guten wäre. Die Basis der Beschreibungen liefert auch hier die am weitesten verbreitete Linux-Distribution: Ubuntu. Der Preis (knapp 50 Euro) für die "Linux-Bibel" ist u.M.n. fair und eine wirklich gute Investition für alle Linux-Nutzer - Beginner wie Fortgeschrittene. INHALTSVERZEICHNIS der "Linux-Bibel": LINUX. Das umfassende Handbuch, Michael Kofler, 17. Aufl., 2021: 0019 Vorwort 0021 Konzeption 0023 TEIL I Installation 0025 1 Was ist Linux? 0037 2 Installationsgrundlagen 0071 3 Installationsanleitungen 0115 TEIL II Linux anwenden 0117 4 Gnome 0163 5 KDE * Gnome und KDE sind Desktop-Varianten (wispor.de) 0179 6 Desktop-Apps und Tools 0241 7 Raspberry Pi * Der Raspberry Pi ist ein Einplatinen-Computer im Scheckkartenformat, * den man für ein Taschengeld kaufen kann! Auf ihm läuft auch Linux! (wispor.de) 0297 TEIL III Linux-Grundlagen 0299 8 Arbeiten im Terminal * Das Terminal unter Linux entspricht dem * Befehlseingabefenster unter Windows. (wispor.de) 0313 9 bash (Shell) 0363 10 zsh (Shell) 0375 11 Dateien und Verzeichnisse 0419 12 Prozessverwaltung 0451 13 Konverter für Grafik, Text und Multimedia 0467 14 Netzwerk-Tools 0487 TEIL IV Text- und Code-Editoren 0489 15 Visual Studio Code 0503 16 Vim 0521 17 Emacs 0543 TEIL V Systemkonfiguration und Administration 0545 18 Basiskonfiguration 0627 19 Netzwerkkonfiguration 0675 20 Software- und Paketverwaltung 0731 21 Grafiksystem 0765 22 Administration des Dateisystems 0863 23 GRUB * GRUB ist ein Bootloader; quasi das Startprogramm von Linux. (wispor.de) 0887 24 Das Init-System 0909 25 Kernel und Module 0947 TEIL VI Server-Konfiguration 0949 26 Server-Installation 0995 27 Secure Shell (SSH) 1013 28 Apache * Apache ist der meistgenutzte Webserver im Internet. (wispor.de) 1063 29 MySQL und MariaDB * MySQL und MariaDB sind Datenbanksysteme. (wispor.de) 1087 30 Postfix und Dovecot 1155 31 Nextcloud 1173 32 Samba * "Fast alle Linux-Distributionen enthalten Samba und bieten damit Zugriff * auf Dateifreigaben in gemischten Netzwerken, in denen z. B. auch Windows * eingesetzt wird." (Quelle: Wikipedia, 18.Mär.2022) 1215 TEIL VII Sicherheit 1217 33 Backups 1255 34 Firewalls 1285 35 SELinux und AppArmor 1301 TEIL VIII Virtualisierung & Co. 1303 36 VirtualBox 1321 37 QEMU/KVM 1361 38 Docker * Docker Container sind eine Art light-Version von Virtuellen Maschinen. * Vorteile von Containern: sie brauchen deutlich weniger Speicher und sie * laufen deutlich schneller. (wispor.de) 1407 39 Linux on Windows 1421 Index * (ca. 1.500 Stichwörter!) (wispor.de) * Das Programm WINE ist in diesem Buch nicht erwähnt, deshalb hole ich das hier kurz * nach: WINE erlaubt es unter sehr vielen Linux-Distributionen zahlreiche Windows- * Programme laufen zu lassen. So sind wir hier Fans des Grafikbetrachters: Irfanview * und des Übersetzungsprogramms: Quickdic. Beide laufen unter WINE auf Ubuntu. * Je einfacher die zu verwendenden Programme sind, desto größer ist auch die * Chance, dass sie auch unter WINE lauffähig sind ... Hier hilft nur: ausprobieren.

Bestellung der Broschüre:
Fachhochschulverlag
Kleiststr. 31
60318 Frankfurt am Main

bestellung@fhverlag.de
www.fhverlag.de

'Leitfaden Sozialhilfe für Behinderte und Pflegebedürftige von A-Z'

ISBN 3-932246-47-0
08. Auflage (März 2005) 131 Seiten.
5,00 € [D] (einschließlich Versandkosten!)


Rezension: - Arrist Spieß (wispor.de ) - letzte Korrekturen: 10. Dez. 2005

'Sozialhilfemißbrauch'

Michael Kofler. LINUX. Das umfassende Handbuch 17., aktualisierte Auflage 2021, 1.452 Seiten: Natürlich, im Internet findet man (gerade auch auf den englisch-sprachigen Seiten sehr viele Informationen zu Linux). Aber dieses anarchisch-demokratisches Gebilde, das niemanden gehört, hat auch deshalb so seine Tücken. Jeder kennt das: Genau die Antwort, die man sucht ist auch nach stundenlangem Suchen einfach nicht zu finden - egal welche Suchbegriffe man eingibt ... Und die meisten Treffer erzielt man auf englisch, was auch mitunter dann schwierig ist. Bei dieser Linux-Bibel von Professor Kofler ist das aber anders: Er geht sehr systematisch vor. Ein Hauptwerkzeug ist dabei das Terminal. Dies garantiert uns, dass die angegebenen Befehlssequenzen auf allen Linux-Distributionen laufen und man nicht immer wieder neu irgendwelche Programme bedienen lernen muss. Das Buch befasst sich mit: der Installation von Linux, der Anwendung von Linux und reicht bis hin zu Systemkonfiguration und Administration und Serverkonfiguration. Weitere Themen sind: Text- und Code-Editoren, Virtualisierung und natürlich die System-Sicherheit. Wer noch tiefer in die "Eingeweide" von Linux herab will, kann natürlich auf einen recht großen Fundus von Büchern zugreifen. Michael Kofler hat ja darauf auch schon reagiert und z.B. eine Linux Kommandoreferenz (die wir hier auch im Einsatz haben!) heraus gegeben, die jetzt (2022) auch schon in der 5. Auflage erschienen ist. Diese Referenz behandelt auch so 'mal eben über 500 Befehle für die Kommandozeilen-Ebene. Diese Auslagerung belegt auch deutlich, dass die Kofler-Linux-Bibel mit 1.450 Seiten ihre Kapazitätsgrenze mehr als erreicht hat und dass eine Aufnahme z.B. der Kommandozeilen-Referenz (mit auch noch 'mal 530? Seiten) deutlich zuviel des Guten wäre. Die Basis der Beschreibungen liefert auch hier die am weitesten verbreitete Linux-Distribution: Ubuntu. Der Preis (knapp 50 Euro) für die "Linux-Bibel" ist u.M.n. fair und eine wirklich gute Investition für alle Linux-Nutzer - Beginner wie Fortgeschrittene. INHALTSVERZEICHNIS der "Linux-Bibel": LINUX. Das umfassende Handbuch, Michael Kofler, 17. Aufl., 2021: 0019 Vorwort 0021 Konzeption 0023 TEIL I Installation 0025 1 Was ist Linux? 0037 2 Installationsgrundlagen 0071 3 Installationsanleitungen 0115 TEIL II Linux anwenden 0117 4 Gnome 0163 5 KDE * Gnome und KDE sind Desktop-Varianten (wispor.de) 0179 6 Desktop-Apps und Tools 0241 7 Raspberry Pi * Der Raspberry Pi ist ein Einplatinen-Computer im Scheckkartenformat, * den man für ein Taschengeld kaufen kann! Auf ihm läuft auch Linux! (wispor.de) 0297 TEIL III Linux-Grundlagen 0299 8 Arbeiten im Terminal * Das Terminal unter Linux entspricht dem * Befehlseingabefenster unter Windows. (wispor.de) 0313 9 bash (Shell) 0363 10 zsh (Shell) 0375 11 Dateien und Verzeichnisse 0419 12 Prozessverwaltung 0451 13 Konverter für Grafik, Text und Multimedia 0467 14 Netzwerk-Tools 0487 TEIL IV Text- und Code-Editoren 0489 15 Visual Studio Code 0503 16 Vim 0521 17 Emacs 0543 TEIL V Systemkonfiguration und Administration 0545 18 Basiskonfiguration 0627 19 Netzwerkkonfiguration 0675 20 Software- und Paketverwaltung 0731 21 Grafiksystem 0765 22 Administration des Dateisystems 0863 23 GRUB * GRUB ist ein Bootloader; quasi das Startprogramm von Linux. (wispor.de) 0887 24 Das Init-System 0909 25 Kernel und Module 0947 TEIL VI Server-Konfiguration 0949 26 Server-Installation 0995 27 Secure Shell (SSH) 1013 28 Apache * Apache ist der meistgenutzte Webserver im Internet. (wispor.de) 1063 29 MySQL und MariaDB * MySQL und MariaDB sind Datenbanksysteme. (wispor.de) 1087 30 Postfix und Dovecot 1155 31 Nextcloud 1173 32 Samba * "Fast alle Linux-Distributionen enthalten Samba und bieten damit Zugriff * auf Dateifreigaben in gemischten Netzwerken, in denen z. B. auch Windows * eingesetzt wird." (Quelle: Wikipedia, 18.Mär.2022) 1215 TEIL VII Sicherheit 1217 33 Backups 1255 34 Firewalls 1285 35 SELinux und AppArmor 1301 TEIL VIII Virtualisierung & Co. 1303 36 VirtualBox 1321 37 QEMU/KVM 1361 38 Docker * Docker Container sind eine Art light-Version von Virtuellen Maschinen. * Vorteile von Containern: sie brauchen deutlich weniger Speicher und sie * laufen deutlich schneller. (wispor.de) 1407 39 Linux on Windows 1421 Index * (ca. 1.500 Stichwörter!) (wispor.de) * Das Programm WINE ist in diesem Buch nicht erwähnt, deshalb hole ich das hier kurz * nach: WINE erlaubt es unter sehr vielen Linux-Distributionen zahlreiche Windows- * Programme laufen zu lassen. So sind wir hier Fans des Grafikbetrachters: Irfanview * und des Übersetzungsprogramms: Quickdic. Beide laufen unter WINE auf Ubuntu. * Je einfacher die zu verwendenden Programme sind, desto größer ist auch die * Chance, dass sie auch unter WINE lauffähig sind ... Hier hilft nur: ausprobieren.

Bestellung der Broschüre:
Fachhochschulverlag
Kleiststr. 31
60318 Frankfurt am Main

bestellung@fhverlag.de
www.fhverlag.de

'Sozialhilfemißbrauch. Wer missbraucht eigentlich wen?'
von Professor Rainer Roth


ISBN: 3-936065-33-0
(2004), 104 Seiten.
5,80 € [D] (versandkostenfrei!)


Rezension: - Arrist Spieß (wispor.de ) - letzte Korrekturen: 07. Jan.  2006

'Leitfaden für Arbeitslose' Der Rechtsratgeber zum SGB III (Arbeitslosengeld I)

Die Broschüre 'Leitfaden für Arbeitslose' Der Rechtsratgeber zum SGB III (gemeint ist das Arbeitslosengeld I) stellt einen mehr als notwendigen Helfer in dem Dschungel des SGB III dar.

Es ist für den Normalsterblichen einfach unmöglich, durch dieses Gewimmel von Paragraphen und Bestimmungen und Auslegungen allein hindurch zufinden!

Wer damit rechnen muss, dass er bald SGB III-Leistungen in Anspruch nehmen muss, oder schon diese Leistungen bezieht, der sollte sich diese Broschüre schleunigst bestellen.

Auf über 700 Seiten werden u. a. folgende Hauptthemen beschrieben:

Dazu enthält die Broschüre noch ein Abkürzungsverzeichnis, ein Stichwortverzeichnis, Schaubilder, Tabellen und Musterbriefe.

Wirksam unterstützt werden die genannten Paragraphen und Bestimmungen durch zahlreiche konkrete Beispiele!

Der Fachhochschulverlag bringt übrigens auch für SGB_II = Hart_IV (Arbeitslosengeld II) und für SGB_XII (= Sozialhilfe) ähnliche Broschüren heraus.

Bestellung der Broschüre(n):
Fachhochschulverlag
Kleiststr. 10 (Gebäude 1)
60318 Frankfurt am Main

bestellung@fhverlag.de
www.fhverlag.de

'Leitfaden für Arbeitslose' Der Rechtsratgeber zum SGB III
von Ulrich Stascheit und Ute Winkler


ISBN: 3-940087-55-3
(2010), 702 Seiten.
15,00 € [D] zzgl. Porto


Rezension: - Arrist Spieß (wispor.de ) - letzte Korrekturen: 22. Dez. 2010

'Sind Arbeitslose faul?
Was ist dran an den Vorwürfen?'


Die Broschüre: 'Sind Arbeitslose faul?" von Klartext e.V. erschienen im Fachhochschulverlag widerspricht fundiert den gängigen Voreingenommenheiten, den von Wirtschaftskreisen und der Politik, gezielt in die Welt gesetzten und verbreiteten 'Argumenten' und auch der 'Volksmeinung' zur Arbeitslosigkeit, bzw. den Arbeitslosen.

In der Broschüre wird vielen dieser Klischees mit aussagekräftigen Argumenten, Zahlen, Fakten und Zitaten zu Leibe gerückt. Als da sind z. B.:

"Viele Arbeitslose wollen nicht arbeiten!"

"Jeder, der Arbeit will, findet auch welche!"

"Den Arbeitslosen geht es zu gut - Deshalb wollen sie nicht arbeiten!"

"Die Sozialhilfe ist zu hoch - Deshalb wollen Sozialhilfeempfänger nicht arbeiten!"


Die Argumentation gegen diese dummen Sprüche erfolgt immer kurz und knapp und eignet sich so auch ganz hervorragend für die Weiterverwendung in gewerkschaftlichen und/oder anderen sozial und politisch motivierten Gruppen. Etwa für Flugblätter, als Argumentationshilfen etc.

Wichtig ist in diesem Zusammenhang natürlich auch die Broschüre
'Sozialhilfemißbrauch', die ebenfalls im Fachhochschulverlag erschienen ist und die ähnliche, gleiche Gründe festmacht, die hinter der gesamtgesellschaftlichen Treibjagd - gerade unserer Zeit - stecken.
In der 'Missbrauch'-Broschüre wird aufgezeigt, wer tatsächlich Missbrauch betreibt. Dass sind offenkundig nicht 'die' Sozialhilfeempfänger oder 'die' Arbeitslosen!!!



Bestellung der Broschüre:
Fachhochschulverlag
Kleiststr. 31
60318 Frankfurt am Main

bestellung@fhverlag.de
www.fhverlag.de

'Sind Arbeitslose faul? Was ist dran an den Vorwürfen?'
Klartext e.V. (Hrsg.)


ISBN: 3-936065-18-7
(2004), 48 Seiten.
3,00 € [D] (versandkostenfrei!)


Rezension: - Arrist Spieß (wispor.de ) - letzte Korrekturen: 13. Jan.  2006

'Wir sind besser, als wir glauben'
Wohlstand für alle




Professor Peter Bofinger (ehemals einer der '5 Wirtschaftsweisen') geht in diesem Buch leicht verständlich, aber dennoch fundiert auf 284 Seiten auf die großen Wirtschaftsfragen unserer Republik ein.

Seine Gegenpositionen zur herrschenden Meinung sind nicht nur erfrischend, sondern auch dringend nötig, um der einseitigen Ausrichtung der öffentlichen Diskussion zu diesem Thema wenigstens etwas entgegen zu setzen.

Besonders interessant ist dabei auch, dass sich Professor Bofinger immer wieder auf Positionen des Vaters des dt. Wirtschaftswunders 'Ludwig Erhardt' bezieht.

Prof. Bofinger nimmt z. B. folgende polulären Einschätzungen, die uns überall (und nicht nicht nur in den Medien) immer wieder, quasio als Faustformeln, präsentiert werden gründlich auseinander und bezieht Gegenpositon.

1. Wir leben über unsere Verhältnisse.
2. Arbeit lohnt sich nicht mehr.
3. Der Staat ist zu fett geworden.
4. Die Steuern sind viel zu hoch.
5. Die Bürokratie erstickt das Wachstum.
6. Die Löhne sind zu hoch, Arbeitszeit zu kurz.
7. Der Arbeitsmarkt ist zu unflexibel.
8. Wir haben unsere Wettbewerbsfähigkeit verloren.
9. Immer mehr Firmen investieren im Ausland.


Prof. Bofinger gibt hier auch Antworten auf zentrale Fragen und Themen wie:

Was bedeutet die Globalisierung tatsächlich für unsere Arbeitsplätze?
Warum steigen die Staatsschulden immer weiter an?
Wovon hängt es ab, ob wir die demografische Zeitbombe entschärfen können?
Wie geil ist Geiz wirklich?

Teil I: Warum wir besser sind, als wir glauben.
Teil II: Die Hypotheken der 90er Jahre.
Teil III: Sparen, Sparen über alles?
Teil IV: Vor der Reform ist nach der Reform.
Teil V: Von der "Wende zum Weniger" zum "dynamischen Durchbruch nach vorne".


Besonders wichtig finde ich, dass Prof. Bofinger handfeste Argumente z. B. gegen den Sozialabbau liefert und den unbedingten Erhalt des Sozialstaates (wie er im Grundgesetz verankert ist) propagiert.

*Peter Bofinger ist Professor für Geldpolitik und internationale Wirtschaftsbeziehungen an der Universität Würzburg.

'Wir sind besser, als wir glauben'
Wohlstand für alle

Autor: Professor Peter Bofinger

Pearson-Studium
ISBN: 3-8273-7138-4
(2005), 284 Seiten.
19,95 € [D] | 20,60 € [A]


Rezension: - Arrist Spieß (wispor.de ) - letzte Korrekturen: 11. Aug. 2006

'Wirtschaft die arm macht'
Vom Sozialstaat zur gespaltenen Gesellschaft





Autor: Horst Afheldt

Verlag Kunstmann

In seinem Buch 'Wirtschaft die arm macht' Vom Sozialstaat zur gespaltenen Gesellschaft
, das uns in der überarbeiteten Neuauflage von 2005 vorliegt, beschreibt der Autor Horst Afheldt wirklich sehr gut nachvollziehbar und sehr gut lesbar (es ist kaum 'Fachchinesisch' zu finden) zum Einen die Folgen der Arbeitsmarkt-'Reformen' in unserem Lande.

Dabei zeigt Afheldt gründlich auf, dass kein Wirtschaftssystem für die Ewigkeit gemacht ist.

Es wird (auch nach seiner Auffassung) höchste Zeit, dass der neoliberale Wahnsinn, der gebetsmühlenartig auf den in die Krise geratenen Kapitalismus - weil ihm das Wachstum ausbliebt - immer herunter gebetet und leider auch angewandt wird, ein Ende hat. Soll heißen: "Löhne runter, Wachstum, Wachstum, Wachstum ..., weg mit 'Handelshemmnissen', Unternehmens-'Entlastungen' von Abgaben und Steuern.

Denn ganz offensichtlich - schließlich wird es ja schon über 10 Jahre versucht! - greifen die neoliberalen Ideen überhaupt nicht, wie sich an dem Zustand unserer Gesellschaft zum Leidwesen von mindest einem Drittel der Gesellschaft ablesen läßt (schließlich lebt schon jetzt ein großer Teil der Erwerbsttätigen und der Arbeitslosen sowieso in Dtl. in 'prekären' Verhältnissen)!

Horst Afheldt wendet sich hier auch mutig gegen den Gedanken des weltweiten Freihandels.

*Info (wispor.de):
Freihandel: Internationaler Handel ohne jegliche Beschränkung des Staates von Im- und Export (also z.B. keine Zölle ...).


'Wirtschaft die arm macht'
Vom Sozialstaat zur gespaltenen Gesellschaft


Verlag Kunstmann
ISBN: 3-88897-385-6
Neuausgabe (2005), 256 Seiten.
19,90 € [D] | SFR 34,90 €


Rezension: - Arrist Spieß (wispor.de ) - letzte Korrekturen: 07. Dez. 2007

'Schamland'
Die Armut mitten unter uns




Autor: Prof. Stefan Selke

Verlag Econ

Professor Selke stellt in seinem Buch: 'Schamland' aus 2013 die Welt der Arbeitslosen in Deutschland vor.

Er setzt den Fokus auf die (mittlerweile fast 1.000 mit weit über 2.000 Ausgabestellen, für bis zu 1,5 Mio. Menschen / Stand: Feb. 2018) TAFELn in Deutschland und was die Nutzung bei den Betroffenen bewirkt.

Ein System, das nur als Notlösung gedacht war und schon 1993 in Berlin (als Suppenküche, Hilfe für Obdachlose) gestartet ist, hat sich derartig durch die AGENDA 2010 und Hartz IV verfestigt, dass man sich vielfach als von Arbeitslosigkeit, sprich Armut Betroffener, sagen lassen muss: 'Wenn's nicht reicht, gehen Sie doch zur TAFEL!'.

*Kommentar (wispor.de) ===

Als wenn der TAFEL-Besuch fester Bestandteil, der ganz offensichtlich nicht ausreichenden 'Bezüge' von Hartz IV, Sozialhilfe, Grundsicherung und (der wohl am schlimmsten Betroffenen) den Asylsuchenden - auch durch die seit Jahren heftig steigenden Kosten für z.B.: Mieten, Energierversorgung, Lebensmittel, sein soll.

Wie zum Hohn werden nur Minimal-Erhöhungen von Hartz IV und Sozialhilfe um jeweils wenige Euros vorgenommen.
Nach dem Motto: 'Seht, wir tun doch etwas!'.

===

*Hier aus eigener Erfahrung einige (zusätzliche) 'gute' Argumente gegen die TAFELn und für ein die Betroffenen ausreichend versorgendes Sozialsystem, auf das man einen Rechtsanspruch hat und nicht für fragwürdige (wenn auch von privater Seite sicherlich gut gemeinte) Hilfe den ewigen Bittsteller mimen muss:

1a. Was ist mit denen, die chronisch krank sind und nicht zur Tafel können???

1b. Was mit denen, die Magen- oder Darmkrank sind und die meisten Sachen gar nicht vertragen???

2. Was ist das für ein 'Sozial-System', bei dem man als mehrfach-chronisch Kranker im Februar 1 1/2 Stunden draußen in der Kälte in der Schlange stehen muss, um die milden Gaben zu empfangen, von denen man nicht einmal weiß, was z.B. für einen Magen-Darm-Kranken überhaupt verwertbar ist (mir geschehen in Münster [Westfalen], Herz-Jesu-Kirche)!!! Der Tross dieser Armen war übrigens die ganze Zeit über deutlich für die vorbeiflanierenden 'Normal-Bürger' an einer Hauptstraße (Wolbecker-Straße) sichtbar.
3. In Münster (Westf.) gab es (zumindest um den 17.04.2014 herum) einen TAFEL-Ausgabestopp. Ich solle in 6 Wochen 'mal wieder anrufen!!! *Was machen diejenigen, die sich auf diese 'Not-Versorgung' fest eingerichtet haben, wenn sie plötzlich ersatzlos wegfällt???

===



Nach Professor Selke hat sich sogar eine regelrechte 'Armuts-Ökonomie' herausgebildet.

Nutznießer sind teilweise karitative Einrichtungen, aber vor allem Firmen, die als Sach-Spender fungieren und nicht müde werden ihr Engagement zur Imageaufpolierung zu vermarkten.

So kam z.B. (siehe 'Schamland', S. xxx) eine Werbefirma auf die hinterfotzige Idee, leere Pfandflaschen mit einem Etikett zu versehen, auf dem dem Finder eine Portion von der ortsansässigen TAFEL garantiert wurde!

*Kommentar (wispor.de) === Also, es ist richtig, im Dreck wühlen zu müssen, um einen Anspruch auf Segnungen von honorigen Gönnern erlangen zu können ? ... Genau: "Gewöhnt euch schon einmal daran, Ihr Schmeisfliegen - ab in die Container. Und vergesst auf keinen Fall, Danke zu sagen!" ===

Noch nie hat es ein Buch zu diesem Thema gegeben, in dem derartig viele Arme in unserem Land mit auf den Punkt gebrachten Zitaten zu Wort kommen!

Der größte Teil des Buches ist aber gesellschaftliche Anlayse. Aber keine Sorge, dieses Buch ist nicht für Fachkollegen geschrieben, sondern richtet sich an alle Interessierten. Sprich, es ist durchweg einfach zu verstehen.

Stefan Selke ist Soziologieprofessor an der Hochschule in Furtwangen auf dem Lehrstuhl: 'Gesellschaftlicher Wandel'.

Fazit:

Ein außerordentlich wichtiges Buch zum Thema Arbeitslosigkeit und deren Auswirkungen auf die Betroffenen im heutigen Deutschland.

Endlich erhebt jemand aus der geistigen Elite dieses Landes laut und deutlich und vor allem auch ausdauernd seine Stimme gegen offensichtliche Missstände, die so viele Menschen unter ein derartig entwürdigendes Kuratel gestellt haben.

Kritik:

Was unserer Meinung nach diese Buch noch ein klein wenig wertvoller machen würde:

Wir wünschen uns wie immer einen ausführlichen Index. Der fehlt hier leider ganz.

Und - auch wie immer - wir wünschen uns für alle Sachbücher die Abbildung, Beschreibung des inhaltlichen Extraktes. Sprich, eine sehr kurze und knappe Zusammenfassung jedes Kapitels.

*Kommentar (wispor.de) ===

Es ist eine Schande, dass nicht viel, viel mehr von unserer geistigen Elite, so z.B. Hochschulprofessoren etc. sich schützend vor die betroffenen Bürger stellen. Gegen diesen - die Gesellschaft zerreissenden - stetig fortschreitenden Prozess vehement angehen.

* Statt dessen nutzen unglaublich viele Professoren (seit Jahren) die 'tolle' Gelegenheit und stellen 1-Euro-Kräfte an, um die Bezahlung von studentischen Hilfskräften zu sparen.



'Schamland'
Die Armut mitten unter uns


Verlag Econ
ISBN: 978-3-430-20152-0
(2013), 279 Seiten.

18,00 € [D] | 18,50 [A] €


Rezension: - Arrist Spieß (wispor.de ) - letzte Korrekturen: 03. Feb. 2020

 
© Texte, Datenbanken, Auflistungssysteme, Fotos & Layout (wispor.de)
- lexikalischer Auskunftsdienst / Münster (Westfalen)