39,99 €
Mehr erfahren.
- Herausgeber: Carl Hanser Verlag GmbH & Co. KG
- Kategorie: Wissenschaft und neue Technologien
- Sprache: Deutsch
- Veröffentlichungsjahr: 2025
- 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
Das E-Book können Sie in Legimi-Apps oder einer beliebigen App lesen, die das folgende Format unterstützen:
Ähnliche
Bernd Klein, Philip Klein
Funktionale Programmierung mit Python
Die Autoren:Bernd Klein, SingenPhilip Klein, Freiburg
Print-ISBN: 978-3-446-48191-6E-Book-ISBN: 978-3-446-48200-5E-Pub-ISBN: 978-3-446-48379-8
Alle in diesem Werk enthaltenen Informationen, Verfahren und Darstellungen wurden nach bestem Wissen erstellt und mit Sorgfalt getestet. Dennoch sind Fehler nicht ganz auszuschließen. Aus diesem Grund sind die im vorliegenden Werk enthaltenen Informationen mit keiner Verpflichtung oder Garantie irgendeiner Art verbunden. Autor und Verlag übernehmen infolgedessen keine Verantwortung und werden keine daraus folgende oder sonstige Haftung übernehmen, die auf irgendeine Art aus der Benutzung dieses Programm-Materials – oder Teilen davon – entsteht. Ebenso übernehmen Autoren und Verlag keine Gewähr dafür, dass beschriebene Verfahren usw. frei von Schutzrechten Dritter sind.
Die Wiedergabe von Gebrauchsnamen, Handelsnamen, Warenbezeichnungen usw. in diesem Werk berechtigt also auch ohne besondere Kennzeichnung nicht zu der Annahme, dass solche Namen im Sinne der Warenzeichen- und Markenschutz-Gesetzgebung als frei zu betrachten wären und daher von jedermann benutzt werden dürften.
Bibliografische Information der Deutschen Nationalbibliothek:Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.d-nb.de abrufbar.
Dieses Werk ist urheberrechtlich geschützt.Alle Rechte, auch die der Übersetzung, des Nachdruckes und der Vervielfältigung des Buches, oder Teilen daraus, vorbehalten. Kein Teil des Werkes darf ohne schriftliche Genehmigung des Verlages in irgendeiner Form (Fotokopie, Mikrofilm oder ein anderes Verfahren), auch nicht für Zwecke der Unterrichtsgestaltung – mit Ausnahme der in den §§ 53, 54 URG genannten Sonderfälle –, reproduziert oder unter Verwendung elektronischer Systeme verarbeitet, vervielfältigt oder verbreitet werden.
Wir behalten uns auch eine Nutzung des Werks für Zwecke des Text- und Data Mining nach § 44b UrhG ausdrücklich vor.
Aus Gründen der besseren Lesbarkeit wird auf die gleichzeitige Verwendung der Sprachformen männlich, weiblich und divers (m/w/d) verzichtet. Sämtliche Personenbezeichnungen gelten gleichermaßen für alle Geschlechter.
© 2025 Carl Hanser Verlag GmbH & Co. KG, MünchenKolbergerstraße 22 | 81679 München | [email protected]: Brigitte Bauer-SchiewekCopy editing: Jürgen Dubau, FreiburgLayout: die Autoren mit LaTeXHerstellung: le-tex publishing services GmbH, LeipzigCoverkonzept: Marc Müller-Bremer, www.rebranding.de, MünchenCovergestaltung: Thomas WestTitelmotiv: © vectorpouch / Shutterstock
Inhalt
Titelei
Impressum
Inhalt
Teil I Einleitung
1 Vorwort
2 Danksagung
3 Einleitung
3.1 Einführung
3.2 Zielsetzung des Buches
3.3 Aufbau des Buches
3.4 Leserschaft
3.5 Zusätzliche Unterlagen
Teil II Python-Grundlagen unter funktionalen Aspekten
4 Variablen und Datentypen
4.1 Variablen
4.1.1 Gültige Variablennamen
4.1.2 Konventionen für Variablennamen
4.2 Übersicht Datenstrukturen
4.2.1 Unveränderliche (immutable) Datentypen
4.2.2 Veränderliche (mutable) Datentypen
4.3 Datenstrukturen im Detail
4.3.1 Integer
4.3.2 Floats
4.3.3 Zeichenketten oder Strings
4.3.4 Bytesequenz
4.3.5 Listen..
4.3.6 Mengen
4.3.7 Dictionaries
5 Kontrollstrukturen
5.1 Sequenz
5.2 Bedingte Anweisungen
5.2.1 Vollständiges if
5.2.2 Ternäres if
5.3 Schleifen
5.3.1 while-Schleife
5.3.1.1 Allgemeine Arbeitsweise
5.3.1.2 while-Schleife mit else
5.3.2 while-Schleife als rekursive Funktion
5.3.3 Allgemeine while-Funktion
5.3.4 for-Schleife
5.3.5 for-Schleife in funktionaler Programmierung
6 Das Modul collections
6.1 Übersicht
6.2 namedtuple
6.3 Deque
6.4 ChainMap
6.5 Counter
Teil III Funktionale Programmierung
7 Begriffsbestimmung
7.1 Einführung
7.2 Verschiedene Programmierparadigmen
7.3 Funktionale Programmierung
8 Funktionen
8.1 Einleitung
8.2 Funktionen
8.2.1 Einfache Funktionen
8.2.2 Typehints
8.2.2.1 Einführende Beispiele
8.2.2.2 Typehints mit mypy
8.2.3 Default-Parameter und Schlüsselwortparameter
8.2.4 Weitere Typehints
8.2.5 Lokale Funktionen
8.2.6 Globale und lokale Variablen in Funktionen
8.2.7 Gültigkeit von Variablen in verschachtelten Funktionen
8.3 Dataclasses und Pattern Matching
8.3.1 Dataclasses
8.3.1.1 Standardargumente und Fabrikfunktionen
8.3.1.2 Unterschiede zumnamedtuple
8.3.2 Pattern Matching
8.3.2.1 Einführung
8.3.2.2 Binärbäume mit Pattern Matching durchlaufen
8.4 Aufgaben
8.5 lambda
8.5.1 lambda mit sorted
8.6 Aufgaben
8.7 Rekursive Funktionen
8.7.1 Einführung
8.7.2 Definition der Rekursion
8.7.3 Iterative Lösung im Vergleich zur rekursiven Lösung
8.7.4 Kategorien der Rekursion
8.7.4.1 Lineare Rekursion
8.7.4.2 Gegenseitige/Wechselseitige Rekursion
8.7.4.3 Baumartige Rekursion
8.7.4.4 Endrekursion
8.8 Aufgaben
8.9 Funktionen als Erste-Klasse-Objekte
8.9.1 Definition
8.9.2 Zuweisung an Variable
8.9.3 Funktionen in Datenstrukturen
8.9.4 Funktionen als Argumente
8.9.5 Funktionen innerhalb von Funktionen
8.9.5.1 Kapselung und Verbergen
8.9.5.2 Fabrikfunktionen
8.10 Aufgaben
9 Dekoratoren
9.1 Einführung Dekoratoren
9.2 Ein einfacher Dekorator
9.3 @-Syntax für Dekoratoren
9.4 Dekoratoren für beliebige Signaturen
9.5 Anwendungsfälle für Dekoratoren
9.5.1 Erweiterung von Funktionen
9.5.2 Logging-Dekorator
9.5.3 Authentifizierung und Autorisierung
9.5.4 Validierung: Überprüfung von Argumenten
9.5.5 Profiling: Funktionsaufrufemit einem Dekorator zählen
9.6 Dekoratoren mit Parametern
9.6.1 Einführendes Beispiel
9.6.2 Weiteres Beispiel
9.7 Benutzung von Wraps aus functools
9.8 Mehrfache Dekoration einer Funktion
9.8.1 Veranschaulichung
9.8.2 Python-Beispiel
9.8.3 Praktisches Beispiel einer Mehrfachdekoration
9.9 Eine Klasse als Dekorator benutzen
9.10 Klassendekoration
9.11 Dekorator-Aufgaben
10 Memoisation
10.1 Bedeutung und Herkunft des Begriffs
10.2 Memoisation mit Dekoratorfunktionen
10.3 Memoisation mit einer Klasse
10.4 Memoisation mit functools.lru_cache
10.5 Aufgaben zur Memoisation
11 Closures
11.1 Einleitung
11.1.1 Definition
11.1.2 Praktische Anwendungen von Closures
11.2 Aufgaben
12 Komposition von Funktionen
12.1 Einführung
12.2 Funktionskomposition in Python
12.3 Komposition mit beliebiger Argumentenzahl
12.4 Komposition einer beliebigen Anzahl von Funktionen
12.5 Aufgaben
13 Currying in Python
13.1 Einführung
13.1.1 Zugrundeliegende Idee
13.1.2 Herkunft des Names
13.2 Currying von Funktionen
13.2.1 Definition und Beispiel
13.2.2 BMI als Beispiel
13.2.3 BMI als Beispiel
13.3 Benutzung von partial
13.4 Praktisches Beispiel für Currying: E-Mail-Vorlagen
13.5 Dekorator für Currying
13.6 Weitere Beispiele
13.6.1 Arithmetische Operatoren
13.6.2 Beispiel aus der Finanzwelt
13.6.3 Currying zur Listenfilterung
13.7 Currying-Funktion mit einer beliebigen Anzahl von Parametern
13.8 Aufgaben
14 Funktionale Emulation von OOP-Konzepten
14.1 Einführung
14.2 Imitation einer Klasse durch eine Funktion
14.2.1 Erstes Beispiel: Geradengenerierung
14.2.2 Private Attribute
14.2.3 Klasse mit Gettern und Settern als Funktion
14.2.4 Nachahmung von Vererbung
14.2.5 Überlagern von Funktionen
14.3 Aufgaben
15 Generatoren und Iteratoren
15.1 Definitionen
15.2 Einführung
15.2.1 Iterierbar
15.2.2 Iterator und Arbeitsweise der for-Schleife
15.3 Eigenen Iterator erzeugen
15.3.1 Beispiel einer Iteratorklasse
15.4 Generatoren und Generatorfunktionen
15.4.1 Unendliche Generatoren
15.5 Endlos-Generatoren zähmen mit firstn und islice
15.6 Beispiele aus der Kombinatorik
15.6.1 Permutationen
15.6.2 Variationen und Kombinationen
15.7 Generator-Ausdrücke..
15.8 yield from
15.9 return-Anweisungen in Generatoren
15.10 send-Methode
15.10.1 Arbeitsweise
15.10.2 Umprogrammierung mittels send
15.10.3 Radio-Beispiel mit send
15.11 Die close-Methode
15.12 Die throw-Methode
15.13 Dekoration von Generatoren
15.14 Aufgaben
16 Iteratoren der Standardbibliothek
16.1 Einführung
16.2 Wichtige Iteratoren und iteratorähnliche Funktionen in der Python-Standardbibliothek
16.3 enumerate
16.4 map, filter und reduce
16.4.1 map
16.4.2 Filtern von sequentiellen Datentypen mittels „filter“
16.4.3 reduce
16.4.4 Zusammenspiel von map, filter und reduce
16.5 Listen-Abstraktion
16.5.1 Alternative zu map und filter
16.5.2 Syntax
16.5.3 Weitere Beispiele
16.5.4 Die zugrunde liegende Idee
16.5.5 Anspruchsvolleres Beispiel
16.5.6 Mengen-Abstraktion
16.5.7 Generatoren-Abstraktion
16.5.8 map und filter oder Listen-Abstraktion
16.5.9 Dict-Komprehension in Python
16.6 reversed
16.7 Die zip-Funktion
16.8 zip in Kombination mit map und filter
16.9 Aufgaben
17 Das Modul itertools
17.1 Übersicht
17.2 Unendliche Iteratoren
17.2.1 itertools.count
17.2.1.1 Beispiel: Teilbarkeit
17.2.1.2 Beispiel: Quadratpolynome
17.2.1.3 Beispiel: Bestellungsmanager
17.2.2 chain und chain.from_iterable
17.2.3 cycle
17.2.4 tee
17.2.4.1 Effiziente Implementierung von cycle
17.2.4.2 Beispiel: Aufgaben und Mitarbeiter
17.2.5 repeat
17.3 Iteratoren über endliche Sequenzen
17.3.1 slice und islice
17.3.1.1 slice
17.3.1.2 islice
17.3.1.3 slice und islice im Vergleich
17.3.2 accumulate
17.3.2.1 Praktisches Börsenbeispiel
17.3.3 compress
17.3.3.1 Einführung
17.3.3.2 Umfangreiches Beispiel
17.3.4 dropwhile
17.3.5 takewhile
17.3.6 filterfalse
17.3.7 groupby
17.3.8 pairwise
17.3.9 n_grams und map_n
17.3.10 zip_longest
17.3.11 starmap
17.4 Kombinatorische Generatoren
17.4.1 product
17.4.2 permutations
17.4.3 combinations
17.4.3.1 Arbeitsweise
17.4.3.2 Beispiel: Speisekartengenerierung
17.4.3.3 Beispiel: Benachbarte Kantengraphen
17.4.4 combinations_with_replacement
17.4.5 Umfangreiches praktisches Beispiel: csv-Datei lesen
17.5 Aufgaben
Teil IV Lösungen zu den Aufgaben
18 Lösungen zu den Aufgaben
18.1 Lösungen zu Abschnitt 8.9 (Funktionen als Erste-Klasse-Objekte)
18.2 Lösungen zu Abschnitt 8.3 (Dataclasses und Pattern Matching)
18.3 Lösungen zu Abschnitt 8.5 (lambda)
18.4 Lösungen zu Abschnitt 8.7 (Rekursive Funktionen)
18.5 Lösungen zu Abschnitt 8.9 (Funktionen als Erste-Klasse-Objekte)
18.6 Lösungen zu Kapitel 9 (Dekoratoren)
18.7 Lösungen zu Kapitel 10 (Memoisation)
18.8 Lösungen zu Kapitel 11 (Closures)
18.9 Lösungen zu Kapitel 16 (Iteratoren der Standardbibliothek)
18.10 Lösungen zu Abschnitt 16.5 (Listen-Abstraktion)
18.11 Lösungen zu Kapitel 15 (Generatoren und Iteratoren)
18.12 Lösungen zu Kapitel 17 (Das Modul itertools)
18.13 Lösungen zu Kapitel 12 (Komposition von Funktionen)
18.14 Lösungen zu Kapitel 13 (Currying in Python)
18.15 Lösungen zu Kapitel 14 (Funktionale Emulation von OOP-Konzepten)
Willkommen zu unserem Buch über funktionale Programmierung in Python. In einer Welt, die zunehmend von datengetriebenen Entscheidungen und komplexen Systemen geprägt ist, wird die Fähigkeit immer wichtiger, robuste und elegante Software zu entwickeln. Dieses Buch bietet eine fundierte Einführung in die funktionale Programmierung unter Python, ein Paradigma, das eine andere Herangehensweise an das Programmieren bietet und helfen kann, Probleme auf eine klarere und effizientere Weise zu lösen.
Obwohl Python keine rein funktionale Sprache ist, bietet sie eine Vielzahl von funktionalen Werkzeugen und Konzepten, die es wert sind, erkundet zu werden. Dieses Buch ist darauf ausgelegt, die Prinzipien und die Möglichkeiten der funktionalen Programmierung unter Python aufzuzeigen und zu demonstrieren, wie man diese Prinzipien effektiv in der Praxis anwenden kann. Neben theoretischen Erklärungen legen wir großen Wert auf praktische Anwendungen, um das Gelernte direkt umzusetzen. Jedes Kapitel enthält praktische Beispiele und Aufgaben, um die erlernten Fähigkeiten weiterzuentwickeln und die Kenntnisse zu vertiefen.
Dieses Buch richtet sich sowohl an erfahrene Programmierer aus anderen Programmiersprachen, die ihre Kenntnisse in Python und funktionaler Programmierung erweitern möchten, als auch an Anfänger mit geringen Kenntnissen in Python, die ein neues Paradigma kennenlernen wollen.
Viel Erfolg und Freude beim Lesen des Buches und beim Ausprobieren der zahlreichen Beispiele und Aufgaben!
Ein Buch entsteht über einen langen Zeitraum und ist das Ergebnis der gemeinsamen Anstrengung vieler engagierter Menschen. Neben den Autoren, die den wesentlichen Beitrag leisten, sind auch zahlreiche andere Personen direkt oder indirekt an der Entstehung beteiligt. Unser besonderer Dank gilt Karola und Melisa, die die zusätzliche Belastung mit großem Verständnis und Geduld getragen haben.
Ein solches Werk wäre ohne die Unterstützung eines gut funktionierenden und anerkannten Verlages nicht möglich. Deshalb möchten wir uns herzlich beim Hanser Verlag bedanken, der uns die Gelegenheit gegeben hat, dieses Buch zu veröffentlichen. Unser besonderer Dank gilt Frau Brigitte Bauer-Schiewek und Frau Kristin Rothe für ihre kontinuierliche und hervorragende Unterstützung sowie ihr unermüdliches Engagement, das dieses Projekt maßgeblich vorangebracht hat.
Ein weiterer Dank gilt den zahlreichen Teilnehmerinnen und Teilnehmern unserer Python-Kurse, deren Fragen, Anregungen und Rückmeldungen uns geholfen haben, unsere didaktischen und fachlichen Fähigkeiten stetig weiterzuentwickeln – Fähigkeiten, die beim Verfassen dieses Buches von unschätzbarem Wert waren. Ein besonderer Dank geht zudem an die Besucherinnen und Besucher unserer Online-Tutorials auf www.python-kurs.eu und www.python-course.eu, insbesondere an diejenigen, die uns durch konstruktive Anmerkungen und wertvolles Feedback unterstützt haben.
Wir möchten auch Herrn Jürgen Dubau für das hervorragende Lektorat danken, das wesentlich zur sprachlichen Klarheit und Präzision dieses Werkes beigetragen hat. Ebenso gebührt unser Dank Herrn Stephan Korell und Frau Irene Weilhart für ihre wertvolle Unterstützung bei der Umsetzung in LaTeX. Ihre Expertise und Sorgfalt haben die technische Umsetzung dieses Buches erheblich erleichtert.
Abschließend möchten wir all jenen danken, die durch ihre kritischen Anmerkungen, ihr Lob und ihre Unterstützung dazu beigetragen haben, dass dieses Buch in seiner jetzigen Form entstehen konnte. Ihre Beiträge sind für uns von unschätzbarem Wert.
Bernd Klein, SingenPhilip Klein, Freiburg
August 2024
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.2Zielsetzung des BuchesDieses 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.3Aufbau des BuchesDas 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 collections in Python ist wichtig, weil es erweiterte Datenstrukturen wie deque, defaultdict, Counter und namedtuple 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 collections die Arbeit mit unveränderlichen und strukturierten Daten, indem es z. B. namedtuple bereitstellt, um benannte und unveränderliche Datentypen zu erstellen. Außerdem bietet Counter 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 yield 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 zip, enumerate, map, filter, reduce, 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 itertools 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 itertools-Bibliothek in Python bietet vielseitige Funktionen für die Arbeit mit Iterationen. Zu den wichtigsten gehören unendliche Iteratoren wie count, cycle und repeat, die unendlich lange Sequenzen erzeugen. Endliche Kombinations- und Permutations-Iteratoren wie chain, product, permutations und combinations ermöglichen die Erzeugung komplexer Kombinationen und Anordnungen von Daten. Zudem bietet itertools leistungsfähige Filter- und Mapping-Tools wie starmap, takewhile, dropwhile und accumulate, die es ermöglichen, Sequenzen nach bestimmten Kriterien zu filtern und zu transformieren. Insgesamt erleichtert itertools die effiziente und speicherschonende Verarbeitung von Daten.
3.4LeserschaftAuch 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 Sprachen wie C, C++, C#, JavaScript oder Java, die die funktionale Denkweise und die Programmierung in Python erlernen möchten. Es vermittelt sowohl das notwendige theoretische Wissen als auch praktische Fähigkeiten, um die Prinzipien der funktionalen Programmierung erfolgreich in der Praxis anzuwenden.
Letztlich ist es jedoch immer eine individuelle Entscheidung, ob ein Buch für jemanden geeignet ist oder nicht. Kein Buch kann für jeden „ideal“ sein. Wir sind jedoch überzeugt, dass dieses Buch für viele Programmierende und Studierende neue Perspektiven eröffnen und ihren Programmierhorizont erheblich erweitern kann.
3.5Zusätzliche UnterlagenAuf unserer Webseite https://python-kurs.eu/funktional stellen wir die Beispiele und Lösungen als Jupyter-Notebooks zur Verfügung. Denn was nutzt das beste Buch, wenn man den Code der Programme nicht zur Verfügung hat und mühsam eintippen muss, um Beispiele und Aufgaben nachvollziehen zu können? Deshalb haben wir uns entschieden, Jupyter-Notebooks mit Programmcode online zur Verfügung zu stellen.
Mithilfe von Kontrollstrukturen legen Programmierende fest, in welcher Reihenfolge die Handlungsschritte eines Algorithmus abgearbeitet werden sollen. In imperativen Programmiersprachen werden sie mithilfe von Kontrollanweisungen, auch als Steuerkonstrukte bekannt, implementiert. Diese Strukturen ermöglichen es Programmen, flexibel auf verschiedene Zustände zu reagieren, indem bestimmte Programmteile nur unter Bedingungen (bedingte Anweisungen) oder wiederholt (Schleifen) ausgeführt werden.
In der funktionalen Programmierung liegt der Schwerpunkt jedoch weniger auf Kontrollstrukturen wie if-Anweisungen und Schleifen, sondern eher auf der Verwendung von Funktionen und Datenmanipulationstechniken wie Filtern, Map und Reduce. Anstatt den Programmfluss direkt zu steuern, werden in funktionalen Programmiersprachen oft höhere Abstraktionsebenen verwendet, um Bedingungen und Iterationen auszudrücken. Das ermöglicht eine klarere und oft elegantere Darstellung von Algorithmen, da sie sich auf die Transformation von Daten konzentrieren, ohne sich um den Zustand oder den Programmfluss kümmern zu müssen.
Sequenz: Anweisungen werden linear ausgeführt. Es ist der einfachste Kontrollfluss, bei dem eine Aktion nach der anderen abgearbeitet wird.
Blockstruktur: Mehrere Anweisungen werden in einem Block gruppiert. Diese werden in Python durch Einrückungen erzeugt, aber nur in Verbindung mit anderen Strukturen wie Verzweigungen, Schleifen und so weiter.
Bedingte Anweisung und Verzweigung: Hier werden Anweisungen oder Anweisungsfolgen nur unter bestimmten Bedingungen ausgeführt. Das ermöglicht es, verschiedene Pfade im Code zu nehmen, je nachdem, ob eine Bedingung erfüllt ist oder nicht.
Schleife oder Iteration: Anweisungen werden wiederholt ausgeführt, solange eine bestimmte Bedingung erfüllt ist. Das ist besonders nützlich, um denselben Codeblock mehrmals auszuführen.
