Unterricht Donnerstag

python/aufgaben_tag2.ipynb

@@ -188,7 +188,7 @@
     "\n",
     "        a: Author  # Typ-Hinweis\n",
     "        for a in authors:\n",
-    "             a.books.append(self)  # Füge allen übergebenen Authors das Book hinzu.\n",
+    "            a.books.append(self)  # Füge allen übergebenen Authors das Book hinzu.\n",
     "\n",
     "    @property\n",
     "    def title(self):\n",
@@ -353,12 +353,7 @@
    "id": "152f0dfd54408937"
   },
   {
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2026-07-22T06:07:02.682183793Z",
-     "start_time": "2026-07-22T06:07:02.631660938Z"
-    }
-   },
+   "metadata": {},
    "cell_type": "code",
    "source": [
     "class Artikel:\n",
@@ -375,7 +370,7 @@
    ],
    "id": "f876b667a5783072",
    "outputs": [],
-   "execution_count": 11
+   "execution_count": null
   },
   {
    "metadata": {},
@@ -384,12 +379,7 @@
    "id": "9b3dba2c6071ca86"
   },
   {
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2026-07-22T06:07:05.233159899Z",
-     "start_time": "2026-07-22T06:07:05.193137265Z"
-    }
-   },
+   "metadata": {},
    "cell_type": "code",
    "source": [
     "class WarenkorbItem:\n",
@@ -403,7 +393,7 @@
    ],
    "id": "1590b144e6e119a2",
    "outputs": [],
-   "execution_count": 12
+   "execution_count": null
   },
   {
    "metadata": {},
@@ -412,12 +402,7 @@
    "id": "26737f39f9902970"
   },
   {
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2026-07-22T06:07:07.653116857Z",
-     "start_time": "2026-07-22T06:07:07.603058901Z"
-    }
-   },
+   "metadata": {},
    "cell_type": "code",
    "source": [
     "class Warenkorb:\n",
@@ -458,15 +443,10 @@
    ],
    "id": "edcaca28fe6a6cb0",
    "outputs": [],
-   "execution_count": 13
+   "execution_count": null
   },
   {
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2026-07-22T06:07:10.299292598Z",
-     "start_time": "2026-07-22T06:07:10.195456640Z"
-    }
-   },
+   "metadata": {},
    "cell_type": "code",
    "source": [
     "apfel = Artikel(1, \"Apfel\", 1.00, 10)\n",
@@ -482,21 +462,8 @@
     "print(warenkorb.gesamtpreis)"
    ],
    "id": "769c973f4a9ec4a5",
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "11.0\n",
-      "True\n",
-      "16.5\n",
-      "False\n",
-      "True\n",
-      "0\n"
-     ]
-    }
-   ],
-   "execution_count": 14
+   "outputs": [],
+   "execution_count": null
   }
  ],
  "metadata": {

python/aufgaben_tag3.ipynb

@@ -0,0 +1,385 @@
+{
+ "cells": [
+  {
+   "metadata": {
+    "collapsed": true
+   },
+   "cell_type": "markdown",
+   "source": [
+    "# Aufgabe 1\n",
+    "## Aufgabenstellung\n",
+    "Ein Online-Shop hat eine Liste mit Produktpreisen.\n",
+    "\n",
+    "Beispiel: preise = [20, 55, 80, 30, 120]\n",
+    "\n",
+    "Produkte über 50 EUR erhalten 10% Rabatt.\n",
+    "\n",
+    "Schreiben Sie ein Programm, das mit Hilfe von Lamdba eine neue Liste mit reduzierten Preisen erstellt."
+   ],
+   "id": "897a5654dca6cca5"
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "## Bearbeitung\n",
+    "### Variante A"
+   ],
+   "id": "ee68cc8aef8a90e1"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "source": [
+    "from datetime import date\n",
+    "\n",
+    "preise = [20, 55, 80, 30, 120]\n",
+    "print(\"Originalpreis\")\n",
+    "print(preise)\n",
+    "\n",
+    "berechne_reduzierten_preis = lambda x: x * 0.9 if x > 50 else x\n",
+    "reduzierte_preise = list(map(berechne_reduzierten_preis, preise))\n",
+    "\n",
+    "print(\"Mit Rabatt\")\n",
+    "print(reduzierte_preise)"
+   ],
+   "id": "7992fb80d80b9a9d",
+   "outputs": [],
+   "execution_count": null
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "### Variante B",
+   "id": "79212ee1313a3dab"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "source": [
+    "preise = [20, 55, 80, 30, 120]\n",
+    "\n",
+    "format_preis = lambda x: f'{x:.2f} EUR'\n",
+    "\n",
+    "print(\"Originalpreis\")\n",
+    "print(list(map(format_preis, preise)))\n",
+    "\n",
+    "berechne_reduzierten_preis = lambda x: x * 0.9 if x > 50 else x\n",
+    "reduzierte_preise = list(map(berechne_reduzierten_preis, preise))\n",
+    "\n",
+    "print(\"Mit Rabatt\")\n",
+    "print(list(map(format_preis, reduzierte_preise)))"
+   ],
+   "id": "d0783086c8499ec",
+   "outputs": [],
+   "execution_count": null
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "# Aufgabe 2\n",
+    "## Aufgabenstellung\n",
+    "Schreibe ein Programm zur Verwaltung von Mitarbeitern.\n",
+    "\n",
+    "Jeder Mitarbeiter besitzt:\n",
+    "- Name\n",
+    "- Alter\n",
+    "- Abteilung\n",
+    "- Gehalt"
+   ],
+   "id": "35d95a33d0cfa30f"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "source": [
+    "from datetime import date\n",
+    "from dateutil.relativedelta import relativedelta"
+   ],
+   "id": "272c0dd3d94b644b",
+   "outputs": [],
+   "execution_count": null
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "source": [
+    "class Abteilung:\n",
+    "\n",
+    "    def __init__(self, name:str, *args):\n",
+    "        self.__name = name\n",
+    "        super().__init__(*args)\n",
+    "\n",
+    "    @property\n",
+    "    def name(self):\n",
+    "        return self.__name\n",
+    "\n",
+    "    def __str__(self):\n",
+    "        return self.name"
+   ],
+   "id": "90d84c95ac6ed431",
+   "outputs": [],
+   "execution_count": null
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "source": [
+    "class Mitarbeiter:\n",
+    "\n",
+    "    def __init__(self, name:str, geburtsdatum:date, abteilung:Abteilung, gehalt:float, *args):\n",
+    "        self.__name = name\n",
+    "        self.__geburtsdatum = geburtsdatum\n",
+    "        self.__abteilung = abteilung\n",
+    "        self.__gehalt = gehalt\n",
+    "        super().__init__(*args)\n",
+    "\n",
+    "    @property\n",
+    "    def name(self):\n",
+    "        return self.__name\n",
+    "\n",
+    "    @property\n",
+    "    def alter(self):\n",
+    "        return relativedelta(date.today(), self.__geburtsdatum).years\n",
+    "\n",
+    "    @property\n",
+    "    def gehalt(self):\n",
+    "        return self.__gehalt\n",
+    "\n",
+    "    @property\n",
+    "    def abteilung(self):\n",
+    "        return self.__abteilung\n",
+    "\n",
+    "    def __str__(self):\n",
+    "        return f\"{self.name}, geboren {self.__geburtsdatum} ({self.alter} Jahre alt) arbeitet in {self.abteilung} und verdient {self.gehalt:.2f} EUR.\""
+   ],
+   "id": "e75bd9332850f6fa",
+   "outputs": [],
+   "execution_count": null
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "\n",
+    "Erstelle mindestens 6 Mitarbeiter und speichere sie in einer Liste."
+   ],
+   "id": "80f0590dbc1f3eea"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "source": [
+    "it = Abteilung(\"IT-Abteilung\")\n",
+    "personal = Abteilung(\"Personalabteilung\")\n",
+    "vertrieb = Abteilung(\"Vertrieb\")\n",
+    "\n",
+    "mitarbeiter_list = [\n",
+    "    Mitarbeiter(\"Albert\", date(1970, 2, 22), personal, 1234.5),\n",
+    "    Mitarbeiter(\"Bert\", date(1980, 3, 11), it, 2345.6),\n",
+    "    Mitarbeiter(\"Camembert\", date(2008, 1, 15), it, 1234.5),\n",
+    "    Mitarbeiter(\"Dilbert\", date(2001, 2, 22), personal, 1234.5),\n",
+    "    Mitarbeiter(\"Elbert\", date(1999, 3, 11), it, 2345.6),\n",
+    "    Mitarbeiter(\"Filbert\", date(1968, 1, 15), it, 5234.5),\n",
+    "]"
+   ],
+   "id": "f54a24a33da9ef37",
+   "outputs": [],
+   "execution_count": null
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "\n",
+    "Das Programm soll anschließend:\n",
+    "\n",
+    "- Alle Mitarbeiter ausgeben."
+   ],
+   "id": "186cd3483d573698"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "source": [
+    "for mitarbeiter in mitarbeiter_list:\n",
+    "    print(mitarbeiter)"
+   ],
+   "id": "888cea3bcb830aed",
+   "outputs": [],
+   "execution_count": null
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "- Alle Mitarbeiter anzeigen, die älter als 30 Jahre sind.",
+   "id": "b29b20967f9c3ac7"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "source": [
+    "mitarbeiter_ueber_30 = list(filter(lambda x: x.alter > 30, mitarbeiter_list))\n",
+    "\n",
+    "for mitarbeiter in mitarbeiter_ueber_30:\n",
+    "    print(mitarbeiter)"
+   ],
+   "id": "1a992cb2a3092ae5",
+   "outputs": [],
+   "execution_count": null
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "- Das durchschnittliche Gehalt berechnen.",
+   "id": "aa7c0e7d3d25a806"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "source": [
+    "summe_gehalt = sum(list(map(lambda x : x.gehalt, mitarbeiter_list)))\n",
+    "durchschnitt_gehalt = summe_gehalt / len(mitarbeiter_list)\n",
+    "\n",
+    "print(durchschnitt_gehalt)"
+   ],
+   "id": "3d16715679dd9a23",
+   "outputs": [],
+   "execution_count": null
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "- Alle Mitarbeiter der IT-Abteilung ausgeben.",
+   "id": "7a99b3570a2444a3"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "source": [
+    "mitarbeiter_in_it = list(filter(lambda x: x.abteilung == it, mitarbeiter_list))\n",
+    "\n",
+    "for mitarbeiter in mitarbeiter_in_it:\n",
+    "    print(mitarbeiter)"
+   ],
+   "id": "bce2741c8f96e7eb",
+   "outputs": [],
+   "execution_count": null
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "- Die Namen aller Mitarbeiter in Großbuchstaben ausgeben.",
+   "id": "51d3d88f26dc87fa"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "source": [
+    "MITARBEITER_NAMEN = list(map(lambda x: x.name.upper(), mitarbeiter_list))\n",
+    "\n",
+    "print(MITARBEITER_NAMEN)"
+   ],
+   "id": "ceab8fc00992178",
+   "outputs": [],
+   "execution_count": null
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "- Alle Mitarbeiter ausgeben, deren Gehalt über 4000 € liegt.",
+   "id": "2909d6f2185cd42c"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "source": [
+    "mitarbeiter_gehalt_ueber_4000 = list(filter(lambda x:x.gehalt > 4000, mitarbeiter_list))\n",
+    "\n",
+    "for mitarbeiter in mitarbeiter_gehalt_ueber_4000:\n",
+    "    print(mitarbeiter)"
+   ],
+   "id": "c7653e3dd84adf1",
+   "outputs": [],
+   "execution_count": null
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "\n",
+    "### Zusatzaufgabe\n",
+    "Gib aus, welcher Mitarbeiter das höchste Gehalt besitzt."
+   ],
+   "id": "6c2a5da8a3ffbcea"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "source": [
+    "mitarbeiter_max_gehalt = mitarbeiter_list[0]\n",
+    "\n",
+    "for mitarbeiter in mitarbeiter_list:\n",
+    "    if mitarbeiter_max_gehalt.gehalt < mitarbeiter.gehalt:\n",
+    "        mitarbeiter_max_gehalt = mitarbeiter\n",
+    "\n",
+    "print(mitarbeiter_max_gehalt)\n"
+   ],
+   "id": "faaf607cc0508e17",
+   "outputs": [],
+   "execution_count": null
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "Alternative mit Lambda:",
+   "id": "13dba464d7ddd6af"
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2026-07-22T09:46:00.972621400Z",
+     "start_time": "2026-07-22T09:46:00.935546200Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "mitarbeiter_max_gehalt = max(mitarbeiter_list, key= lambda x: x.gehalt)\n",
+    "print(mitarbeiter_max_gehalt)"
+   ],
+   "id": "1946de57dee64b91",
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Filbert, geboren 1968-01-15 (58 Jahre alt) arbeitet in IT-Abteilung und verdient 5234.50 EUR.\n"
+     ]
+    }
+   ],
+   "execution_count": 9
+  }
+ ],
+ "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
+}

python/datei.csv

@@ -0,0 +1,2 @@
+Dies, ist, eine, CSV
+Dies, ist, eine, Zeile

python/lambda.ipynb

@@ -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
+}

python/markov.ipynb

@@ -0,0 +1,249 @@
+{
+ "cells": [
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "Diese Klasse stellt eine einfache Markov-Verkettung da, gewissermaßen den \"Urgroßvater\" moderner KI",
+   "id": "6c199494598c034d"
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "### Imports",
+   "id": "b0d957031c0d2044"
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2026-07-23T07:05:25.425471700Z",
+     "start_time": "2026-07-23T07:05:25.387973100Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "from pypdf import PdfReader\n",
+    "import random\n",
+    "import re #Regular Expression"
+   ],
+   "id": "65aa9dc8abd455f7",
+   "outputs": [],
+   "execution_count": 3
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "### Basisklasse für unser Sprachmodell:",
+   "id": "c53ec100d7edf47f"
+  },
+  {
+   "cell_type": "code",
+   "id": "initial_id",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2026-07-23T07:05:27.974021100Z",
+     "start_time": "2026-07-23T07:05:27.953033600Z"
+    }
+   },
+   "source": [
+    "class LanguageModel:\n",
+    "\n",
+    "    def __init__(self):\n",
+    "        self.text = \"\"\n",
+    "\n",
+    "        #Modell zum Speichern von Wortbeziehungen:\n",
+    "        self.model = {}\n",
+    "\n",
+    "    def load_text(self):\n",
+    "        raise NotImplementedError\n",
+    "\n",
+    "    def train(self):\n",
+    "        #Erzeugt ein Markov-Modell, das sich für jedes Wort merkt, welche Wörter danach kommen\n",
+    "        if not self.text:\n",
+    "            raise ValueError(\"Kein Text geladen\")\n",
+    "\n",
+    "        text = self.text.lower() #optional, da eine Markov-Verkettung Case Sensitive ist\n",
+    "\n",
+    "        #Satzzeichen entfernen, da diese sonst als Teil des Wortes gesehen werden. Dafür nutzen wir einen Regex:\n",
+    "        text = re.sub(r\"[^\\w\\s]\", \"\", text)\n",
+    "\n",
+    "        words = text.split() #Wandelt den Text in eine Liste aus Wörtern um\n",
+    "\n",
+    "        #Wortbeziehungen erzeugen:\n",
+    "        for i in range(len(words) -1):\n",
+    "            current_word = words[i]\n",
+    "            next_word = words[i+1]\n",
+    "\n",
+    "            if current_word not in self.model:\n",
+    "                self.model[current_word] = []\n",
+    "\n",
+    "            self.model[current_word].append(next_word)\n",
+    "            #[ameise][hat][ist][ist][schläft]\n",
+    "\n",
+    "\n",
+    "    def generate(self, start_word = None, length=50):\n",
+    "        if not self.model:\n",
+    "            raise ValueError(\"Modell wurde noch nicht trainiert.\")\n",
+    "\n",
+    "        if start_word == \"\":\n",
+    "            start_word = random.choice(list(self.model.keys()))\n",
+    "\n",
+    "        current_word = start_word.lower()\n",
+    "\n",
+    "        result= [current_word]\n",
+    "\n",
+    "        for _ in range(length):\n",
+    "\n",
+    "            if current_word not in self.model:\n",
+    "                print(\"Das angegebene Wort konnte nicht gefunden werden. Modell unzureichend trainiert.\")\n",
+    "                break\n",
+    "\n",
+    "            next_word = random.choice(\n",
+    "                self.model[current_word]\n",
+    "            )\n",
+    "\n",
+    "            result.append(next_word)\n",
+    "\n",
+    "            current_word = next_word\n",
+    "\n",
+    "\n",
+    "        return \" \".join(result)\n"
+   ],
+   "outputs": [],
+   "execution_count": 4
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2026-07-23T07:05:32.388260300Z",
+     "start_time": "2026-07-23T07:05:32.352749100Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "class PDFLanguageModel(LanguageModel):\n",
+    "\n",
+    "    def __init__(self, pdf_path):\n",
+    "        super().__init__()\n",
+    "\n",
+    "        self.pdf_path = pdf_path\n",
+    "\n",
+    "    def load_text(self):\n",
+    "        reader = PdfReader(self.pdf_path)\n",
+    "\n",
+    "        pages_text = []\n",
+    "\n",
+    "        for page in reader.pages:\n",
+    "            text = page.extract_text()\n",
+    "\n",
+    "            if text:\n",
+    "                pages_text.append(text)\n",
+    "\n",
+    "        self.text = \"\\n\".join(pages_text)\n"
+   ],
+   "id": "28c790fe8e837cac",
+   "outputs": [],
+   "execution_count": 5
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2026-07-23T07:15:57.810092400Z",
+     "start_time": "2026-07-23T07:15:57.762428Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "def loadAndTrain(path:str)->PDFLanguageModel:\n",
+    "    model = PDFLanguageModel(path)\n",
+    "\n",
+    "    model.load_text()\n",
+    "\n",
+    "    #Modell trainieren:\n",
+    "    model.train()\n",
+    "\n",
+    "    return model"
+   ],
+   "id": "fd0205251645f412",
+   "outputs": [],
+   "execution_count": 13
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2026-07-23T07:16:00.105290600Z",
+     "start_time": "2026-07-23T07:16:00.052151200Z"
+    }
+   },
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": 15,
+   "source": "model = loadAndTrain(\"loremipsum.pdf\")",
+   "id": "6dd267218f206e1a"
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2026-07-23T07:16:13.594166700Z",
+     "start_time": "2026-07-23T07:16:13.500158400Z"
+    }
+   },
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": 17,
+   "source": "model = loadAndTrain(\"KI-Baum.pdf\")",
+   "id": "cff84213cc7a22dc"
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2026-07-23T07:16:25.676998200Z",
+     "start_time": "2026-07-23T07:16:25.615333200Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "print(\"Hier ist unser generierter Text:\")\n",
+    "\n",
+    "text = model.generate(\n",
+    "    #Man könnte hier ein Wort vorgeben. Gibt man keines vor, wird zufällig eines ausgewählt.\n",
+    "    start_word=\"\"\n",
+    ")\n",
+    "\n",
+    "print(text)"
+   ],
+   "id": "39d177f9d1667428",
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hier ist unser generierter Text:\n",
+      "vor kunststoffbächen nur so weit mein schlafsand tropfte dadurch zu boden kein sicherer boden kein sicherer boden kein sicherer boden kein sicherer boden kein bodenständiges land auf dem entsorgung schicksal anheimfallend samt aller kinderkrankheiten bereits mit beiden beinen und ja da erschien am erscheinungstag an jedem baum zu land zu finden\n"
+     ]
+    }
+   ],
+   "execution_count": 18
+  }
+ ],
+ "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
+}

python/test.ipynb

@@ -0,0 +1,69 @@
+{
+ "cells": [
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "# Test",
+   "id": "5f992ca0ee06c01c"
+  },
+  {
+   "metadata": {
+    "collapsed": true,
+    "ExecuteTime": {
+     "end_time": "2026-07-22T08:14:47.152767500Z",
+     "start_time": "2026-07-22T08:14:47.121874300Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "a = 50\n",
+    "print(50)"
+   ],
+   "id": "cc6e758282212d7a",
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "50\n"
+     ]
+    }
+   ],
+   "execution_count": 1
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2026-07-22T08:15:04.685063100Z",
+     "start_time": "2026-07-22T08:15:04.670671300Z"
+    }
+   },
+   "cell_type": "code",
+   "source": "a = a + 10",
+   "id": "7359f0aee5a53934",
+   "outputs": [],
+   "execution_count": 2
+  }
+ ],
+ "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
+}