{
 "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
}