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