Max
452 lines
11 KiB
Plaintext
452 lines
11 KiB
Plaintext
{
|
|
"cells": [
|
|
{
|
|
"metadata": {
|
|
"collapsed": true
|
|
},
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"# Funktionale Programmierung in Python\n",
|
|
"\n",
|
|
"## Ziel dieser Einheit\n",
|
|
"\n",
|
|
"In dieser Einheit lernst du:\n",
|
|
"\n",
|
|
"- was funktionale Programmierung bedeutet\n",
|
|
"- wie Lambda-Ausdrücke in Python funktionieren\n",
|
|
"- wie filter() verwendet wird\n",
|
|
"- wie map() verwendet wird\n",
|
|
"- wie mehrere funktionale Operationen kombiniert werden\n",
|
|
"- wie List Comprehensions als pythonische Alternative funktionieren"
|
|
],
|
|
"id": "aba2c4fa1f75f62d"
|
|
},
|
|
{
|
|
"metadata": {},
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"## 1. Grundidee der funktionalen Programmierung\n",
|
|
"\n",
|
|
"Funktionale Programmierung bedeutet:\n",
|
|
"\n",
|
|
"- Wir verändern Daten nicht direkt\n",
|
|
"- Wir benutzen Funktionen, um neue Daten zu erzeugen\n",
|
|
"- Häufig genutzte Funktionen sind:\n",
|
|
" - filter() → filtern\n",
|
|
" - map() → umwandeln\n",
|
|
" - sum() → berechnen\n",
|
|
"\n",
|
|
"In diesem Beispiel arbeiten wir mit einer Liste von Zahlen."
|
|
],
|
|
"id": "5fe9a211e4e1f290"
|
|
},
|
|
{
|
|
"metadata": {},
|
|
"cell_type": "code",
|
|
"source": "zahlen = [1, 2, 3, 4, 5, 6]",
|
|
"id": "eb8147e500b5876e",
|
|
"outputs": [],
|
|
"execution_count": null
|
|
},
|
|
{
|
|
"metadata": {},
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"\n",
|
|
"Die ursprüngliche Liste bleibt dabei unverändert.\n",
|
|
"Stattdessen erzeugen wir neue Listen mit den gewünschten Ergebnissen."
|
|
],
|
|
"id": "ce47b4e7ceac7b2b"
|
|
},
|
|
{
|
|
"metadata": {},
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"## 2. Lambda-Ausdrücke\n",
|
|
"\n",
|
|
"Ein Lambda-Ausdruck ist eine kurze, anonyme Funktion.\n",
|
|
"\n",
|
|
"Anonym bedeutet:\n",
|
|
"\n",
|
|
"- die Funktion hat keinen eigenen Namen\n",
|
|
"- sie wird direkt dort definiert, wo sie gebraucht wird\n",
|
|
"\n",
|
|
"Beispiel:"
|
|
],
|
|
"id": "308f2ba46c30f8bd"
|
|
},
|
|
{
|
|
"metadata": {},
|
|
"cell_type": "code",
|
|
"source": "lambda x: x % 2 == 0",
|
|
"id": "36ecb9f8790e3ef3",
|
|
"outputs": [],
|
|
"execution_count": null
|
|
},
|
|
{
|
|
"metadata": {},
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"\n",
|
|
"Bedeutung:\n",
|
|
"\n",
|
|
"- x ist die Variable für die Funktion\n",
|
|
"- x % 2 == 0 prüft, ob eine Zahl gerade ist\n",
|
|
"- das Ergebnis ist True oder False\n",
|
|
"\n",
|
|
"Vergleich mit Java:\n",
|
|
"\n",
|
|
" (x) -> x % 2 == 0\n",
|
|
"\n",
|
|
"In Java würde ein ähnlicher Lambda-Ausdruck also mit Pfeil geschrieben werden."
|
|
],
|
|
"id": "ab7b62549d06d131"
|
|
},
|
|
{
|
|
"metadata": {},
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"## 3. Filtern mit filter()\n",
|
|
"\n",
|
|
"Zuerst sollen nur die geraden Zahlen aus der Liste ausgewählt werden."
|
|
],
|
|
"id": "4f313a6ccf2b179e"
|
|
},
|
|
{
|
|
"metadata": {
|
|
"ExecuteTime": {
|
|
"end_time": "2026-07-22T08:15:25.729179Z",
|
|
"start_time": "2026-07-22T08:15:25.652826100Z"
|
|
}
|
|
},
|
|
"cell_type": "code",
|
|
"source": [
|
|
"gerade_zahlen = list(filter(lambda x: x % 2 == 0, zahlen))\n",
|
|
"\n",
|
|
"print(\"Gerade Zahlen:\", gerade_zahlen)"
|
|
],
|
|
"id": "405e64898d7dd020",
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"Gerade Zahlen: [2, 4, 6]\n"
|
|
]
|
|
}
|
|
],
|
|
"execution_count": 10
|
|
},
|
|
{
|
|
"metadata": {},
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"\n",
|
|
"\n",
|
|
"Erklärung:\n",
|
|
"\n",
|
|
"- filter() bekommt eine Funktion und eine Liste\n",
|
|
"- die Funktion prüft jedes Element\n",
|
|
"- nur Elemente, bei denen die Funktion True zurückgibt, bleiben erhalten\n",
|
|
"- list() wandelt das Ergebnis wieder in eine Liste um\n",
|
|
"\n",
|
|
"In diesem Beispiel prüft:\n",
|
|
"\n",
|
|
" lambda x: x % 2 == 0\n",
|
|
"\n",
|
|
"ob eine Zahl gerade ist.\n",
|
|
"\n",
|
|
"Aus der Liste:\n",
|
|
"\n",
|
|
" [1, 2, 3, 4, 5, 6]\n",
|
|
"\n",
|
|
"wird dadurch:\n",
|
|
"\n",
|
|
" [2, 4, 6]"
|
|
],
|
|
"id": "a7786217eb1ebd0f"
|
|
},
|
|
{
|
|
"metadata": {},
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"### Aufgabe zur Übung\n",
|
|
"Eine Liste mit den Zahlen von 1 bis 100 so filtern, dass alle Zahlen ausgegeben werden, die durch 12 oder 17 teilbar sind"
|
|
],
|
|
"id": "10bddadd2af9878"
|
|
},
|
|
{
|
|
"metadata": {},
|
|
"cell_type": "code",
|
|
"source": [
|
|
"zahlen_liste = []\n",
|
|
"for i in range (1, 101):\n",
|
|
" zahlen_liste.append(i)\n",
|
|
"\n",
|
|
"durch_12_oder_17_teilbar = list(filter(lambda x: x % 12 == 0 or x % 17 == 0, zahlen_liste))\n",
|
|
"print(durch_12_oder_17_teilbar)"
|
|
],
|
|
"id": "a06029e472a8f213",
|
|
"outputs": [],
|
|
"execution_count": null
|
|
},
|
|
{
|
|
"metadata": {},
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"## 4. Umwandeln mit map()\n",
|
|
"\n",
|
|
"Als nächstes sollen alle Zahlen quadriert werden."
|
|
],
|
|
"id": "84ceeb61fc5b523a"
|
|
},
|
|
{
|
|
"metadata": {},
|
|
"cell_type": "code",
|
|
"source": [
|
|
"quadriere = lambda x: x * x\n",
|
|
"\n",
|
|
"quadrate = list(\n",
|
|
" map(quadriere, zahlen)\n",
|
|
")\n",
|
|
"\n",
|
|
"print(\"Quadrate:\", quadrate)"
|
|
],
|
|
"id": "5789adc3dd4af6f8",
|
|
"outputs": [],
|
|
"execution_count": null
|
|
},
|
|
{
|
|
"metadata": {},
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"\n",
|
|
"\n",
|
|
"Erklärung:\n",
|
|
"\n",
|
|
"- map() wendet eine Funktion auf jedes Element an\n",
|
|
"- hier wird jede Zahl mit sich selbst multipliziert\n",
|
|
"- dadurch entsteht eine neue Liste mit den Quadraten\n",
|
|
"\n",
|
|
"Die Funktion:\n",
|
|
"\n",
|
|
" lambda x: x * x\n",
|
|
"\n",
|
|
"berechnet für jede Zahl ihr Quadrat.\n",
|
|
"\n",
|
|
"Aus:\n",
|
|
"\n",
|
|
" [1, 2, 3, 4, 5, 6]\n",
|
|
"\n",
|
|
"wird:\n",
|
|
"\n",
|
|
" [1, 4, 9, 16, 25, 36]"
|
|
],
|
|
"id": "7210ac5691299df5"
|
|
},
|
|
{
|
|
"metadata": {},
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"### Aufgabe zur Übung\n",
|
|
"Eine Map erstellen, die jede Zahl in einer Liste mit drei multipliziert:"
|
|
],
|
|
"id": "2885e847dce66b9b"
|
|
},
|
|
{
|
|
"metadata": {},
|
|
"cell_type": "code",
|
|
"source": [
|
|
"multipliziere_mit_drei = lambda x: 3 * x\n",
|
|
"\n",
|
|
"zahlen_mal_drei = list(map(multipliziere_mit_drei, zahlen))\n",
|
|
"print(zahlen_mal_drei)"
|
|
],
|
|
"id": "a327676c343bd9b1",
|
|
"outputs": [],
|
|
"execution_count": null
|
|
},
|
|
{
|
|
"metadata": {},
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"## 5. Kombinieren von filter() und map()\n",
|
|
"\n",
|
|
"Funktionale Operationen können kombiniert werden.\n",
|
|
"\n",
|
|
"In diesem Beispiel sollen zuerst nur die geraden Zahlen gefiltert und danach quadriert werden."
|
|
],
|
|
"id": "ac187b86ff0d3bc5"
|
|
},
|
|
{
|
|
"metadata": {},
|
|
"cell_type": "code",
|
|
"source": [
|
|
"ergebnis = list(\n",
|
|
" map(\n",
|
|
" lambda x: x * x,\n",
|
|
" filter(lambda x: x % 2 == 0, zahlen)\n",
|
|
" )\n",
|
|
")\n",
|
|
"\n",
|
|
"print(\"Quadrate der geraden Zahlen:\", ergebnis)"
|
|
],
|
|
"id": "5c41c5c137fa4b65",
|
|
"outputs": [],
|
|
"execution_count": null
|
|
},
|
|
{
|
|
"metadata": {},
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"\n",
|
|
"\n",
|
|
"Ablauf:\n",
|
|
"\n",
|
|
"1. filter() wählt nur gerade Zahlen aus\n",
|
|
"2. map() quadriert diese Zahlen\n",
|
|
"3. list() erzeugt daraus eine Liste\n",
|
|
"\n",
|
|
"Zwischenschritt:\n",
|
|
"\n",
|
|
" filter(lambda x: x % 2 == 0, zahlen)\n",
|
|
"\n",
|
|
"ergibt:\n",
|
|
"\n",
|
|
" [2, 4, 6]\n",
|
|
"\n",
|
|
"Danach wird mit map() quadriert:\n",
|
|
"\n",
|
|
" [4, 16, 36]\n",
|
|
"\n",
|
|
"## 6. Python-typische Schreibweise: List Comprehension\n",
|
|
"\n",
|
|
"Die gleiche Aufgabe kann in Python auch mit einer List Comprehension geschrieben werden."
|
|
],
|
|
"id": "1c43c327479ca804"
|
|
},
|
|
{
|
|
"metadata": {},
|
|
"cell_type": "code",
|
|
"source": [
|
|
"ergebnis_comp = [x * x for x in zahlen if x % 2 == 0]\n",
|
|
"\n",
|
|
"print(\"Mit List Comprehension:\", ergebnis_comp)"
|
|
],
|
|
"id": "a80de265be2ebfa5",
|
|
"outputs": [],
|
|
"execution_count": null
|
|
},
|
|
{
|
|
"metadata": {},
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"\n",
|
|
"\n",
|
|
"Erklärung:\n",
|
|
"\n",
|
|
"- Das ist die pythonischere Variante\n",
|
|
"- sie ist oft besser lesbar als map() und filter()\n",
|
|
"- sie kombiniert Filtern und Umwandeln in einer Zeile\n",
|
|
"\n",
|
|
"Die Struktur lautet:\n",
|
|
"\n",
|
|
" neuer_wert for element in liste if bedingung\n",
|
|
"\n",
|
|
"In unserem Beispiel:\n",
|
|
"\n",
|
|
" x * x for x in zahlen if x % 2 == 0\n",
|
|
"\n",
|
|
"Bedeutung:\n",
|
|
"\n",
|
|
"- gehe durch alle Zahlen in zahlen\n",
|
|
"- verwende nur Zahlen, die gerade sind\n",
|
|
"- berechne für jede dieser Zahlen x * x\n",
|
|
"\n",
|
|
"Das Ergebnis ist wieder:\n",
|
|
"\n",
|
|
" [4, 16, 36]\n",
|
|
"\n",
|
|
"\n",
|
|
"## 7. Wichtige Konzepte im Überblick\n",
|
|
"\n",
|
|
"### Funktionale Programmierung\n",
|
|
"\n",
|
|
"Funktionale Programmierung beschreibt Berechnungen mit Funktionen.\n",
|
|
"\n",
|
|
"Die ursprünglichen Daten werden dabei möglichst nicht verändert.\n",
|
|
"Stattdessen werden neue Daten erzeugt.\n",
|
|
"\n",
|
|
"\n",
|
|
"### Lambda-Ausdruck\n",
|
|
"\n",
|
|
"Ein Lambda-Ausdruck ist eine kurze Funktion ohne Namen.\n",
|
|
"\n",
|
|
"Er eignet sich besonders für kleine Funktionen, die nur einmal gebraucht werden.\n",
|
|
"\n",
|
|
"\n",
|
|
"### filter()\n",
|
|
"\n",
|
|
"filter() wählt Elemente aus einer Sammlung aus.\n",
|
|
"\n",
|
|
"Die übergebene Funktion muss True oder False zurückgeben.\n",
|
|
"\n",
|
|
"\n",
|
|
"### map()\n",
|
|
"\n",
|
|
"map() wandelt jedes Element einer Sammlung um.\n",
|
|
"\n",
|
|
"Die übergebene Funktion bestimmt, wie jedes Element verändert wird.\n",
|
|
"\n",
|
|
"\n",
|
|
"### List Comprehension\n",
|
|
"\n",
|
|
"List Comprehensions sind eine typische Python-Schreibweise.\n",
|
|
"\n",
|
|
"Sie sind oft lesbarer als verschachtelte map()- und filter()-Aufrufe.\n",
|
|
"\n",
|
|
"\n",
|
|
"## Zusammenfassung\n",
|
|
"\n",
|
|
"- Funktionale Programmierung arbeitet mit Funktionen statt direkter Veränderung von Daten\n",
|
|
"- Lambda-Ausdrücke sind kurze anonyme Funktionen\n",
|
|
"- filter() filtert Elemente anhand einer Bedingung\n",
|
|
"- map() wandelt Elemente um\n",
|
|
"- map() und filter() können kombiniert werden\n",
|
|
"- List Comprehensions sind in Python oft die bevorzugte Schreibweise\n",
|
|
"\n",
|
|
"\n",
|
|
"## Verständnisfragen\n",
|
|
"\n",
|
|
"- Was ist ein Lambda-Ausdruck?\n",
|
|
"- Wofür wird filter() verwendet?\n",
|
|
"- Wofür wird map() verwendet?\n",
|
|
"- Warum wird list() um filter() oder map() geschrieben?\n",
|
|
"- Was ist der Vorteil einer List Comprehension?"
|
|
],
|
|
"id": "239738006efd56b5"
|
|
}
|
|
],
|
|
"metadata": {
|
|
"kernelspec": {
|
|
"display_name": "Python 3",
|
|
"language": "python",
|
|
"name": "python3"
|
|
},
|
|
"language_info": {
|
|
"codemirror_mode": {
|
|
"name": "ipython",
|
|
"version": 2
|
|
},
|
|
"file_extension": ".py",
|
|
"mimetype": "text/x-python",
|
|
"name": "python",
|
|
"nbconvert_exporter": "python",
|
|
"pygments_lexer": "ipython2",
|
|
"version": "2.7.6"
|
|
}
|
|
},
|
|
"nbformat": 4,
|
|
"nbformat_minor": 5
|
|
}
|