Funktionale Programmierung mit Python

Name: Funktionale Programmierung mit Python
Brand: Hanser
Price: 39.99 EUR
Availability: OnlineOnly

Bernd Klein Philip Klein(Autor*in)

Hanser (Verlag)

1. Auflage

Erschienen am 13. Januar 2025

356 Seiten

E-Book

ePUB mit Wasserzeichen-DRM

Systemvoraussetzungen

E-Book

PDF mit Wasserzeichen-DRM

Systemvoraussetzungen

978-3-446-48200-5 (ISBN)

39,99 €inkl. 7% MwSt.

Systemvoraussetzungen

für ePUB mit Wasserzeichen-DRM und PDF mit Wasserzeichen-DRM

(Hinweis: Die Auswahl des von Ihnen gewünschten Dateiformats und des Kopierschutzes erfolgt erst im System des E-Book Anbieters)

E-Book Einzellizenz

Als Download verfügbar

Beschreibung

- Erweitern Sie Ihre Programmierfähigkeiten in Python
- Erhöhen Sie mittels funktionaler Programmierung die Qualität Ihres Codes
- Lernen Sie anhand zahlreicher praxisbezogener Übungsaufgaben
- Mit Beispielen und Lösungen aus dem Buch auf der begleitenden Website
- Vermeiden Sie Nebenwirkungen durch den Einsatz reiner Funktionen
- Einführung in höherwertige Funktionen zur Steigerung der Programmier-Effizienz
- Optimieren Sie Ihre Codes durch Lazy Evaluation und Generatoren
- Ihr exklusiver Vorteil: E-Book inklusive beim Kauf des gedruckten Buches

Das Buch bietet zahlreiche Vorteile für alle, die ihre Programmierkenntnisse vertiefen möchten. Es vermittelt grundlegende Konzepte wie Funktionen als erste Klasse Bürger, Unveränderlichkeit, Funktionskomposition und Funktionen höherer Ordnung. Dabei fördert es einen deklarativen Programmierstil, der die Skalierbarkeit von Anwendungen erleichtert und durch den Einsatz von Funktionen ohne Seiteneffekte die Codequalität verbessert.
Zudem werden höhere Abstraktionen wie Dekoratoren, Generatoren, Closures, Memoisation und Currying ausführlich erklärt. Durch praxisnahe Beispiele und Übungen mit Lösungen wird die Anwendung dieser Konzepte deutlich erleichtert.
Darüber hinaus behandelt das Buch auch die funktionale Emulation von OOP-Konzepten, was besonders bei komplexen Anwendungen von Nutzen ist. Insgesamt hilft es dabei, das Verständnis für diese fortgeschrittenen Themen zu vertiefen und die Programmierfähigkeiten in verschiedenen Kontexten effektiv anzuwenden.

AUS DEM INHALT //
- Einführung in Python unter funktionalen Aspekten
- Collections-Modul
- Dataclasses und Pattern Matching
- Funktionen höherer Ordnung
- Dekoratoren _ Memoisation
- Closures
- Komposition von Funktionen
- Currying in Python
- Funktionale Emulation von OOP-Konzepten
- Generatoren und Iteratoren
- Iteratoren der Standardbibliothek
- Das Modul itertools

Rezensionen / Stimmen

"Funktionale Programmierung mit Python ist ein praxisnahes, verständliches und vielseitiges Buch, das funktionale Konzepte in Python aufgreift, ohne dogmatisch zu sein. Es motiviert, diese Paradigmen im Alltag einzusetzen. Für Python-Entwickler und -Entwicklerinnen, die über imperative oder objektorientierte Muster hinausblicken wollen, eine klare Empfehlung!" Dr. Fabian Deitelhoff, LinkedIN, 06.05.2025

Weitere Details

Weitere Ausgaben

Personen

Inhalt

1 - Inhalt [Seite 7]
2 - Teil I Einleitung [Seite 15]
2.1 - 1 Vorwort [Seite 17]
2.2 - 2 Danksagung [Seite 19]
2.3 - 3 Einleitung [Seite 21]
2.3.1 - 3.1 Einführung [Seite 21]
2.3.2 - 3.2 Zielsetzung des Buches [Seite 21]
2.3.3 - 3.3 Aufbau des Buches [Seite 22]
2.3.4 - 3.4 Leserschaft [Seite 24]
2.3.5 - 3.5 Zusätzliche Unterlagen [Seite 24]
3 - Teil II Python-Grundlagen unter funktionalen Aspekten [Seite 25]
3.1 - 4 Variablen und Datentypen [Seite 27]
3.1.1 - 4.1 Variablen [Seite 27]
3.1.1.1 - 4.1.1 Gültige Variablennamen [Seite 29]
3.1.1.2 - 4.1.2 Konventionen für Variablennamen [Seite 29]
3.1.2 - 4.2 Übersicht Datenstrukturen [Seite 30]
3.1.2.1 - 4.2.1 Unveränderliche (immutable) Datentypen [Seite 30]
3.1.2.2 - 4.2.2 Veränderliche (mutable) Datentypen [Seite 30]
3.1.3 - 4.3 Datenstrukturen im Detail [Seite 31]
3.1.3.1 - 4.3.1 Integer [Seite 31]
3.1.3.2 - 4.3.2 Floats [Seite 31]
3.1.3.3 - 4.3.3 Zeichenketten oder Strings [Seite 32]
3.1.3.4 - 4.3.4 Bytesequenz [Seite 34]
3.1.3.5 - 4.3.5 Listen [Seite 35]
3.1.3.6 - 4.3.6 Mengen [Seite 36]
3.1.3.7 - 4.3.7 Dictionaries [Seite 37]
3.2 - 5 Kontrollstrukturen [Seite 39]
3.2.1 - 5.1 Sequenz [Seite 40]
3.2.2 - 5.2 Bedingte Anweisungen [Seite 40]
3.2.2.1 - 5.2.1 Vollständiges if [Seite 40]
3.2.2.2 - 5.2.2 Ternäres if [Seite 42]
3.2.3 - 5.3 Schleifen [Seite 43]
3.2.3.1 - 5.3.1 while-Schleife [Seite 43]
3.2.3.1.1 - 5.3.1.1 Allgemeine Arbeitsweise [Seite 43]
3.2.3.1.2 - 5.3.1.2 while-Schleife mit else [Seite 44]
3.2.3.2 - 5.3.2 while-Schleife als rekursive Funktion [Seite 45]
3.2.3.3 - 5.3.3 Allgemeine while-Funktion [Seite 47]
3.2.3.4 - 5.3.4 for-Schleife [Seite 48]
3.2.3.5 - 5.3.5 for-Schleife in funktionaler Programmierung [Seite 50]
3.3 - 6 Das Modul collections [Seite 51]
3.3.1 - 6.1 Übersicht [Seite 51]
3.3.2 - 6.2 namedtuple [Seite 52]
3.3.3 - 6.3 Deque [Seite 55]
3.3.4 - 6.4 ChainMap [Seite 56]
3.3.5 - 6.5 Counter [Seite 58]
4 - Teil III Funktionale Programmierung [Seite 61]
4.1 - 7 Begriffsbestimmung [Seite 63]
4.1.1 - 7.1 Einführung [Seite 63]
4.1.2 - 7.2 Verschiedene Programmierparadigmen [Seite 64]
4.1.3 - 7.3 Funktionale Programmierung [Seite 64]
4.2 - 8 Funktionen [Seite 67]
4.2.1 - 8.1 Einleitung [Seite 67]
4.2.2 - 8.2 Funktionen [Seite 67]
4.2.2.1 - 8.2.1 Einfache Funktionen [Seite 67]
4.2.2.2 - 8.2.2 Typehints [Seite 69]
4.2.2.2.1 - 8.2.2.1 Einführende Beispiele [Seite 69]
4.2.2.2.2 - 8.2.2.2 Typehints mit mypy [Seite 70]
4.2.2.3 - 8.2.3 Default-Parameter und Schlüsselwortparameter [Seite 71]
4.2.2.4 - 8.2.4 Weitere Typehints [Seite 71]
4.2.2.5 - 8.2.5 Lokale Funktionen [Seite 72]
4.2.2.6 - 8.2.6 Globale und lokale Variablen in Funktionen [Seite 73]
4.2.2.7 - 8.2.7 Gültigkeit von Variablen in verschachtelten Funktionen [Seite 74]
4.2.3 - 8.3 Dataclasses und Pattern Matching [Seite 77]
4.2.3.1 - 8.3.1 Dataclasses [Seite 77]
4.2.3.1.1 - 8.3.1.1 Standardargumente und Fabrikfunktionen [Seite 78]
4.2.3.1.2 - 8.3.1.2 Unterschiede zum namedtuple [Seite 80]
4.2.3.2 - 8.3.2 Pattern Matching [Seite 83]
4.2.3.2.1 - 8.3.2.1 Einführung [Seite 83]
4.2.3.2.2 - 8.3.2.2 Binärbäume mit Pattern Matching durchlaufen [Seite 83]
4.2.4 - 8.4 Aufgaben [Seite 84]
4.2.5 - 8.5 lambda [Seite 85]
4.2.5.1 - 8.5.1 lambda mit sorted [Seite 87]
4.2.6 - 8.6 Aufgaben [Seite 88]
4.2.7 - 8.7 Rekursive Funktionen [Seite 89]
4.2.7.1 - 8.7.1 Einführung [Seite 89]
4.2.7.2 - 8.7.2 Definition der Rekursion [Seite 90]
4.2.7.3 - 8.7.3 Iterative Lösung im Vergleich zur rekursiven Lösung [Seite 91]
4.2.7.4 - 8.7.4 Kategorien der Rekursion [Seite 91]
4.2.7.4.1 - 8.7.4.1 Lineare Rekursion [Seite 92]
4.2.7.4.2 - 8.7.4.2 Gegenseitige/Wechselseitige Rekursion [Seite 93]
4.2.7.4.3 - 8.7.4.3 Baumartige Rekursion [Seite 94]
4.2.7.4.4 - 8.7.4.4 Endrekursion [Seite 99]
4.2.8 - 8.8 Aufgaben [Seite 99]
4.2.9 - 8.9 Funktionen als Erste-Klasse-Objekte [Seite 101]
4.2.9.1 - 8.9.1 Definition [Seite 101]
4.2.9.2 - 8.9.2 Zuweisung an Variable [Seite 102]
4.2.9.3 - 8.9.3 Funktionen in Datenstrukturen [Seite 103]
4.2.9.4 - 8.9.4 Funktionen als Argumente [Seite 106]
4.2.9.5 - 8.9.5 Funktionen innerhalb von Funktionen [Seite 107]
4.2.9.5.1 - 8.9.5.1 Kapselung und Verbergen [Seite 107]
4.2.9.5.2 - 8.9.5.2 Fabrikfunktionen [Seite 109]
4.2.10 - 8.10 Aufgaben [Seite 112]
4.3 - 9 Dekoratoren [Seite 113]
4.3.1 - 9.1 Einführung Dekoratoren [Seite 113]
4.3.2 - 9.2 Ein einfacher Dekorator [Seite 114]
4.3.3 - 9.3 @-Syntax für Dekoratoren [Seite 115]
4.3.4 - 9.4 Dekoratoren für beliebige Signaturen [Seite 116]
4.3.5 - 9.5 Anwendungsfälle für Dekoratoren [Seite 117]
4.3.5.1 - 9.5.1 Erweiterung von Funktionen [Seite 118]
4.3.5.2 - 9.5.2 Logging-Dekorator [Seite 119]
4.3.5.3 - 9.5.3 Authentifizierung und Autorisierung [Seite 120]
4.3.5.4 - 9.5.4 Validierung: Überprüfung von Argumenten [Seite 121]
4.3.5.5 - 9.5.5 Profiling: Funktionsaufrufe mit einem Dekorator zählen [Seite 122]
4.3.6 - 9.6 Dekoratoren mit Parametern [Seite 123]
4.3.6.1 - 9.6.1 Einführendes Beispiel [Seite 123]
4.3.6.2 - 9.6.2 Weiteres Beispiel [Seite 124]
4.3.7 - 9.7 Benutzung von Wraps aus functools [Seite 126]
4.3.8 - 9.8 Mehrfache Dekoration einer Funktion [Seite 128]
4.3.8.1 - 9.8.1 Veranschaulichung [Seite 128]
4.3.8.2 - 9.8.2 Python-Beispiel [Seite 129]
4.3.8.3 - 9.8.3 Praktisches Beispiel einer Mehrfachdekoration [Seite 130]
4.3.9 - 9.9 Eine Klasse als Dekorator benutzen [Seite 133]
4.3.10 - 9.10 Klassendekoration [Seite 134]
4.3.11 - 9.11 Dekorator-Aufgaben [Seite 137]
4.4 - 10 Memoisation [Seite 139]
4.4.1 - 10.1 Bedeutung und Herkunft des Begriffs [Seite 139]
4.4.2 - 10.2 Memoisation mit Dekoratorfunktionen [Seite 140]
4.4.3 - 10.3 Memoisation mit einer Klasse [Seite 143]
4.4.4 - 10.4 Memoisation mit functools.lru_cache [Seite 143]
4.4.5 - 10.5 Aufgaben zur Memoisation [Seite 145]
4.5 - 11 Closures [Seite 147]
4.5.1 - 11.1 Einleitung [Seite 147]
4.5.1.1 - 11.1.1 Definition [Seite 148]
4.5.1.2 - 11.1.2 Praktische Anwendungen von Closures [Seite 150]
4.5.2 - 11.2 Aufgaben [Seite 150]
4.6 - 12 Komposition von Funktionen [Seite 151]
4.6.1 - 12.1 Einführung [Seite 151]
4.6.2 - 12.2 Funktionskomposition in Python [Seite 152]
4.6.3 - 12.3 Komposition mit beliebiger Argumentenzahl [Seite 154]
4.6.4 - 12.4 Komposition einer beliebigen Anzahl von Funktionen [Seite 155]
4.6.5 - 12.5 Aufgaben [Seite 156]
4.7 - 13 Currying in Python [Seite 157]
4.7.1 - 13.1 Einführung [Seite 157]
4.7.1.1 - 13.1.1 Zugrundeliegende Idee [Seite 157]
4.7.1.2 - 13.1.2 Herkunft des Names [Seite 158]
4.7.2 - 13.2 Currying von Funktionen [Seite 158]
4.7.2.1 - 13.2.1 Definition und Beispiel [Seite 158]
4.7.2.2 - 13.2.2 BMI als Beispiel [Seite 159]
4.7.2.3 - 13.2.3 BMI als Beispiel [Seite 159]
4.7.3 - 13.3 Benutzung von partial [Seite 160]
4.7.4 - 13.4 Praktisches Beispiel für Currying: E-Mail-Vorlagen [Seite 160]
4.7.5 - 13.5 Dekorator für Currying [Seite 162]
4.7.6 - 13.6 Weitere Beispiele [Seite 164]
4.7.6.1 - 13.6.1 Arithmetische Operatoren [Seite 164]
4.7.6.2 - 13.6.2 Beispiel aus der Finanzwelt [Seite 165]
4.7.6.3 - 13.6.3 Currying zur Listenfilterung [Seite 168]
4.7.7 - 13.7 Currying-Funktion mit einer beliebigen Anzahl von Parametern [Seite 168]
4.7.8 - 13.8 Aufgaben [Seite 171]
4.8 - 14 Funktionale Emulation von OOP-Konzepten [Seite 173]
4.8.1 - 14.1 Einführung [Seite 173]
4.8.2 - 14.2 Imitation einer Klasse durch eine Funktion [Seite 174]
4.8.2.1 - 14.2.1 Erstes Beispiel: Geradengenerierung [Seite 174]
4.8.2.2 - 14.2.2 Private Attribute [Seite 175]
4.8.2.3 - 14.2.3 Klasse mit Gettern und Settern als Funktion [Seite 176]
4.8.2.4 - 14.2.4 Nachahmung von Vererbung [Seite 179]
4.8.2.5 - 14.2.5 Überlagern von Funktionen [Seite 183]
4.8.3 - 14.3 Aufgaben [Seite 185]
4.9 - 15 Generatoren und Iteratoren [Seite 189]
4.9.1 - 15.1 Definitionen [Seite 189]
4.9.2 - 15.2 Einführung [Seite 189]
4.9.2.1 - 15.2.1 Iterierbar [Seite 190]
4.9.2.2 - 15.2.2 Iterator und Arbeitsweise der for-Schleife [Seite 190]
4.9.3 - 15.3 Eigenen Iterator erzeugen [Seite 193]
4.9.3.1 - 15.3.1 Beispiel einer Iteratorklasse [Seite 193]
4.9.4 - 15.4 Generatoren und Generatorfunktionen [Seite 194]
4.9.4.1 - 15.4.1 Unendliche Generatoren [Seite 198]
4.9.5 - 15.5 Endlos-Generatoren zähmen mit firstn und islice [Seite 199]
4.9.6 - 15.6 Beispiele aus der Kombinatorik [Seite 202]
4.9.6.1 - 15.6.1 Permutationen [Seite 202]
4.9.6.2 - 15.6.2 Variationen und Kombinationen [Seite 203]
4.9.7 - 15.7 Generator-Ausdrücke [Seite 205]
4.9.8 - 15.8 yield from [Seite 206]
4.9.9 - 15.9 return-Anweisungen in Generatoren [Seite 207]
4.9.10 - 15.10 send-Methode [Seite 210]
4.9.10.1 - 15.10.1 Arbeitsweise [Seite 210]
4.9.10.2 - 15.10.2 Umprogrammierung mittels send [Seite 212]
4.9.10.3 - 15.10.3 Radio-Beispiel mit send [Seite 213]
4.9.11 - 15.11 Die close-Methode [Seite 215]
4.9.12 - 15.12 Die throw-Methode [Seite 216]
4.9.13 - 15.13 Dekoration von Generatoren [Seite 220]
4.9.14 - 15.14 Aufgaben [Seite 221]
4.10 - 16 Iteratoren der Standardbibliothek [Seite 225]
4.10.1 - 16.1 Einführung [Seite 225]
4.10.2 - 16.2 Wichtige Iteratoren und iteratorähnliche Funktionen in der Python-Standardbibliothek [Seite 226]
4.10.3 - 16.3 enumerate [Seite 226]
4.10.4 - 16.4 map, filter und reduce [Seite 228]
4.10.4.1 - 16.4.1 map [Seite 228]
4.10.4.2 - 16.4.2 Filtern von sequentiellen Datentypen mittels "filter" [Seite 229]
4.10.4.3 - 16.4.3 reduce [Seite 230]
4.10.4.4 - 16.4.4 Zusammenspiel von map, filter und reduce [Seite 232]
4.10.5 - 16.5 Listen-Abstraktion [Seite 232]
4.10.5.1 - 16.5.1 Alternative zu map und filter [Seite 232]
4.10.5.2 - 16.5.2 Syntax [Seite 233]
4.10.5.3 - 16.5.3 Weitere Beispiele [Seite 234]
4.10.5.4 - 16.5.4 Die zugrunde liegende Idee [Seite 234]
4.10.5.5 - 16.5.5 Anspruchsvolleres Beispiel [Seite 235]
4.10.5.6 - 16.5.6 Mengen-Abstraktion [Seite 236]
4.10.5.7 - 16.5.7 Generatoren-Abstraktion [Seite 236]
4.10.5.8 - 16.5.8 map und filter oder Listen-Abstraktion [Seite 237]
4.10.5.9 - 16.5.9 Dict-Komprehension in Python [Seite 237]
4.10.6 - 16.6 reversed [Seite 238]
4.10.7 - 16.7 Die zip-Funktion [Seite 238]
4.10.8 - 16.8 zip in Kombination mit map und filter [Seite 240]
4.10.9 - 16.9 Aufgaben [Seite 241]
4.11 - 17 Das Modul itertools [Seite 243]
4.11.1 - 17.1 Übersicht [Seite 243]
4.11.2 - 17.2 Unendliche Iteratoren [Seite 244]
4.11.2.1 - 17.2.1 itertools.count [Seite 245]
4.11.2.1.1 - 17.2.1.1 Beispiel: Teilbarkeit [Seite 246]
4.11.2.1.2 - 17.2.1.2 Beispiel: Quadratpolynome [Seite 246]
4.11.2.1.3 - 17.2.1.3 Beispiel: Bestellungsmanager [Seite 247]
4.11.2.2 - 17.2.2 chain und chain.from_iterable [Seite 248]
4.11.2.3 - 17.2.3 cycle [Seite 251]
4.11.2.4 - 17.2.4 tee [Seite 251]
4.11.2.4.1 - 17.2.4.1 Effiziente Implementierung von cycle [Seite 252]
4.11.2.4.2 - 17.2.4.2 Beispiel: Aufgaben und Mitarbeiter [Seite 253]
4.11.2.5 - 17.2.5 repeat [Seite 254]
4.11.3 - 17.3 Iteratoren über endliche Sequenzen [Seite 254]
4.11.3.1 - 17.3.1 slice und islice [Seite 255]
4.11.3.1.1 - 17.3.1.1 slice [Seite 255]
4.11.3.1.2 - 17.3.1.2 islice [Seite 255]
4.11.3.1.3 - 17.3.1.3 slice und islice im Vergleich [Seite 257]
4.11.3.2 - 17.3.2 accumulate [Seite 258]
4.11.3.2.1 - 17.3.2.1 Praktisches Börsenbeispiel [Seite 258]
4.11.3.3 - 17.3.3 compress [Seite 260]
4.11.3.3.1 - 17.3.3.1 Einführung [Seite 260]
4.11.3.3.2 - 17.3.3.2 Umfangreiches Beispiel [Seite 261]
4.11.3.4 - 17.3.4 dropwhile [Seite 262]
4.11.3.5 - 17.3.5 takewhile [Seite 263]
4.11.3.6 - 17.3.6 filterfalse [Seite 265]
4.11.3.7 - 17.3.7 groupby [Seite 266]
4.11.3.8 - 17.3.8 pairwise [Seite 268]
4.11.3.9 - 17.3.9 n_grams und map_n [Seite 270]
4.11.3.10 - 17.3.10 zip_longest [Seite 272]
4.11.3.11 - 17.3.11 starmap [Seite 272]
4.11.4 - 17.4 Kombinatorische Generatoren [Seite 274]
4.11.4.1 - 17.4.1 product [Seite 274]
4.11.4.2 - 17.4.2 permutations [Seite 276]
4.11.4.3 - 17.4.3 combinations [Seite 279]
4.11.4.3.1 - 17.4.3.1 Arbeitsweise [Seite 279]
4.11.4.3.2 - 17.4.3.2 Beispiel: Speisekartengenerierung [Seite 279]
4.11.4.3.3 - 17.4.3.3 Beispiel: Benachbarte Kantengraphen [Seite 282]
4.11.4.4 - 17.4.4 combinations_with_replacement [Seite 283]
4.11.4.5 - 17.4.5 Umfangreiches praktisches Beispiel: csv-Datei lesen [Seite 284]
4.11.5 - 17.5 Aufgaben [Seite 288]
5 - Teil IV Lösungen zu den Aufgaben [Seite 293]
5.1 - 18 Lösungen zu den Aufgaben [Seite 295]
5.1.1 - 18.1 Lösungen zu Abschnitt 8.9 (Funktionen als Erste-Klasse-Objekte) [Seite 295]
5.1.2 - 18.2 Lösungen zu Abschnitt 8.3 (Dataclasses und Pattern Matching) [Seite 297]
5.1.3 - 18.3 Lösungen zu Abschnitt 8.5 (lambda) [Seite 298]
5.1.4 - 18.4 Lösungen zu Abschnitt 8.7 (Rekursive Funktionen) [Seite 299]
5.1.5 - 18.5 Lösungen zu Abschnitt 8.9 (Funktionen als Erste-Klasse-Objekte) [Seite 303]
5.1.6 - 18.6 Lösungen zu Kapitel 9 (Dekoratoren) [Seite 304]
5.1.7 - 18.7 Lösungen zu Kapitel 10 (Memoisation) [Seite 312]
5.1.8 - 18.8 Lösungen zu Kapitel 11 (Closures) [Seite 317]
5.1.9 - 18.9 Lösungen zu Kapitel 16 (Iteratoren der Standardbibliothek) [Seite 318]
5.1.10 - 18.10 Lösungen zu Abschnitt 16.5 (Listen-Abstraktion) [Seite 320]
5.1.11 - 18.11 Lösungen zu Kapitel 15 (Generatoren und Iteratoren) [Seite 322]
5.1.12 - 18.12 Lösungen zu Kapitel 17 (Das Modul itertools) [Seite 330]
5.1.13 - 18.13 Lösungen zu Kapitel 12 (Komposition von Funktionen) [Seite 345]
5.1.14 - 18.14 Lösungen zu Kapitel 13 (Currying in Python) [Seite 348]
5.1.15 - 18.15 Lösungen zu Kapitel 14 (Funktionale Emulation von OOP-Konzepten) [Seite 349]
6 - Stichwortverzeichnis [Seite 355]

3 Einleitung 3.1 Einführung

Dieses Buch widmet sich einem speziellen und faszinierenden Aspekt der Programmierung mit Python: der funktionalen Programmierung. Während Python vor allem für seine Einfachheit und Vielseitigkeit bekannt ist, bietet es auch mächtige Werkzeuge und Paradigmen, die es ermöglichen, Probleme auf eine neue und elegante Weise zu lösen. Eines dieser Paradigmen ist die funktionale Programmierung.

Funktionale Programmierung ist ein Programmierparadigma, das darauf abzielt, Berechnungen als Auswertung mathematischer Funktionen zu behandeln und Zustandsveränderungen zu vermeiden. Dies steht im Gegensatz zum imperativen Paradigma, das den Schwerpunkt auf die Ausführung von Befehlen und die Manipulation von Zuständen legt. Durch die Anwendung der Prinzipien der funktionalen Programmierung können Programme oft klarer, kompakter und weniger fehleranfällig gestaltet werden.

3.2 Zielsetzung des Buches

Dieses Buch ist nicht als umfassende und systematische Einführung in die funktionale Programmierung konzipiert. Der Grund dafür liegt darin, dass Python keine rein funktionale Programmiersprache ist, sondern eine vielseitige Sprache, die sowohl imperative als auch objektorientierte Paradigmen unterstützt. Obwohl Python viele funktionale Prinzipien integriert, bietet es oft Kompromisse zugunsten dieser anderen Paradigmen. Der Schwerpunkt dieses Buches liegt daher auf den Bereichen der funktionalen Programmierung, in denen Python besonders stark ist. Dies wird durch zahlreiche praktische Anwendungen und anschauliche Beispiele verdeutlicht. Jedes Kapitel endet mit einer Reihe von Aufgaben, die das Gelernte vertiefen und erweitern. Zu allen Aufgaben werden ausführliche Lösungen bereitgestellt, um das Verständnis zu fördern und die Lernziele zu erreichen.

3.3 Aufbau des Buches

Das Buch besteht aus zwei Hauptteilen:

1. Python-Grundlagen unter funktionalen Aspekten

2. Funktionale Programmierung

Im ersten Teil des Buches befassen wir uns mit den grundlegenden Datenstrukturen von Python wie Integer, Gleitkommazahlen, Strings, Listen, Tupel und Dictionaries. Darüber hinaus behandeln wir die Kontrollstrukturen, darunter bedingte Anweisungen und Schleifen, wobei wir dabei auf die Besonderheiten im Vergleich zur funktionalen Programmierung bereits ein wenig eingehen.

Das Modul in Python ist wichtig, weil es erweiterte Datenstrukturen wie , , und bietet, die über die Standard-Datenstrukturen hinausgehen und häufige Programmieraufgaben erleichtern. Diese spezialisierten Container ermöglichen effizientere und lesbarere Lösungen für komplexe Aufgabenstellungen. In der funktionalen Programmierung erleichtert das Modul die Arbeit mit unveränderlichen und strukturierten Daten, indem es z. B. bereitstellt, um benannte und unveränderliche Datentypen zu erstellen. Außerdem bietet eine praktische Möglichkeit, Daten zu aggregieren und zu zählen, was funktionale Techniken wie Map- und Reduce-Operationen unterstützen kann.

Da die funktionale Programmierung bei all diesen Themen nicht im Vordergrund steht, haben wir sie in diesem ersten Teil des Buches zusammengefasst. Dieser Abschnitt richtet sich insbesondere an Personen, die bereits über Programmiererfahrung verfügen, jedoch noch keine Vorkenntnisse in Python besitzen.

Im zweiten Teil geht es dann um die funktionalen Aspekte. Zunächst bemühen wir uns um eine Begriffsbestimmung des funktionalen Programmierstils und einer Abgrenzung zu anderen Programmierparadigmen in Kapitel 7 (Begriffsbestimmung). Das folgende Kapitel 8 (Funktionen) widmet sich ganz den Funktionen: beginnend bei einfachen Funktionen, lambda-Funktionen und rekursiven Funktionen bis hin zum Prinzip der First-Class-Funktionen. Dann sind wir bereit für das Thema Dekoratoren in Kapitel 9 (Dekoratoren). Dekoratorfunktionen in Python ermöglichen es, das Verhalten von Funktionen oder Methoden modular und wiederverwendbar zu erweitern oder zu modifizieren, ohne den ursprünglichen Code zu verändern. In diesem Kapitel finden sich viele interessante Anwendungen für Dekoratoren in Form von Beispielen und Aufgaben. Einer der faszinierendsten Anwendungen, nämlich der Memoisation, ist ein eigenes Kapitel 10 (Memoisation) gewidmet.

Die Komposition von Funktionen ist in der funktionalen Programmierung von großer Bedeutung, da sie hilft, sauberen, wartbaren und flexiblen Code zu schreiben. Sie fördert die Modularität, Lesbarkeit und Wiederverwendbarkeit von Funktionen, unterstützt die Vermeidung von Seiteneffekten und ermöglicht eine höhere Abstraktionsebene, die die Entwicklung komplexer Systeme vereinfacht. Dieses Thema behandeln wir deshalb auch in einem eigenen Kapitel 12 (Komposition von Funktionen).

Mit dem Thema "Currying" beschäftigen wir uns in Kapitel 13 (Currying in Python). Dabei handelt es sich um ein zentrales Konzept der funktionalen Programmierung, das die Umwandlung von Funktionen mit mehreren Argumenten in eine Serie von Funktionen mit jeweils einem Argument ermöglicht. Dies verbessert die Modularität und Wiederverwendbarkeit des Codes. In Python unterstützt Currying elegante und flexible Code-Strukturen, die den Prinzipien der funktionalen Programmierung entsprechen.

Funktionale Programmierung und objektorientierte Programmierung sind mächtige, aber unterschiedliche Paradigmen. In Kapitel 14 (Funktionale Emulation von OOP-Konzepten) zeigen wir, dass es sich nicht um unvereinbare oder gegensätzliche Paradigmen handelt. Wir zeigen, wie wir Klassendefinitionen in der funktionalen Programmierung durch First-Class-Funktionen unter Wahrung der objektorientierten Ziele realisieren können. Zudem demonstrieren wir, dass sich selbst objektorientierte Konzepte wie Vererbung funktional emulieren lassen.

Iteratoren und Generatoren sind in Python von großer Bedeutung, da sie eine effiziente Speicherverwaltung ermöglichen. Anstatt Daten vollständig auf einmal zu laden, erzeugen und verarbeiten sie diese bei Bedarf. Dies führt zu einer verbesserten Leistung und Skalierbarkeit von Programmen, insbesondere bei der Verarbeitung großer Datenmengen oder endloser Sequenzen. Deshalb haben wir dieser Thematik gleich drei Kapitel gewidmet. In Kapitel 15 (Generatoren und Iteratoren) zeigen wir, wie man mit Generatorfunktionen Iteratoren erzeugt, die Werte schrittweise mit dem Schlüsselwort zurückgeben, wodurch sie speichereffizient große Datenmengen oder unendliche Sequenzen verarbeiten können. In Kapitel 16 (Iteratoren der Standardbibliothek) lernen wir dann wichtige Iteratoren wie , , , , , der Standardbibliothek kennen. In den Beispielen demonstrieren wir, wie man mit ihrer Hilfe effizienteren Code schreiben kann. Das effizientere Laufzeitverhalten bei der Verwendung von Iteratoren und Generatoren kann allgemein dadurch erklärt werden, dass sie Daten "on-the-fly" erzeugen, anstatt ganze Listen oder andere Datenstrukturen im Speicher zu halten.

Besonders intensiv gehen wir in Kapitel 17 (Das Modul itertools) auf das Modul ein, da es im Zusammenhang mit funktionaler Programmierung von besonderer Wichtigkeit ist, weil es eine Sammlung von effizienten, speichersparenden Iteratoren zur Verfügung stellt, die sich ideal für funktionale Programmierparadigmen eignen. Diese Werkzeuge ermöglichen es, komplexe Iterationen und Kombinationen von Daten in einem deklarativen Stil auszudrücken, ohne explizit Schleifen oder temporäre Datenstrukturen zu verwenden. Dies führt zu sauberem, lesbarem und wartbarem Code, der die Prinzipien der funktionalen Programmierung wie Unveränderlichkeit und First-Class-Funktionen unterstützt.

Die -Bibliothek in Python bietet vielseitige Funktionen für die Arbeit mit Iterationen. Zu den wichtigsten gehören unendliche Iteratoren wie , und , die unendlich lange Sequenzen erzeugen. Endliche Kombinations- und Permutations-Iteratoren wie , , und ermöglichen die Erzeugung komplexer Kombinationen und Anordnungen von Daten. Zudem bietet leistungsfähige Filter- und Mapping-Tools wie , , und , die es ermöglichen, Sequenzen nach bestimmten Kriterien zu filtern und zu transformieren. Insgesamt erleichtert die effiziente und speicherschonende Verarbeitung von Daten.

3.4 Leserschaft

Auch wenn wir im Buch extra einen Abschnitt zu den Grundlagen von Python aufgenommen haben, wäre es dennoch hilfreich, bereits etwas Programmiererfahrung mit Python zu besitzen. Ansonsten richtet sich dieses Buch an Personen mit Programmiererfahrung in...

Systemvoraussetzungen

Dateiformat: ePUB
Kopierschutz: Wasserzeichen-DRM (Digital Rights Management)

Systemvoraussetzungen:

Computer (Windows; MacOS X; Linux): Verwenden Sie eine Lese-Software, die das Dateiformat ePUB verarbeiten kann: z.B. Adobe Digital Editions oder FBReader – beide kostenlos (siehe E-Book Hilfe).
Tablet/Smartphone (Android; iOS): Installieren Sie die App Adobe Digital Editions oder eine andere Leseapp für E-Books, z.B. PocketBook (siehe E-Book Hilfe).
E-Book-Reader: Bookeen, Kobo, Pocketbook, Sony, Tolino u.v.a.m.

Das Dateiformat ePUB ist sehr gut für Romane und Sachbücher geeignet - also für „fließenden” Text ohne komplexes Layout. Bei E-Readern oder Smartphones passt sich der Zeilen- und Seitenumbruch automatisch den kleinen Displays an.
Mit Wasserzeichen-DRM wird hier ein „weicher” Kopierschutz verwendet. Daher ist technisch zwar alles möglich – sogar eine unzulässige Weitergabe. Aber an sichtbaren und unsichtbaren Stellen wird der Käufer des E-Books als Wasserzeichen hinterlegt, sodass im Falle eines Missbrauchs die Spur zurückverfolgt werden kann.

Weitere Informationen finden Sie in unserer E-Book Hilfe.

Dateiformat: PDF
Kopierschutz: Wasserzeichen-DRM (Digital Rights Management)

Systemvoraussetzungen:

Computer (Windows; MacOS X; Linux): Verwenden Sie zum Lesen die kostenlose Software Adobe Reader, Adobe Digital Editions oder einen anderen PDF-Viewer Ihrer Wahl (siehe E-Book Hilfe).
Tablet/Smartphone (Android; iOS): Installieren Sie bereits vor dem Download die kostenlose App Adobe Digital Editions oder die App PocketBook (siehe E-Book Hilfe).
E-Book-Reader: Bookeen, Kobo, Pocketbook, Sony, Tolino u.v.a.m.

Das Dateiformat PDF zeigt auf jeder Hardware eine Buchseite stets identisch an. Daher ist eine PDF auch für ein komplexes Layout geeignet, wie es bei Lehr- und Fachbüchern verwendet wird (Bilder, Tabellen, Spalten, Fußnoten). Bei kleinen Displays von E-Readern oder Smartphones sind PDF leider eher nervig, weil zu viel Scrollen notwendig ist. Mit Wasserzeichen-DRM wird hier ein „weicher” Kopierschutz verwendet. Daher ist technisch zwar alles möglich – sogar eine unzulässige Weitergabe. Aber an sichtbaren und unsichtbaren Stellen wird der Käufer des E-Books als Wasserzeichen hinterlegt, sodass im Falle eines Missbrauchs die Spur zurückverfolgt werden kann.

Weitere Informationen finden Sie in unserer E-Book Hilfe.

Als PDF speichern Als Link merken