Unterricht Mittwoch
This commit is contained in:
Max
@@ -0,0 +1,451 @@
|
||||
{
|
||||
"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
|
||||
}
|
||||
Reference in New Issue
Block a user