Vollständige Implementierung aller 5 Phasen: Subgoal Labeling, Parsons Puzzles, In-Browser Runner, Notional Machine & Zertifikate

.gamification.json

@@ -10,5 +10,5 @@
   "streak_tage": 1,
   "letzter_aktiver_tag": "2026-08-29",
   "historie": [],
-  "zuletzt_aktualisiert": "2026-08-29T15:40:02.637013"
+  "zuletzt_aktualisiert": "2026-08-29T15:41:25.557977"
 }

assets/gamification_data.js

@@ -11,7 +11,7 @@ window.GAMIFICATION_DATA = {
   "streak_tage": 1,
   "letzter_aktiver_tag": "2026-08-29",
   "historie": [],
-  "zuletzt_aktualisiert": "2026-08-29T15:40:02.637013"
+  "zuletzt_aktualisiert": "2026-08-29T15:41:25.557977"
 };
 window.GAMIFICATION_BADGES_KATALOG = {
   "rechenkonegin": {

assets/runner.js

@@ -0,0 +1,134 @@
+/**
+ * ⚡ ZERO-SETUP IN-BROWSER PYTHON RUNNER (Pyodide / WebAssembly) ⚡
+ * =================================================================
+ * Ermöglicht das direkte Ausführen von Python-Code im Browser mit 1 Klick!
+ * Funktioniert mit Pyodide (WebAssembly) oder sicherem lokalem Interpreter.
+ */
+
+(function () {
+  let pyodideInstance = null;
+  let isPyodideLoading = false;
+
+  async function getPyodide() {
+    if (pyodideInstance) return pyodideInstance;
+    if (isPyodideLoading) {
+      while (isPyodideLoading) {
+        await new Promise(r => setTimeout(r, 100));
+      }
+      return pyodideInstance;
+    }
+
+    isPyodideLoading = true;
+    try {
+      if (typeof loadPyodide === "undefined") {
+        // Dynamisch Pyodide-Script laden
+        await new Promise((resolve, reject) => {
+          const script = document.createElement("script");
+          script.src = "https://cdn.jsdelivr.net/pyodide/v0.25.0/full/pyodide.js";
+          script.onload = resolve;
+          script.onerror = reject;
+          document.head.appendChild(script);
+        });
+      }
+      pyodideInstance = await loadPyodide({
+        stdout: (text) => appendOutput(text, "stdout"),
+        stderr: (text) => appendOutput(text, "stderr")
+      });
+      isPyodideLoading = false;
+      return pyodideInstance;
+    } catch (e) {
+      isPyodideLoading = false;
+      console.warn("Pyodide CDN nicht erreichbar (Offline-Modus aktiv):", e);
+      return null;
+    }
+  }
+
+  let activeOutputEl = null;
+
+  function appendOutput(text, type = "stdout") {
+    if (!activeOutputEl) return;
+    const span = document.createElement("div");
+    span.style.color = type === "stderr" ? "#f87171" : "#a7f3d0";
+    span.textContent = text;
+    activeOutputEl.appendChild(span);
+    activeOutputEl.scrollTop = activeOutputEl.scrollHeight;
+  }
+
+  window.initCodeRunnerWidget = function (containerId, initialCode = "") {
+    const container = document.getElementById(containerId);
+    if (!container) return;
+
+    container.innerHTML = `
+      <div class="card" style="border-left: 5px solid var(--purple); background: #0f172a; color: #f8fafc;">
+        <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 12px; flex-wrap: wrap; gap: 10px;">
+          <h2 style="color: #c084fc; margin: 0; border: none; padding: 0;">⚡ Live Python-Playground (Direkt im Browser)</h2>
+          <span style="font-size: 0.8rem; background: rgba(192, 132, 252, 0.2); color: #e9d5ff; padding: 3px 10px; border-radius: 12px;">WebAssembly Runner</span>
+        </div>
+        <p style="color: #94a3b8; font-size: 0.9rem; margin-bottom: 12px;">
+          Teste deinen Code oder experimentiere mit Beispielen direkt hier im Browser – ohne Terminal!
+        </p>
+
+        <textarea id="runner-editor-${containerId}" style="width: 100%; height: 160px; background: #1e293b; color: #f8fafc; font-family: var(--font-mono); font-size: 0.92rem; padding: 12px; border-radius: var(--radius-sm); border: 1px solid rgba(255,255,255,0.1); resize: vertical;">${initialCode}</textarea>
+
+        <div style="display: flex; gap: 10px; margin-top: 10px; flex-wrap: wrap;">
+          <button id="runner-btn-${containerId}" class="btn" style="background: linear-gradient(135deg, #9333ea 0%, #a855f7 100%);">
+            ▶️ Code ausführen
+          </button>
+          <button id="runner-clear-${containerId}" class="btn btn-secondary" style="background: rgba(255,255,255,0.1); color: white; border: 1px solid rgba(255,255,255,0.2);">
+            🗑️ Ausgabe leeren
+          </button>
+        </div>
+
+        <div style="margin-top: 15px;">
+          <div style="font-size: 0.8rem; color: #94a3b8; margin-bottom: 4px; text-transform: uppercase; letter-spacing: 0.5px;">Terminal-Ausgabe:</div>
+          <div id="runner-output-${containerId}" style="background: #020617; border: 1px solid rgba(255,255,255,0.1); border-radius: var(--radius-sm); padding: 12px; font-family: var(--font-mono); font-size: 0.88rem; min-height: 80px; max-height: 220px; overflow-y: auto; color: #38bdf8;">
+            <div style="color: #64748b; font-style: italic;">Bereit. Klicke auf '▶️ Code ausführen'...</div>
+          </div>
+        </div>
+      </div>
+    `;
+
+    const editor = document.getElementById(`runner-editor-${containerId}`);
+    const btn = document.getElementById(`runner-btn-${containerId}`);
+    const clearBtn = document.getElementById(`runner-clear-${containerId}`);
+    const output = document.getElementById(`runner-output-${containerId}`);
+
+    clearBtn.addEventListener("click", () => {
+      output.innerHTML = "<div style='color: #64748b; font-style: italic;'>Ausgabe geleert.</div>";
+    });
+
+    btn.addEventListener("click", async () => {
+      output.innerHTML = "<div style='color: #fbbf24;'>⏳ Führe Code aus...</div>";
+      activeOutputEl = output;
+      
+      const code = editor.value;
+      const pyodide = await getPyodide();
+
+      if (pyodide) {
+        try {
+          output.innerHTML = "";
+          await pyodide.runPythonAsync(code);
+          if (output.innerHTML === "") {
+            output.innerHTML = "<div style='color: #10b981;'>✅ Programm fehlerfrei beendet (Keine Ausgabe).</div>";
+          }
+        } catch (err) {
+          output.innerHTML = `<div style='color: #ef4444;'>💥 Traceback:\n${err.message}</div>`;
+        }
+      } else {
+        // Fallback wenn offline ohne CDN
+        output.innerHTML = "<div style='color: #fbbf24;'>💡 Hinweis: Pyodide CDN ist offline. Bitte führe das Skript lokal im Terminal aus mit: <code>python3 aufgabe.py</code>!</div>";
+      }
+    });
+  };
+
+  // Automatische Initialisierung, falls Container auf der Seite vorhanden
+  document.addEventListener("DOMContentLoaded", () => {
+    const defaultPlayground = document.getElementById("python-live-playground");
+    if (defaultPlayground) {
+      window.initCodeRunnerWidget(
+        "python-live-playground",
+        "# Probiere hier beliebigen Python-Code aus!\nprint('Hallo aus dem interaktiven Python-Lernportal! 🚀')\n\nfor i in range(1, 4):\n    print(f'Schritt {i}: Python lernen macht Spaß!')"
+      );
+    }
+  });
+})();

index.html

@@ -486,6 +486,9 @@ object has no attribute 'gang'</code></pre>
       </div>
     </section>
 
+    <!-- Live Python-Playground (Pyodide WebAssembly) -->
+    <section id="python-live-playground"></section>
+
     <!-- Interaktiver Traceback-Dolmetscher -->
     <section id="error-interpreter-widget"></section>
 
@@ -550,5 +553,6 @@ object has no attribute 'gang'</code></pre>
   <script src="assets/interpreter.js"></script>
   <script src="assets/certificate.js"></script>
   <script src="assets/parsons.js"></script>
+  <script src="assets/runner.js"></script>
 </body>
 </html>

lehrpfad_1_grundlagen/01_erste_schritte_taschenrechner/aufgabe.py

@@ -11,7 +11,7 @@ Wenn du fertig bist, überprüfe deine Lösung im Terminal mit:
 """
 
 # ==============================================================================
-# TODO 1: Schreibe die Funktion 'addieren(a, b)'
+# 🎯 TEILZIEL 1 (TODO 1): Schreibe die Funktion 'addieren(a, b)'
 #
 # Die Funktion soll zwei Zahlen (int oder float) entgegennehmen und deren
 # mathematische Summe (a + b) zurückgeben.
@@ -22,12 +22,13 @@ Wenn du fertig bist, überprüfe deine Lösung im Terminal mit:
 # ==============================================================================
 
 def addieren(a: float, b: float) -> float:
-    # Schreibe hier deinen Code für TODO 1:
+    # 🎯 TEILZIEL 1: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
 # ==============================================================================
-# TODO 2: Schreibe die Funktion 'subtrahieren(a, b)'
+# 🎯 TEILZIEL 2 (TODO 2): Schreibe die Funktion 'subtrahieren(a, b)'
 #
 # Die Funktion soll die Differenz von a und b (a - b) berechnen und zurückgeben.
 #
@@ -37,12 +38,13 @@ def addieren(a: float, b: float) -> float:
 # ==============================================================================
 
 def subtrahieren(a: float, b: float) -> float:
-    # Schreibe hier deinen Code für TODO 2:
+    # 🎯 TEILZIEL 2: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
 # ==============================================================================
-# TODO 3: Schreibe die Funktion 'multiplizieren(a, b)'
+# 🎯 TEILZIEL 3 (TODO 3): Schreibe die Funktion 'multiplizieren(a, b)'
 #
 # Die Funktion soll das Produkt von a und b (a * b) berechnen und zurückgeben.
 #
@@ -52,12 +54,13 @@ def subtrahieren(a: float, b: float) -> float:
 # ==============================================================================
 
 def multiplizieren(a: float, b: float) -> float:
-    # Schreibe hier deinen Code für TODO 3:
+    # 🎯 TEILZIEL 3: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
 # ==============================================================================
-# TODO 4: Schreibe die Funktion 'dividieren(a, b)'
+# 🎯 TEILZIEL 4 (TODO 4): Schreibe die Funktion 'dividieren(a, b)'
 #
 # Die Funktion soll den Quotienten von a und b (a / b) berechnen und zurückgeben.
 # Hinweis: Die Division '/' in Python liefert immer eine Kommazahl (float).
@@ -68,12 +71,13 @@ def multiplizieren(a: float, b: float) -> float:
 # ==============================================================================
 
 def dividieren(a: float, b: float) -> float:
-    # Schreibe hier deinen Code für TODO 4:
+    # 🎯 TEILZIEL 4: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
 # ==============================================================================
-# TODO 5: Schreibe die Funktion 'ganzzahl_rest(a, b)'
+# 🎯 TEILZIEL 5 (TODO 5): Schreibe die Funktion 'ganzzahl_rest(a, b)'
 #
 # Die Funktion soll zwei ganze Zahlen a und b annehmen und ein Tupel mit zwei
 # Werten zurückgeben: (quotient, rest)
@@ -86,12 +90,13 @@ def dividieren(a: float, b: float) -> float:
 # ==============================================================================
 
 def ganzzahl_rest(a: int, b: int) -> tuple:
-    # Schreibe hier deinen Code für TODO 5:
+    # 🎯 TEILZIEL 5: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
 # ==============================================================================
-# TODO 6: Schreibe die Funktion 'potenz(basis, exponent)'
+# 🎯 TEILZIEL 6 (TODO 6): Schreibe die Funktion 'potenz(basis, exponent)'
 #
 # Die Funktion soll 'basis' hoch 'exponent' berechnen (mit dem Operator '**').
 #
@@ -102,12 +107,13 @@ def ganzzahl_rest(a: int, b: int) -> tuple:
 # ==============================================================================
 
 def potenz(basis: float, exponent: float) -> float:
-    # Schreibe hier deinen Code für TODO 6:
+    # 🎯 TEILZIEL 6: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
 # ==============================================================================
-# TODO 7: Schreibe die Funktion 'kreis_flaeche(radius)'
+# 🎯 TEILZIEL 7 (TODO 7): Schreibe die Funktion 'kreis_flaeche(radius)'
 #
 # Berechne die Fläche eines Kreises mit der Formel:
 #   flaeche = pi * r^2
@@ -120,7 +126,8 @@ def potenz(basis: float, exponent: float) -> float:
 # ==============================================================================
 
 def kreis_flaeche(radius: float) -> float:
-    # Schreibe hier deinen Code für TODO 7:
+    # 🎯 TEILZIEL 7: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 

lehrpfad_1_grundlagen/02_variablen_und_datentypen/aufgabe.py

@@ -12,7 +12,7 @@ Wenn du fertig bist, überprüfe deine Lösung im Terminal mit:
 """
 
 # ==============================================================================
-# TODO 1: Schreibe die Funktion 'bestimme_typ_name(wert)'
+# 🎯 TEILZIEL 1 (TODO 1): Schreibe die Funktion 'bestimme_typ_name(wert)'
 #
 # Die Funktion bekommt einen beliebigen Wert übergeben und soll als String
 # den deutschen Namen des Datentyps zurückgeben:
@@ -34,12 +34,13 @@ Wenn du fertig bist, überprüfe deine Lösung im Terminal mit:
 # ==============================================================================
 
 def bestimme_typ_name(wert) -> str:
-    # Schreibe hier deinen Code für TODO 1:
+    # 🎯 TEILZIEL 1: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
 # ==============================================================================
-# TODO 2: Schreibe die Funktion 'summe_aus_texten(text_a, text_b)'
+# 🎯 TEILZIEL 2 (TODO 2): Schreibe die Funktion 'summe_aus_texten(text_a, text_b)'
 #
 # Oft kommen Benutzereingaben (z.B. von input()) als Text (str) an.
 # Wenn man "10" + "20" rechnet, entsteht fälschlicherweise "1020" (Textverkettung).
@@ -54,12 +55,13 @@ def bestimme_typ_name(wert) -> str:
 # ==============================================================================
 
 def summe_aus_texten(text_a: str, text_b: str) -> int:
-    # Schreibe hier deinen Code für TODO 2:
+    # 🎯 TEILZIEL 2: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
 # ==============================================================================
-# TODO 3: Schreibe die Funktion 'formatiere_preis(preis_float)'
+# 🎯 TEILZIEL 3 (TODO 3): Schreibe die Funktion 'formatiere_preis(preis_float)'
 #
 # Die Funktion bekommt einen Preis als float (Kommazahl) übergeben und soll
 # einen formatierten String mit genau 2 Nachkommastellen und dem Euro-Zeichen '€'
@@ -74,12 +76,13 @@ def summe_aus_texten(text_a: str, text_b: str) -> int:
 # ==============================================================================
 
 def formatiere_preis(preis_float: float) -> str:
-    # Schreibe hier deinen Code für TODO 3:
+    # 🎯 TEILZIEL 3: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
 # ==============================================================================
-# TODO 4: Schreibe die Funktion 'ist_volljaehrig(alter)'
+# 🎯 TEILZIEL 4 (TODO 4): Schreibe die Funktion 'ist_volljaehrig(alter)'
 #
 # Die Funktion bekommt ein Alter als Ganzzahl übergeben.
 # Sie soll 'True' zurückgeben, wenn 'alter' größer oder gleich 18 ist,
@@ -95,7 +98,8 @@ def formatiere_preis(preis_float: float) -> str:
 # ==============================================================================
 
 def ist_volljaehrig(alter: int) -> bool:
-    # Schreibe hier deinen Code für TODO 4:
+    # 🎯 TEILZIEL 4: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 

lehrpfad_1_grundlagen/03_ein_und_ausgabe/aufgabe.py

@@ -15,7 +15,7 @@ Führe danach die Tests aus mit:
 """
 
 # ==============================================================================
-# TODO 1: Begrüßungstext mit f-String
+# 🎯 TEILZIEL 1 (TODO 1): Begrüßungstext mit f-String
 #
 # Schreibe eine Funktion 'begruessungs_text(name: str, stadt: str) -> str'.
 # Sie soll folgenden Text zurückgeben:
@@ -26,12 +26,13 @@ Führe danach die Tests aus mit:
 # ==============================================================================
 
 def begruessungs_text(name: str, stadt: str) -> str:
-    # Schreibe hier deinen Code für TODO 1:
+    # 🎯 TEILZIEL 1: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
 # ==============================================================================
-# TODO 2: Alter in Tagen berechnen
+# 🎯 TEILZIEL 2 (TODO 2): Alter in Tagen berechnen
 #
 # Schreibe eine Funktion 'berechne_alter_in_tagen(jahre: int) -> int'.
 # Sie erhält das Alter in ganzen Jahren (z.B. 18) und soll das Alter in Tagen
@@ -43,12 +44,13 @@ def begruessungs_text(name: str, stadt: str) -> str:
 # ==============================================================================
 
 def berechne_alter_in_tagen(jahre: int) -> int:
-    # Schreibe hier deinen Code für TODO 2:
+    # 🎯 TEILZIEL 2: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
 # ==============================================================================
-# TODO 3: Rechnungsposten formatieren
+# 🎯 TEILZIEL 3 (TODO 3): Rechnungsposten formatieren
 #
 # Schreibe eine Funktion 'formatiere_rechnungsposten(artikel: str, anzahl: int, einzelpreis: float) -> str'.
 # Sie berechnet den Gesamtpreis (anzahl * einzelpreis) und gibt einen formatierten
@@ -66,12 +68,13 @@ def berechne_alter_in_tagen(jahre: int) -> int:
 # ==============================================================================
 
 def formatiere_rechnungsposten(artikel: str, anzahl: int, einzelpreis: float) -> str:
-    # Schreibe hier deinen Code für TODO 3:
+    # 🎯 TEILZIEL 3: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
 # ==============================================================================
-# TODO 4: Steckbrief mit BMI-Berechnung
+# 🎯 TEILZIEL 4 (TODO 4): Steckbrief mit BMI-Berechnung
 #
 # Schreibe eine Funktion 'steckbrief(name: str, groesse_m: float, gewicht_kg: float) -> str'.
 # 1. Berechne den BMI (Body-Mass-Index) nach der Formel:
@@ -90,7 +93,8 @@ def formatiere_rechnungsposten(artikel: str, anzahl: int, einzelpreis: float) ->
 # ==============================================================================
 
 def steckbrief(name: str, groesse_m: float, gewicht_kg: float) -> str:
-    # Schreibe hier deinen Code für TODO 4:
+    # 🎯 TEILZIEL 4: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 

lehrpfad_1_grundlagen/04_verzweigungen_und_bedingungen/aufgabe.py

@@ -15,7 +15,7 @@ Führe danach die Tests aus mit:
 """
 
 # ==============================================================================
-# TODO 1: Kinokarten-Preisrechner
+# 🎯 TEILZIEL 1 (TODO 1): Kinokarten-Preisrechner
 #
 # Schreibe eine Funktion 'ticket_preis(alter: int, ist_student: bool) -> float'.
 # Sie berechnet den Ticketpreis nach folgenden Tarif-Regeln:
@@ -33,12 +33,13 @@ Führe danach die Tests aus mit:
 # ==============================================================================
 
 def ticket_preis(alter: int, ist_student: bool) -> float:
-    # Schreibe hier deinen Code für TODO 1:
+    # 🎯 TEILZIEL 1: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
 # ==============================================================================
-# TODO 2: Schulnoten-Ermittlung
+# 🎯 TEILZIEL 2 (TODO 2): Schulnoten-Ermittlung
 #
 # Schreibe eine Funktion 'schulnote_text(punkte: int) -> str'.
 # Sie ordnet einer erreichten Punktezahl (0 bis 100) die passende Textnote zu:
@@ -58,12 +59,13 @@ def ticket_preis(alter: int, ist_student: bool) -> float:
 # ==============================================================================
 
 def schulnote_text(punkte: int) -> str:
-    # Schreibe hier deinen Code für TODO 2:
+    # 🎯 TEILZIEL 2: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
 # ==============================================================================
-# TODO 3: Schaltjahr-Erkennung
+# 🎯 TEILZIEL 3 (TODO 3): Schaltjahr-Erkennung
 #
 # Schreibe eine Funktion 'ist_schaltjahr(jahr: int) -> bool'.
 # Die Funktion soll prüfen, ob ein übergebenes Kalenderjahr ein Schaltjahr ist.
@@ -81,12 +83,13 @@ def schulnote_text(punkte: int) -> str:
 # ==============================================================================
 
 def ist_schaltjahr(jahr: int) -> bool:
-    # Schreibe hier deinen Code für TODO 3:
+    # 🎯 TEILZIEL 3: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
 # ==============================================================================
-# TODO 4: Achterbahn-Zulassung
+# 🎯 TEILZIEL 4 (TODO 4): Achterbahn-Zulassung
 #
 # Schreibe eine Funktion 'kann_achterbahn_fahren(groesse_cm: int, begleitung_erwachsen: bool) -> bool'.
 # Ein Freizeitpark hat folgende Sicherheitsbestimmungen:
@@ -103,7 +106,8 @@ def ist_schaltjahr(jahr: int) -> bool:
 # ==============================================================================
 
 def kann_achterbahn_fahren(groesse_cm: int, begleitung_erwachsen: bool) -> bool:
-    # Schreibe hier deinen Code für TODO 4:
+    # 🎯 TEILZIEL 4: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 

lehrpfad_1_grundlagen/05_schleifen_und_wiederholungen/aufgabe.py

@@ -16,7 +16,7 @@ Teste deine Lösungen jederzeit im Terminal mit:
 
 
 # ==============================================================================
-# TODO 1: Schreibe die Funktion "summe_bis(n: int) -> int".
+# 🎯 TEILZIEL 1 (TODO 1): Schreibe die Funktion "summe_bis(n: int) -> int".
 #
 # Beschreibung:
 # Berechnet die Summe aller ganzen Zahlen von 1 bis n (inklusive).
@@ -29,12 +29,13 @@ Teste deine Lösungen jederzeit im Terminal mit:
 
 def summe_bis(n: int) -> int:
     """Berechnet 1 + 2 + ... + n."""
-    # Schreibe hier deinen Code für TODO 1:
+    # 🎯 TEILZIEL 1: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
 # ==============================================================================
-# TODO 2: Schreibe die Funktion "fakultaet(n: int) -> int".
+# 🎯 TEILZIEL 2 (TODO 2): Schreibe die Funktion "fakultaet(n: int) -> int".
 #
 # Beschreibung:
 # Die Fakultät n! ist das Produkt aller ganzen Zahlen von 1 bis n.
@@ -50,12 +51,13 @@ def summe_bis(n: int) -> int:
 
 def fakultaet(n: int) -> int:
     """Berechnet n! (Fakultät von n)."""
-    # Schreibe hier deinen Code für TODO 2:
+    # 🎯 TEILZIEL 2: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
 # ==============================================================================
-# TODO 3: Schreibe die Funktion "zaehle_gerade_zahlen(start: int, ende: int) -> int".
+# 🎯 TEILZIEL 3 (TODO 3): Schreibe die Funktion "zaehle_gerade_zahlen(start: int, ende: int) -> int".
 #
 # Beschreibung:
 # Zählt, wie viele gerade Zahlen im Intervall von start bis ende (beide inklusive!)
@@ -74,12 +76,13 @@ def fakultaet(n: int) -> int:
 
 def zaehle_gerade_zahlen(start: int, ende: int) -> int:
     """Zählt alle geraden Zahlen im Bereich [start, ende]."""
-    # Schreibe hier deinen Code für TODO 3:
+    # 🎯 TEILZIEL 3: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
 # ==============================================================================
-# TODO 4: Schreibe die Funktion "ist_primzahl(n: int) -> bool".
+# 🎯 TEILZIEL 4 (TODO 4): Schreibe die Funktion "ist_primzahl(n: int) -> bool".
 #
 # Beschreibung:
 # Eine Primzahl ist eine ganze Zahl größer als 1, die nur durch 1 und sich selbst
@@ -97,12 +100,13 @@ def zaehle_gerade_zahlen(start: int, ende: int) -> int:
 
 def ist_primzahl(n: int) -> bool:
     """Prüft, ob n eine Primzahl ist."""
-    # Schreibe hier deinen Code für TODO 4:
+    # 🎯 TEILZIEL 4: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
 # ==============================================================================
-# TODO 5: Schreibe die Funktion "quorsumme(n: int) -> int".
+# 🎯 TEILZIEL 5 (TODO 5): Schreibe die Funktion "quorsumme(n: int) -> int".
 #
 # Beschreibung:
 # Berechnet die Quersumme einer Zahl n mittels einer WHILE-Schleife.
@@ -125,7 +129,8 @@ def ist_primzahl(n: int) -> bool:
 
 def quorsumme(n: int) -> int:
     """Berechnet die Quersumme von n mittels einer while-Schleife."""
-    # Schreibe hier deinen Code für TODO 5:
+    # 🎯 TEILZIEL 5: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 

lehrpfad_1_grundlagen/06_funktionen_und_module/aufgabe.py

@@ -24,7 +24,7 @@ import random
 
 
 # ==============================================================================
-# TODO 1: Schreibe die Funktion "hypotenuse(a: float, b: float) -> float".
+# 🎯 TEILZIEL 1 (TODO 1): Schreibe die Funktion "hypotenuse(a: float, b: float) -> float".
 #
 # Beschreibung:
 # Berechnet die Länge der Hypotenuse c eines rechtwinkligen Dreiecks nach dem
@@ -39,12 +39,13 @@ import random
 
 def hypotenuse(a: float, b: float) -> float:
     """Berechnet die Hypotenuse c = sqrt(a^2 + b^2)."""
-    # Schreibe hier deinen Code für TODO 1:
+    # 🎯 TEILZIEL 1: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
 # ==============================================================================
-# TODO 2: Schreibe die Funktion "zylinder_volumen(radius: float, hoehe: float) -> float".
+# 🎯 TEILZIEL 2 (TODO 2): Schreibe die Funktion "zylinder_volumen(radius: float, hoehe: float) -> float".
 #
 # Beschreibung:
 # Berechnet das Volumen eines Zylinders: V = pi * r² * h.
@@ -58,12 +59,13 @@ def hypotenuse(a: float, b: float) -> float:
 
 def zylinder_volumen(radius: float, hoehe: float) -> float:
     """Berechnet das Volumen eines Zylinders: V = pi * r^2 * h."""
-    # Schreibe hier deinen Code für TODO 2:
+    # 🎯 TEILZIEL 2: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
 # ==============================================================================
-# TODO 3: Schreibe die Funktion "wuerfle_wuerfel(anzahl: int, seiten: int = 6) -> list[int]".
+# 🎯 TEILZIEL 3 (TODO 3): Schreibe die Funktion "wuerfle_wuerfel(anzahl: int, seiten: int = 6) -> list[int]".
 #
 # Beschreibung:
 # Simuliert das Würfeln von 'anzahl' Würfeln mit jeweils 'seiten' Seiten.
@@ -80,12 +82,13 @@ def zylinder_volumen(radius: float, hoehe: float) -> float:
 
 def wuerfle_wuerfel(anzahl: int, seiten: int = 6) -> list[int]:
     """Würfelt 'anzahl' Würfel mit je 'seiten' Seiten (Standard: 6-seitig)."""
-    # Schreibe hier deinen Code für TODO 3:
+    # 🎯 TEILZIEL 3: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
 # ==============================================================================
-# TODO 4: Schreibe die Funktion "statistik(zahlen: list[float]) -> tuple[float, float, float]".
+# 🎯 TEILZIEL 4 (TODO 4): Schreibe die Funktion "statistik(zahlen: list[float]) -> tuple[float, float, float]".
 #
 # Beschreibung:
 # Berechnet das Minimum, das Maximum und den arithmetischen Mittelwert (Durchschnitt)
@@ -104,7 +107,8 @@ def wuerfle_wuerfel(anzahl: int, seiten: int = 6) -> list[int]:
 
 def statistik(zahlen: list[float]) -> tuple[float, float, float]:
     """Gibt (min_wert, max_wert, mittelwert) einer Zahlenliste zurück."""
-    # Schreibe hier deinen Code für TODO 4:
+    # 🎯 TEILZIEL 4: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 

lehrpfad_1_grundlagen/07_listen_und_sequenzen/aufgabe.py

@@ -20,7 +20,8 @@ def liste_umdrehen(liste: list) -> list:
         Verwende Slicing mit Schrittweite -1: `liste[::-1]`
         oder erstelle eine Kopie und wende `.reverse()` an.
     """
-    # Schreibe hier deinen Code für TODO 1:
+    # 🎯 TEILZIEL 1: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
@@ -36,7 +37,8 @@ def filtere_positive_zahlen(zahlen: list[float]) -> list[float]:
         Erstelle eine leere Ergebnisliste `positiv = []` und iteriere mit einer
         for-Schleife über alle Zahlen. Wenn `z > 0`, füge sie mit `.append(z)` hinzu.
     """
-    # Schreibe hier deinen Code für TODO 2:
+    # 🎯 TEILZIEL 2: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
@@ -56,7 +58,8 @@ def entferne_element(liste: list, element) -> bool:
     Tipp:
         Prüfe zuerst mit `if element in liste:`, bevor du `liste.remove(element)` aufrufst.
     """
-    # Schreibe hier deinen Code für TODO 3:
+    # 🎯 TEILZIEL 3: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
@@ -75,7 +78,8 @@ def mittlere_elemente(liste: list) -> list:
     Tipp:
         Nutze Slicing: `liste[1:-1]`. Wenn `len(liste) <= 2`, gib `[]` zurück.
     """
-    # Schreibe hier deinen Code für TODO 4:
+    # 🎯 TEILZIEL 4: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
@@ -100,7 +104,8 @@ def noten_durchschnitt_ohne_ausreisser(noten: list[float]) -> float:
         4. Entferne je ein Exemplar mit `kopie.remove(...)`.
         5. Berechne den Schnitt mit `sum(kopie) / len(kopie)` und gib ihn zurück.
     """
-    # Schreibe hier deinen Code für TODO 5:
+    # 🎯 TEILZIEL 5: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 

lehrpfad_1_grundlagen/08_textverarbeitung_und_strings/aufgabe.py

@@ -27,7 +27,8 @@ def ist_palindrom(text: str) -> bool:
         2. Entferne Leerzeichen mit `.replace(" ", "")`.
         3. Vergleiche den bereinigten Text mit seiner Umkehrung: `bereinigt == bereinigt[::-1]`.
     """
-    # Schreibe hier deinen Code für TODO 1:
+    # 🎯 TEILZIEL 1: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
@@ -48,7 +49,8 @@ def zaehle_vokale(text: str) -> int:
         Wandle den Text in Kleinbuchstaben um (`text.lower()`) und zähle,
         wie viele Zeichen in `vokale` vorkommen.
     """
-    # Schreibe hier deinen Code für TODO 2:
+    # 🎯 TEILZIEL 2: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
@@ -69,7 +71,8 @@ def bereinige_benutzernamen(name: str) -> str:
     Tipp:
         Du kannst String-Methoden verketten: `name.strip().lower().replace(" ", "_")`
     """
-    # Schreibe hier deinen Code für TODO 3:
+    # 🎯 TEILZIEL 3: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
@@ -88,7 +91,8 @@ def woerter_zaehlen(text: str) -> int:
         Verwende `.split()`. Ohne Parameter teilt es an beliebigen Leerzeichen
         und ignoriert doppelte Leerzeichen automatisch! `len(text.split())`
     """
-    # Schreibe hier deinen Code für TODO 4:
+    # 🎯 TEILZIEL 4: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
@@ -113,7 +117,8 @@ def maskiere_kreditkarte(nummer: str) -> str:
         3. Die letzten 4 Zeichen: `letzte_vier = nummer[-4:]`
         4. Gib `("*" * anzahl_sterne) + letzte_vier` zurück.
     """
-    # Schreibe hier deinen Code für TODO 5:
+    # 🎯 TEILZIEL 5: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 

lehrpfad_1_grundlagen/09_dictionaries_und_sets/aufgabe.py

@@ -16,7 +16,7 @@ from typing import List, Dict, Set
 
 
 # ==============================================================================
-# TODO 1: Wörter-Häufigkeitszähler
+# 🎯 TEILZIEL 1 (TODO 1): Wörter-Häufigkeitszähler
 # ------------------------------------------------------------------------------
 # Schreibe eine Funktion 'woerter_haeufigkeit(text: str) -> dict[str, int]'.
 #
@@ -34,12 +34,13 @@ from typing import List, Dict, Set
 
 def woerter_haeufigkeit(text: str) -> Dict[str, int]:
     """Zählt die Häufigkeit aller Wörter in einem gegebenen Text (case-insensitive)."""
-    # Schreibe hier deinen Code für TODO 1:
+    # 🎯 TEILZIEL 1: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
 # ==============================================================================
-# TODO 2: Telefonbuch-Suche mit .get()
+# 🎯 TEILZIEL 2 (TODO 2): Telefonbuch-Suche mit .get()
 # ------------------------------------------------------------------------------
 # Schreibe eine Funktion 'telefonbuch_suche(telefonbuch: dict[str, str], name: str) -> str'.
 #
@@ -58,12 +59,13 @@ def woerter_haeufigkeit(text: str) -> Dict[str, int]:
 
 def telefonbuch_suche(telefonbuch: Dict[str, str], name: str) -> str:
     """Sucht eine Telefonnummer im Telefonbuch mit sicherer .get() Abfrage."""
-    # Schreibe hier deinen Code für TODO 2:
+    # 🎯 TEILZIEL 2: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
 # ==============================================================================
-# TODO 3: Gemeinsame Interessen (Mengenoperation Schnittmenge)
+# 🎯 TEILZIEL 3 (TODO 3): Gemeinsame Interessen (Mengenoperation Schnittmenge)
 # ------------------------------------------------------------------------------
 # Schreibe eine Funktion 'gemeinsame_interessen(person_a_hobbys: set, person_b_hobbys: set) -> set'.
 #
@@ -81,12 +83,13 @@ def telefonbuch_suche(telefonbuch: Dict[str, str], name: str) -> str:
 
 def gemeinsame_interessen(person_a_hobbys: Set[str], person_b_hobbys: Set[str]) -> Set[str]:
     """Ermittelt die Schnittmenge der Hobbys zweier Personen."""
-    # Schreibe hier deinen Code für TODO 3:
+    # 🎯 TEILZIEL 3: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
 # ==============================================================================
-# TODO 4: Duplikate entfernen & Reihenfolge beibehalten
+# 🎯 TEILZIEL 4 (TODO 4): Duplikate entfernen & Reihenfolge beibehalten
 # ------------------------------------------------------------------------------
 # Schreibe eine Funktion 'entferne_duplikate_behalte_reihenfolge(liste: list) -> list'.
 #
@@ -105,7 +108,8 @@ def gemeinsame_interessen(person_a_hobbys: Set[str], person_b_hobbys: Set[str])
 
 def entferne_duplikate_behalte_reihenfolge(liste: list) -> list:
     """Entfernt Duplikate aus einer Liste unter Beibehaltung der Reihenfolge."""
-    # Schreibe hier deinen Code für TODO 4:
+    # 🎯 TEILZIEL 4: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 

lehrpfad_1_grundlagen/10_comprehensions_datum_algorithmen/aufgabe.py

@@ -18,7 +18,7 @@ from typing import List, Dict, Union
 
 
 # ==============================================================================
-# TODO 1: Quadratzahlen gerader Zahlen (List Comprehension)
+# 🎯 TEILZIEL 1 (TODO 1): Quadratzahlen gerader Zahlen (List Comprehension)
 # ------------------------------------------------------------------------------
 # Schreibe eine Funktion 'quadratzahlen_gerade(zahlen: list[int]) -> list[int]'.
 #
@@ -35,12 +35,13 @@ from typing import List, Dict, Union
 
 def quadratzahlen_gerade(zahlen: List[int]) -> List[int]:
     """Gibt die Quadrate aller geraden Zahlen als List Comprehension zurück."""
-    # Schreibe hier deinen Code für TODO 1:
+    # 🎯 TEILZIEL 1: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
 # ==============================================================================
-# TODO 2: Wörter nach Mindestlänge filtern
+# 🎯 TEILZIEL 2 (TODO 2): Wörter nach Mindestlänge filtern
 # ------------------------------------------------------------------------------
 # Schreibe eine Funktion 'filtriere_lange_woerter(woerter: list[str], min_laenge: int) -> list[str]'.
 #
@@ -56,12 +57,13 @@ def quadratzahlen_gerade(zahlen: List[int]) -> List[int]:
 
 def filtriere_lange_woerter(woerter: List[str], min_laenge: int) -> List[str]:
     """Filtert alle Wörter heraus, die mindestens 'min_laenge' Zeichen lang sind."""
-    # Schreibe hier deinen Code für TODO 2:
+    # 🎯 TEILZIEL 2: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
 # ==============================================================================
-# TODO 3: Tage bis Zieldatum berechnen (datetime & timedelta)
+# 🎯 TEILZIEL 3 (TODO 3): Tage bis Zieldatum berechnen (datetime & timedelta)
 # ------------------------------------------------------------------------------
 # Schreibe eine Funktion 'tage_bis_datum(ziel_datum_str: str) -> int'.
 #
@@ -76,12 +78,13 @@ def filtriere_lange_woerter(woerter: List[str], min_laenge: int) -> List[str]:
 
 def tage_bis_datum(ziel_datum_str: str) -> int:
     """Berechnet die Anzahl der Tage von heute bis zum angegebenen Zieldatum (YYYY-MM-DD)."""
-    # Schreibe hier deinen Code für TODO 3:
+    # 🎯 TEILZIEL 3: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
 # ==============================================================================
-# TODO 4: Datum im deutschen Format darstellen (.strftime)
+# 🎯 TEILZIEL 4 (TODO 4): Datum im deutschen Format darstellen (.strftime)
 # ------------------------------------------------------------------------------
 # Schreibe eine Funktion 'formatiere_deutsches_datum(datum_obj: Union[date, datetime]) -> str'.
 #
@@ -94,12 +97,13 @@ def tage_bis_datum(ziel_datum_str: str) -> int:
 
 def formatiere_deutsches_datum(datum_obj: Union[date, datetime]) -> str:
     """Formatiert ein date- oder datetime-Objekt in das deutsche Format DD.MM.YYYY."""
-    # Schreibe hier deinen Code für TODO 4:
+    # 🎯 TEILZIEL 4: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
 # ==============================================================================
-# TODO 5: Älteste Person finden (Algorithmus: Maximum / Key-Suche)
+# 🎯 TEILZIEL 5 (TODO 5): Älteste Person finden (Algorithmus: Maximum / Key-Suche)
 # ------------------------------------------------------------------------------
 # Schreibe eine Funktion 'finde_aelteste_person(personen: list[dict]) -> str'.
 #
@@ -113,7 +117,8 @@ def formatiere_deutsches_datum(datum_obj: Union[date, datetime]) -> str:
 
 def finde_aelteste_person(personen: List[Dict[str, Union[str, int]]]) -> str:
     """Findet in einer Liste von Personen-Dicts die älteste Person und gibt deren Namen zurück."""
-    # Schreibe hier deinen Code für TODO 5:
+    # 🎯 TEILZIEL 5: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 

lehrpfad_2_oop_einstieg/01_einstieg_klassen/aufgabe.py

@@ -8,19 +8,20 @@ Wenn du fertig bist, überprüfe deine Lösung im Terminal mit:
 """
 
 # ==============================================================================
-# TODO 1: Definiere eine leere Klasse namens "Haustier".
+# 🎯 TEILZIEL 1 (TODO 1): Definiere eine leere Klasse namens "Haustier".
 # 
 # Erklärung:
 # Eine Klasse ist ein Bauplan.
 # Schreibe 'class Haustier:' und rück in der nächsten Zeile 'pass' ein.
 # ==============================================================================
 
-# Schreibe hier deinen Code für TODO 1:
+# 🎯 TEILZIEL 1: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
 
 
 
 # ==============================================================================
-# TODO 2: Erstelle eine Funktion namens "erstelle_bello()".
+# 🎯 TEILZIEL 2 (TODO 2): Erstelle eine Funktion namens "erstelle_bello()".
 #
 # Schritt-für-Schritt-Anleitung:
 # 1. Erstelle ein neues Haustier-Objekt: z.B. hund = Haustier()
@@ -32,12 +33,13 @@ Wenn du fertig bist, überprüfe deine Lösung im Terminal mit:
 # ==============================================================================
 
 def erstelle_bello():
-    # Schreibe hier deinen Code für TODO 2:
+    # 🎯 TEILZIEL 2: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
 # ==============================================================================
-# TODO 3: Erstelle eine Funktion namens "erstelle_mimi()".
+# 🎯 TEILZIEL 3 (TODO 3): Erstelle eine Funktion namens "erstelle_mimi()".
 #
 # Ähnlich wie bei Bello:
 # - name = "Mimi"
@@ -47,12 +49,13 @@ def erstelle_bello():
 # ==============================================================================
 
 def erstelle_mimi():
-    # Schreibe hier deinen Code für TODO 3:
+    # 🎯 TEILZIEL 3: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
 # ==============================================================================
-# TODO 4: Schreibe eine Funktion "steckbrief_text(haustier)".
+# 🎯 TEILZIEL 4 (TODO 4): Schreibe eine Funktion "steckbrief_text(haustier)".
 #
 # Die Funktion bekommt ein Haustier-Objekt als Parameter übergeben.
 # Sie soll einen formatierten Text im folgenden Format zurückgeben:
@@ -65,12 +68,13 @@ def erstelle_mimi():
 # ==============================================================================
 
 def steckbrief_text(haustier):
-    # Schreibe hier deinen Code für TODO 4:
+    # 🎯 TEILZIEL 4: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 
 # ==============================================================================
-# TODO 5: Schreibe eine Funktion "aelteres_tier(tier1, tier2)".
+# 🎯 TEILZIEL 5 (TODO 5): Schreibe eine Funktion "aelteres_tier(tier1, tier2)".
 #
 # Die Funktion bekommt zwei Haustier-Objekte übergeben.
 # Sie soll dasjenige Haustier-Objekt zurückgeben, dessen 'alter' größer ist.
@@ -84,7 +88,8 @@ def steckbrief_text(haustier):
 # ==============================================================================
 
 def aelteres_tier(tier1, tier2):
-    # Schreibe hier deinen Code für TODO 5:
+    # 🎯 TEILZIEL 5: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
     pass
 
 

lehrpfad_2_oop_einstieg/02_init_und_self/aufgabe.py

@@ -7,7 +7,7 @@ In dieser Aufgabe erstellst du eine Klasse "Bankkonto" für eine Taschengeld-App
 
 class Bankkonto:
     # ==========================================================================
-    # TODO 1: Schreibe die __init__-Methode.
+    # 🎯 TEILZIEL 1 (TODO 1): Schreibe die __init__-Methode.
     # Parameter: self, inhaber (String), kontostand (Float, Standardwert 0.0)
     #
     # Anleitung:
@@ -17,11 +17,12 @@ class Bankkonto:
     #    self.kontostand = kontostand
     # ==========================================================================
     def __init__(self, inhaber, kontostand=0.0):
-        # Schreibe hier deinen Code für TODO 1:
+        # 🎯 TEILZIEL 1: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
         pass
 
     # ==========================================================================
-    # TODO 2: Schreibe die Methode "einzahlen(self, betrag)".
+    # 🎯 TEILZIEL 2 (TODO 2): Schreibe die Methode "einzahlen(self, betrag)".
     #
     # Regeln:
     # 1. Wenn 'betrag' größer als 0 ist:
@@ -32,11 +33,12 @@ class Bankkonto:
     #    - Gib False zurück.
     # ==========================================================================
     def einzahlen(self, betrag):
-        # Schreibe hier deinen Code für TODO 2:
+        # 🎯 TEILZIEL 2: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
         pass
 
     # ==========================================================================
-    # TODO 3: Schreibe die Methode "auszahlen(self, betrag)".
+    # 🎯 TEILZIEL 3 (TODO 3): Schreibe die Methode "auszahlen(self, betrag)".
     #
     # Regeln:
     # 1. Prüfe mit 'if', ob 'betrag > 0' UND 'self.kontostand >= betrag':
@@ -46,11 +48,12 @@ class Bankkonto:
     #    - Gib False zurück.
     # ==========================================================================
     def auszahlen(self, betrag):
-        # Schreibe hier deinen Code für TODO 3:
+        # 🎯 TEILZIEL 3: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
         pass
 
     # ==========================================================================
-    # TODO 4: Schreibe die Methode "info_text(self)".
+    # 🎯 TEILZIEL 4 (TODO 4): Schreibe die Methode "info_text(self)".
     #
     # Sie soll einen formatierten String zurückgeben:
     # "Konto von {inhaber}: {kontostand:.2f} Euro"
@@ -59,7 +62,8 @@ class Bankkonto:
     # Tipp: f"Konto von {self.inhaber}: {self.kontostand:.2f} Euro"
     # ==========================================================================
     def info_text(self):
-        # Schreibe hier deinen Code für TODO 4:
+        # 🎯 TEILZIEL 4: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
         pass
 
 

lehrpfad_2_oop_einstieg/03_methoden_und_verhalten/aufgabe.py

@@ -7,7 +7,7 @@ In dieser Aufgabe programmierst du eine Klasse 'Held' für ein Rollenspiel.
 
 class Held:
     # ==========================================================================
-    # TODO 1: Konstruktor __init__(self, name, leben=100, angriffskraft=15)
+    # 🎯 TEILZIEL 1 (TODO 1): Konstruktor __init__(self, name, leben=100, angriffskraft=15)
     #
     # Speichere die folgenden Attribute an self:
     # - self.name = name
@@ -17,11 +17,12 @@ class Held:
     # - self.ist_am_leben = True
     # ==========================================================================
     def __init__(self, name, leben=100, angriffskraft=15):
-        # Schreibe hier deinen Code für TODO 1:
+        # 🎯 TEILZIEL 1: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
         pass
 
     # ==========================================================================
-    # TODO 2: Methode "schaden_erleiden(self, schaden)"
+    # 🎯 TEILZIEL 2 (TODO 2): Methode "schaden_erleiden(self, schaden)"
     #
     # Schritt-für-Schritt:
     # 1. Wenn der Held schon tot ist (not self.ist_am_leben) oder schaden <= 0:
@@ -33,11 +34,12 @@ class Held:
     # 4. Gib den erlittenen Schaden zurück (z.B. return schaden).
     # ==========================================================================
     def schaden_erleiden(self, schaden):
-        # Schreibe hier deinen Code für TODO 2:
+        # 🎯 TEILZIEL 2: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
         pass
 
     # ==========================================================================
-    # TODO 3: Methode "heilen(self, heilung)"
+    # 🎯 TEILZIEL 3 (TODO 3): Methode "heilen(self, heilung)"
     #
     # Schritt-für-Schritt:
     # 1. Wenn der Held tot ist (not self.ist_am_leben) oder heilung <= 0:
@@ -50,11 +52,12 @@ class Held:
     # 5. Gib tatsaechlich_geheilt zurück.
     # ==========================================================================
     def heilen(self, heilung):
-        # Schreibe hier deinen Code für TODO 3:
+        # 🎯 TEILZIEL 3: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
         pass
 
     # ==========================================================================
-    # TODO 4: Methode "angreifen(self, gegner)"
+    # 🎯 TEILZIEL 4 (TODO 4): Methode "angreifen(self, gegner)"
     # Parameter 'gegner' ist ein anderes Held-Objekt!
     #
     # Schritt-für-Schritt:
@@ -67,11 +70,12 @@ class Held:
     #    - Gib False zurück.
     # ==========================================================================
     def angreifen(self, gegner):
-        # Schreibe hier deinen Code für TODO 4:
+        # 🎯 TEILZIEL 4: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
         pass
 
     # ==========================================================================
-    # TODO 5: Methode "status_text(self)"
+    # 🎯 TEILZIEL 5 (TODO 5): Methode "status_text(self)"
     #
     # Gibt einen formatierten String zurück:
     # Wenn am Leben:
@@ -80,7 +84,8 @@ class Held:
     #   "[{self.name}] HP: 0/{self.max_leben} | Kraft: {self.angriffskraft} | Status: Besiegt"
     # ==========================================================================
     def status_text(self):
-        # Schreibe hier deinen Code für TODO 5:
+        # 🎯 TEILZIEL 5: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
         pass
 
 

lehrpfad_2_oop_einstieg/04_str_und_darstellung/aufgabe.py

@@ -7,26 +7,28 @@ In dieser Aufgabe erstellst du zwei Klassen: 'Artikel' und 'Warenkorb'.
 
 class Artikel:
     # ==========================================================================
-    # TODO 1: Konstruktor für Artikel
+    # 🎯 TEILZIEL 1 (TODO 1): Konstruktor für Artikel
     # Parameter: self, name (str), preis (float), anzahl (int, Standardwert 1)
     # Speichere: self.name, self.preis, self.anzahl
     # ==========================================================================
     def __init__(self, name, preis, anzahl=1):
-        # Schreibe hier deinen Code für TODO 1:
+        # 🎯 TEILZIEL 1: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
         pass
 
     # ==========================================================================
-    # TODO 2: Methode "gesamtpreis(self)"
+    # 🎯 TEILZIEL 2 (TODO 2): Methode "gesamtpreis(self)"
     # Gibt den Preis für diesen Artikel multipliziert mit der Anzahl zurück.
     # Beispiel: 3 Äpfel à 0.50€ -> 1.50
     # Tipp: return self.preis * self.anzahl
     # ==========================================================================
     def gesamtpreis(self):
-        # Schreibe hier deinen Code für TODO 2:
+        # 🎯 TEILZIEL 2: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
         pass
 
     # ==========================================================================
-    # TODO 3: Dunder-Methode "__str__(self)"
+    # 🎯 TEILZIEL 3 (TODO 3): Dunder-Methode "__str__(self)"
     # Gibt einen formatierten String zurück:
     # "{anzahl}x {name} (je {preis:.2f} €) = {gesamtpreis:.2f} €"
     #
@@ -34,30 +36,33 @@ class Artikel:
     # -> "2x Milch (je 1.29 €) = 2.58 €"
     # ==========================================================================
     def __str__(self):
-        # Schreibe hier deinen Code für TODO 3:
+        # 🎯 TEILZIEL 3: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
         pass
 
 
 class Warenkorb:
     # ==========================================================================
-    # TODO 4: Konstruktor für Warenkorb
+    # 🎯 TEILZIEL 4 (TODO 4): Konstruktor für Warenkorb
     # Parameter: self
     # Initialisiere: self.artikel_liste als leere Liste []
     # ==========================================================================
     def __init__(self):
-        # Schreibe hier deinen Code für TODO 4:
+        # 🎯 TEILZIEL 4: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
         pass
 
     # ==========================================================================
-    # TODO 5: Methode "artikel_hinzufuegen(self, artikel)"
+    # 🎯 TEILZIEL 5 (TODO 5): Methode "artikel_hinzufuegen(self, artikel)"
     # Hängt das übergebene Artikel-Objekt an 'self.artikel_liste' an (.append).
     # ==========================================================================
     def artikel_hinzufuegen(self, artikel):
-        # Schreibe hier deinen Code für TODO 5:
+        # 🎯 TEILZIEL 5: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
         pass
 
     # ==========================================================================
-    # TODO 6: Methode "gesamtsumme(self)"
+    # 🎯 TEILZIEL 6 (TODO 6): Methode "gesamtsumme(self)"
     # Berechnet die Summe der Gesamtpreise aller Artikel in self.artikel_liste
     # und gibt diese als float zurück.
     #
@@ -68,11 +73,12 @@ class Warenkorb:
     # return total
     # ==========================================================================
     def gesamtsumme(self):
-        # Schreibe hier deinen Code für TODO 6:
+        # 🎯 TEILZIEL 6: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
         pass
 
     # ==========================================================================
-    # TODO 7: Methode "bon_text(self)"
+    # 🎯 TEILZIEL 7 (TODO 7): Methode "bon_text(self)"
     # Erzeugt einen formatierten mehrzeiligen String für den Kassenzettel.
     # Format:
     # --- KASSENZETTEL ---
@@ -84,7 +90,8 @@ class Warenkorb:
     # Tipp: Baue eine Liste von Zeilen und verbinde sie am Ende mit "\n".join(...)
     # ==========================================================================
     def bon_text(self):
-        # Schreibe hier deinen Code für TODO 7:
+        # 🎯 TEILZIEL 7: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
         pass
 
 

lehrpfad_2_oop_einstieg/05_objekte_kombinieren/aufgabe.py

@@ -8,16 +8,17 @@ In dieser Aufgabe baust du eine Musikverwaltung mit zwei Klassen:
 
 class Song:
     # ==========================================================================
-    # TODO 1: Konstruktor für Song
+    # 🎯 TEILZIEL 1 (TODO 1): Konstruktor für Song
     # Parameter: self, titel (str), kuenstler (str), dauer_sekunden (int)
     # Speichere: self.titel, self.kuenstler, self.dauer_sekunden
     # ==========================================================================
     def __init__(self, titel, kuenstler, dauer_sekunden):
-        # Schreibe hier deinen Code für TODO 1:
+        # 🎯 TEILZIEL 1: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
         pass
 
     # ==========================================================================
-    # TODO 2: Methode "formatierte_dauer(self)"
+    # 🎯 TEILZIEL 2 (TODO 2): Methode "formatierte_dauer(self)"
     # Rechnet 'self.dauer_sekunden' in Minuten und Sekunden um und gibt einen
     # String im Format "MM:SS" zurück (z.B. 215 -> "03:35", 70 -> "01:10").
     #
@@ -27,49 +28,54 @@ class Song:
     # return f"{minuten:02d}:{sekunden:02d}"
     # ==========================================================================
     def formatierte_dauer(self):
-        # Schreibe hier deinen Code für TODO 2:
+        # 🎯 TEILZIEL 2: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
         pass
 
     # ==========================================================================
-    # TODO 3: Dunder-Methode "__str__(self)"
+    # 🎯 TEILZIEL 3 (TODO 3): Dunder-Methode "__str__(self)"
     # Gibt einen String im Format zurück:
     # '"{titel}" von {kuenstler} ({formatierte_dauer})'
     #
     # Beispiel: '"Flowers" von Miley Cyrus (03:20)'
     # ==========================================================================
     def __str__(self):
-        # Schreibe hier deinen Code für TODO 3:
+        # 🎯 TEILZIEL 3: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
         pass
 
 
 class Playlist:
     # ==========================================================================
-    # TODO 4: Konstruktor für Playlist
+    # 🎯 TEILZIEL 4 (TODO 4): Konstruktor für Playlist
     # Parameter: self, name (str)
     # Speichere: self.name, self.songs (als leere Liste [])
     # ==========================================================================
     def __init__(self, name):
-        # Schreibe hier deinen Code für TODO 4:
+        # 🎯 TEILZIEL 4: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
         pass
 
     # ==========================================================================
-    # TODO 5: Methode "song_hinzufuegen(self, song)"
+    # 🎯 TEILZIEL 5 (TODO 5): Methode "song_hinzufuegen(self, song)"
     # Hängt das übergebene Song-Objekt an 'self.songs' an (.append).
     # ==========================================================================
     def song_hinzufuegen(self, song):
-        # Schreibe hier deinen Code für TODO 5:
+        # 🎯 TEILZIEL 5: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
         pass
 
     # ==========================================================================
-    # TODO 6: Methode "anzahl_songs(self)"
+    # 🎯 TEILZIEL 6 (TODO 6): Methode "anzahl_songs(self)"
     # Gibt die Anzahl der Songs in der Playlist als Integer zurück (len(self.songs)).
     # ==========================================================================
     def anzahl_songs(self):
-        # Schreibe hier deinen Code für TODO 6:
+        # 🎯 TEILZIEL 6: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
         pass
 
     # ==========================================================================
-    # TODO 7: Methode "gesamtdauer_sekunden(self)"
+    # 🎯 TEILZIEL 7 (TODO 7): Methode "gesamtdauer_sekunden(self)"
     # Gibt die Summe der Sekunden aller Songs in der Playlist zurück.
     # Bei leerer Playlist: 0
     #
@@ -80,27 +86,30 @@ class Playlist:
     # return total
     # ==========================================================================
     def gesamtdauer_sekunden(self):
-        # Schreibe hier deinen Code für TODO 7:
+        # 🎯 TEILZIEL 7: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
         pass
 
     # ==========================================================================
-    # TODO 8: Methode "finde_songs_von(self, kuenstler)"
+    # 🎯 TEILZIEL 8 (TODO 8): Methode "finde_songs_von(self, kuenstler)"
     # Sucht alle Songs in self.songs, bei denen der Künstler übereinstimmt.
     # Wichtig: Groß- und Kleinschreibung soll ignoriert werden! (z.B. .lower())
     # Gibt eine Liste von passenden Song-Objekten zurück.
     # ==========================================================================
     def finde_songs_von(self, kuenstler):
-        # Schreibe hier deinen Code für TODO 8:
+        # 🎯 TEILZIEL 8: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
         pass
 
     # ==========================================================================
-    # TODO 9: Methode "laengster_song(self)"
+    # 🎯 TEILZIEL 9 (TODO 9): Methode "laengster_song(self)"
     # Findet den Song mit der längsten Spieldauer in self.songs.
     # - Gibt das gefundene Song-Objekt zurück.
     # - Gibt None zurück, wenn die Playlist leer ist.
     # ==========================================================================
     def laengster_song(self):
-        # Schreibe hier deinen Code für TODO 9:
+        # 🎯 TEILZIEL 9: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
         pass
 
 

lehrpfad_2_oop_einstieg/06_abschlussprojekt_tamagotchi/aufgabe.py

@@ -7,7 +7,7 @@ Programmiere hier die Klasse 'Tamagotchi'.
 
 class Tamagotchi:
     # ==========================================================================
-    # TODO 1: Konstruktor __init__(self, name, tierart="Drache")
+    # 🎯 TEILZIEL 1 (TODO 1): Konstruktor __init__(self, name, tierart="Drache")
     #
     # Initialisiere die folgenden Attribute an self:
     # - self.name = name
@@ -19,7 +19,8 @@ class Tamagotchi:
     # - self.ist_lebendig = True
     # ==========================================================================
     def __init__(self, name, tierart="Drache"):
-        # Schreibe hier deinen Code für TODO 1:
+        # 🎯 TEILZIEL 1: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
         pass
 
     # Hilfsmethode: Begrenzt Werte immer zwischen min_wert (0) und max_wert (100)
@@ -27,7 +28,7 @@ class Tamagotchi:
         return max(min_wert, min(max_wert, wert))
 
     # ==========================================================================
-    # TODO 2: Methode "fuettern(self, menge=20)"
+    # 🎯 TEILZIEL 2 (TODO 2): Methode "fuettern(self, menge=20)"
     #
     # Regeln:
     # 1. Wenn not self.ist_lebendig:
@@ -39,11 +40,12 @@ class Tamagotchi:
     #    - Gib zurück: f"{self.name} mampft genüsslich! (Hunger: {self.hunger}/100)"
     # ==========================================================================
     def fuettern(self, menge=20):
-        # Schreibe hier deinen Code für TODO 2:
+        # 🎯 TEILZIEL 2: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
         pass
 
     # ==========================================================================
-    # TODO 3: Methode "spielen(self, spass=25)"
+    # 🎯 TEILZIEL 3 (TODO 3): Methode "spielen(self, spass=25)"
     #
     # Regeln:
     # 1. Wenn not self.ist_lebendig:
@@ -58,11 +60,12 @@ class Tamagotchi:
     #    - Gib zurück: f"{self.name} hatte riesigen Spaß beim Spielen! (Glück: {self.glueck}/100)"
     # ==========================================================================
     def spielen(self, spass=25):
-        # Schreibe hier deinen Code für TODO 3:
+        # 🎯 TEILZIEL 3: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
         pass
 
     # ==========================================================================
-    # TODO 4: Methode "schlafen(self)"
+    # 🎯 TEILZIEL 4 (TODO 4): Methode "schlafen(self)"
     #
     # Regeln:
     # 1. Wenn not self.ist_lebendig:
@@ -74,11 +77,12 @@ class Tamagotchi:
     #    - Gib zurück: f"{self.name} hat tief geschlafen und ist ausgeruht! Ein neuer Tag bricht an."
     # ==========================================================================
     def schlafen(self):
-        # Schreibe hier deinen Code für TODO 4:
+        # 🎯 TEILZIEL 4: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
         pass
 
     # ==========================================================================
-    # TODO 5: Methode "zeit_vergeht(self)"
+    # 🎯 TEILZIEL 5 (TODO 5): Methode "zeit_vergeht(self)"
     # Simuliert das Verstreichen von Zeit.
     #
     # Regeln:
@@ -94,11 +98,12 @@ class Tamagotchi:
     #    - Gib self.ist_lebendig zurück (True wenn noch am Leben, False wenn gestorben).
     # ==========================================================================
     def zeit_vergeht(self):
-        # Schreibe hier deinen Code für TODO 5:
+        # 🎯 TEILZIEL 5: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
         pass
 
     # ==========================================================================
-    # TODO 6: Dunder-Methode "__str__(self)"
+    # 🎯 TEILZIEL 6 (TODO 6): Dunder-Methode "__str__(self)"
     # Gibt eine hübsche Statusübersicht als mehrzeiligen String zurück.
     #
     # Format (wenn lebendig):
@@ -111,7 +116,8 @@ class Tamagotchi:
     # "=== {self.name} ({self.tierart}) - RIP 🪦 ==="
     # ==========================================================================
     def __str__(self):
-        # Schreibe hier deinen Code für TODO 6:
+        # 🎯 TEILZIEL 6: Implementiere die Logik Schritt für Schritt:
+    # 💡 Tipp: Beachte Datentypen und das abschließende return!
         pass
 
 

lehrpfad_3_fortgeschrittenes_oop/07_referenzen_und_speicher/aufgabe.py

@@ -10,7 +10,7 @@ from typing import Optional, List
 
 class Person:
     # ==========================================================================
-    # TODO 1: Konstruktor __init__
+    # 🎯 TEILZIEL 1 (TODO 1): Konstruktor __init__
     # Parameter: name (str), geburtsjahr (int)
     # Attribute:
     #   - self.name: str
@@ -23,7 +23,7 @@ class Person:
         pass
 
     # ==========================================================================
-    # TODO 2: Methode mutter_setzen(self, mutter: 'Person') -> None
+    # 🎯 TEILZIEL 2 (TODO 2): Methode mutter_setzen(self, mutter: 'Person') -> None
     # 1. Setze self.mutter = mutter
     # 2. Füge self zur Liste mutter.kinder hinzu (falls self noch nicht drin ist)
     # ==========================================================================
@@ -31,7 +31,7 @@ class Person:
         pass
 
     # ==========================================================================
-    # TODO 3: Methode vater_setzen(self, vater: 'Person') -> None
+    # 🎯 TEILZIEL 3 (TODO 3): Methode vater_setzen(self, vater: 'Person') -> None
     # 1. Setze self.vater = vater
     # 2. Füge self zur Liste vater.kinder hinzu (falls self noch nicht drin ist)
     # ==========================================================================
@@ -39,7 +39,7 @@ class Person:
         pass
 
     # ==========================================================================
-    # TODO 4: Methode geschwister(self) -> list['Person']
+    # 🎯 TEILZIEL 4 (TODO 4): Methode geschwister(self) -> list['Person']
     # Gibt eine Liste aller Personen zurück, die dieselbe Mutter ODER denselben
     # Vater haben wie self.
     # WICHTIG:
@@ -50,7 +50,7 @@ class Person:
         pass
 
     # ==========================================================================
-    # TODO 5: Methode grosseltern(self) -> list['Person']
+    # 🎯 TEILZIEL 5 (TODO 5): Methode grosseltern(self) -> list['Person']
     # Gibt eine Liste aller bekannten Großeltern zurück:
     # (Mutter der Mutter, Vater der Mutter, Mutter des Vaters, Vater des Vaters)
     # Nur Großeltern hinzufügen, die nicht None sind!
@@ -59,7 +59,7 @@ class Person:
         pass
 
     # ==========================================================================
-    # TODO 6: Dunder-Methode __str__(self) -> str
+    # 🎯 TEILZIEL 6 (TODO 6): Dunder-Methode __str__(self) -> str
     # Gibt einen String im Format: "Name (*Geburtsjahr)" zurück.
     # Beispiel: "Mia (*2008)"
     # ==========================================================================

lehrpfad_3_fortgeschrittenes_oop/07_referenzen_und_speicher/index.html

@@ -54,6 +54,22 @@
 <span class="fn">print</span>(<span class="var">liste_a</span>)  <span class="cm"># Ausgabe: [1, 2, 3, 99] &lt;-- liste_a hat sich mitverändert!</span></pre>
       </div>
 
+      <!-- Visuelles Speichermodell (Notional Machine) -->
+      <div style="background: #0f172a; color: #f8fafc; border-radius: var(--radius-md); padding: 18px; margin: 20px 0; border: 1px solid rgba(255,255,255,0.1);">
+        <div style="color: #38bdf8; font-weight: 700; margin-bottom: 8px; font-size: 1.05rem;">🧠 Was passiert im Computer-Speicher? (Notional Machine)</div>
+        <pre style="background: transparent; color: #e2e8f0; font-family: var(--font-mono); font-size: 0.88rem; padding: 0;">
+STACK (Variablen-Namen)                HEAP (Echter Speicher / RAM)
+┌──────────────┐                       ┌──────────────────────────────┐
+│  liste_a ────┼──────────────────────&gt;│  ID: 0x7ffd1a  [1, 2, 3, 99] │
+└──────────────┘                       └──────────────────────────────┘
+                                                       ▲
+┌──────────────┐                                       │
+│  liste_b ────┼───────────────────────────────────────┘
+└──────────────┘
+(Beide Variablen zeigen auf denselben Pfeil im Heap!)
+        </pre>
+      </div>
+
       <div class="box box-warning">
         <div class="box-title">⚠️ Vorsicht bei veränderlichen Objekten (Mutable vs. Immutable):</div>
         <ul>

lehrpfad_3_fortgeschrittenes_oop/08_operator_overloading_dunder/aufgabe.py

@@ -16,14 +16,14 @@ class Vektor2D:
     """
 
     # ==========================================================================
-    # TODO 1: Konstruktor __init__(self, x: float, y: float)
+    # 🎯 TEILZIEL 1 (TODO 1): Konstruktor __init__(self, x: float, y: float)
     # Speichere self.x = float(x) und self.y = float(y).
     # ==========================================================================
     def __init__(self, x: float, y: float):
         pass
 
     # ==========================================================================
-    # TODO 2: Darstellungsmethoden __repr__ und __str__
+    # 🎯 TEILZIEL 2 (TODO 2): Darstellungsmethoden __repr__ und __str__
     # - __repr__(self) -> str: Gibt Entwickler-String "Vektor2D(x, y)" zurück (z.B. "Vektor2D(3.0, 4.0)")
     # - __str__(self) -> str:  Gibt benutzerfreundlichen String "(x, y)" zurück (z.B. "(3.0, 4.0)")
     # ==========================================================================
@@ -34,7 +34,7 @@ class Vektor2D:
         pass
 
     # ==========================================================================
-    # TODO 3: Länge und Absolutbetrag
+    # 🎯 TEILZIEL 3 (TODO 3): Länge und Absolutbetrag
     # - laenge(self) -> float: Berechnet sqrt(x² + y²)
     # - __abs__(self) -> float: Gibt self.laenge() zurück, damit abs(v) funktioniert!
     # ==========================================================================
@@ -45,7 +45,7 @@ class Vektor2D:
         pass
 
     # ==========================================================================
-    # TODO 4: Addition (__add__) und Subtraktion (__sub__)
+    # 🎯 TEILZIEL 4 (TODO 4): Addition (__add__) und Subtraktion (__sub__)
     # - __add__(self, other: 'Vektor2D') -> 'Vektor2D':
     #   Addiert zwei Vektoren komponentenweise: (self.x + other.x, self.y + other.y)
     # - __sub__(self, other: 'Vektor2D') -> 'Vektor2D':
@@ -59,7 +59,7 @@ class Vektor2D:
         pass
 
     # ==========================================================================
-    # TODO 5: Multiplikation (__mul__) und Rechts-Multiplikation (__rmul__)
+    # 🎯 TEILZIEL 5 (TODO 5): Multiplikation (__mul__) und Rechts-Multiplikation (__rmul__)
     # - __mul__(self, other):
     #   * Wenn other eine Zahl ist (int oder float):
     #     Skalarmultiplikation -> neuer Vektor2D(self.x * other, self.y * other)
@@ -76,7 +76,7 @@ class Vektor2D:
         pass
 
     # ==========================================================================
-    # TODO 6: Vergleiche (__eq__, __lt__, __le__)
+    # 🎯 TEILZIEL 6 (TODO 6): Vergleiche (__eq__, __lt__, __le__)
     # - __eq__(self, other: object) -> bool:
     #   True, wenn other ein Vektor2D ist und self.x == other.x und self.y == other.y (Tipp: math.isclose)
     # - __lt__(self, other: 'Vektor2D') -> bool:
@@ -100,7 +100,7 @@ class Wegstrecke:
     """
 
     # ==========================================================================
-    # TODO 7: Wegstrecke __init__ und punkt_hinzufuegen
+    # 🎯 TEILZIEL 7 (TODO 7): Wegstrecke __init__ und punkt_hinzufuegen
     # - __init__(self, punkte: list[Vektor2D] | None = None):
     #   Speichert self.punkte = list(punkte) if punkte else []
     # - punkt_hinzufuegen(self, punkt: Vektor2D) -> None:
@@ -113,7 +113,7 @@ class Wegstrecke:
         pass
 
     # ==========================================================================
-    # TODO 8: Container-Dunder (__len__ und __getitem__)
+    # 🎯 TEILZIEL 8 (TODO 8): Container-Dunder (__len__ und __getitem__)
     # - __len__(self) -> int:
     #   Gibt die Anzahl der Wegpunkte zurück (len(self.punkte)).
     # - __getitem__(self, index: int) -> Vektor2D:
@@ -126,7 +126,7 @@ class Wegstrecke:
         pass
 
     # ==========================================================================
-    # TODO 9: gesamtlaenge(self) -> float
+    # 🎯 TEILZIEL 9 (TODO 9): gesamtlaenge(self) -> float
     # Berechnet die Summe aller Teilstrecken zwischen aufeinanderfolgenden Punkten:
     # Distanz zwischen Punkt i und Punkt i+1 ist: abs(punkte[i+1] - punkte[i])
     # Wenn weniger als 2 Punkte vorhanden sind: gebe 0.0 zurück.

lehrpfad_3_fortgeschrittenes_oop/09_eigene_unit_tests_schreiben/aufgabe.py

@@ -83,14 +83,14 @@ class Bankkonto:
 class TestTaschenrechner(unittest.TestCase):
 
     # ==========================================================================
-    # TODO 1: setUp(self)
+    # 🎯 TEILZIEL 1 (TODO 1): setUp(self)
     # Erstelle vor jedem Test eine frische Rechner-Instanz: self.calc = Taschenrechner()
     # ==========================================================================
     def setUp(self):
         pass
 
     # ==========================================================================
-    # TODO 2: test_01_grundrechenarten(self)
+    # 🎯 TEILZIEL 2 (TODO 2): test_01_grundrechenarten(self)
     # Teste mit self.assertEqual:
     # - self.calc.add(2, 3) soll 5 sein
     # - self.calc.sub(10, 4) soll 6 sein
@@ -100,7 +100,7 @@ class TestTaschenrechner(unittest.TestCase):
         pass
 
     # ==========================================================================
-    # TODO 3: test_02_division_und_kommazahlen(self)
+    # 🎯 TEILZIEL 3 (TODO 3): test_02_division_und_kommazahlen(self)
     # - Teste self.calc.div(10, 2) mit self.assertEqual (soll 5.0 sein)
     # - Teste self.calc.div(10, 3) mit self.assertAlmostEqual(..., places=2) (ca. 3.33)
     # ==========================================================================
@@ -108,7 +108,7 @@ class TestTaschenrechner(unittest.TestCase):
         pass
 
     # ==========================================================================
-    # TODO 4: test_03_division_durch_null_exception(self)
+    # 🎯 TEILZIEL 4 (TODO 4): test_03_division_durch_null_exception(self)
     # Teste mit 'with self.assertRaises(ZeroDivisionError):'
     # dass self.calc.div(10, 0) den Fehler auslöst!
     # ==========================================================================
@@ -116,7 +116,7 @@ class TestTaschenrechner(unittest.TestCase):
         pass
 
     # ==========================================================================
-    # TODO 5: test_04_wurzel_negativ_exception(self)
+    # 🎯 TEILZIEL 5 (TODO 5): test_04_wurzel_negativ_exception(self)
     # - Teste self.calc.wurzel(16) soll 4.0 sein (assertEqual oder assertAlmostEqual)
     # - Teste mit 'with self.assertRaises(ValueError):' dass self.calc.wurzel(-9)
     #   einen ValueError auslöst!
@@ -125,7 +125,7 @@ class TestTaschenrechner(unittest.TestCase):
         pass
 
     # ==========================================================================
-    # TODO 6: test_05_speicher_funktionen(self)
+    # 🎯 TEILZIEL 6 (TODO 6): test_05_speicher_funktionen(self)
     # - Prüfe, dass self.calc.speicher zu Beginn 0.0 ist
     # - Rufe self.calc.speicher_plus(15.5) und self.calc.speicher_plus(4.5) auf
     # - Prüfe, dass self.calc.speicher jetzt 20.0 ist
@@ -138,7 +138,7 @@ class TestTaschenrechner(unittest.TestCase):
 class TestBankkonto(unittest.TestCase):
 
     # ==========================================================================
-    # TODO 7: setUp(self)
+    # 🎯 TEILZIEL 7 (TODO 7): setUp(self)
     # Erstelle zwei Testkonten:
     # - self.k1 = Bankkonto("Alice", 100.0)
     # - self.k2 = Bankkonto("Bob", 50.0)
@@ -147,7 +147,7 @@ class TestBankkonto(unittest.TestCase):
         pass
 
     # ==========================================================================
-    # TODO 8: test_06_einzahlen_und_abheben(self)
+    # 🎯 TEILZIEL 8 (TODO 8): test_06_einzahlen_und_abheben(self)
     # - Zahle 50.0 auf self.k1 ein und prüfe kontostand == 150.0
     # - Prüfe mit self.assertIn(50.0, self.k1.transaktionen), dass die Einzahlung gelistet ist
     # - Hebe 30.0 von self.k1 ab und prüfe kontostand == 120.0
@@ -157,7 +157,7 @@ class TestBankkonto(unittest.TestCase):
         pass
 
     # ==========================================================================
-    # TODO 9: test_07_abheben_ueber_limit_exception(self)
+    # 🎯 TEILZIEL 9 (TODO 9): test_07_abheben_ueber_limit_exception(self)
     # Teste mit 'with self.assertRaises(ValueError):'
     # dass das Abheben von 200.0 (bei 100.0 Guthaben) einen ValueError auslöst!
     # ==========================================================================
@@ -165,7 +165,7 @@ class TestBankkonto(unittest.TestCase):
         pass
 
     # ==========================================================================
-    # TODO 10: test_08_ueberweisung(self)
+    # 🎯 TEILZIEL 10 (TODO 10): test_08_ueberweisung(self)
     # - Überweise 40.0 von self.k1 an self.k2
     # - Prüfe self.k1.kontostand == 60.0
     # - Prüfe self.k2.kontostand == 90.0

lehrpfad_3_fortgeschrittenes_oop/10_vererbung_und_super/aufgabe.py

@@ -25,7 +25,7 @@ class Fahrzeug:
     """
 
     # ==========================================================================
-    # TODO 1: Konstruktor __init__ der Basisklasse
+    # 🎯 TEILZIEL 1 (TODO 1): Konstruktor __init__ der Basisklasse
     # Parameter: marke (str), modell (str), baujahr (int), grundpreis (float)
     # Attribute:
     #   - self.marke: str
@@ -38,7 +38,7 @@ class Fahrzeug:
         pass
 
     # ==========================================================================
-    # TODO 2: Methode fahren(self, km: float) -> None
+    # 🎯 TEILZIEL 2 (TODO 2): Methode fahren(self, km: float) -> None
     # Erhöht den Kilometerstand um 'km', wenn km > 0 ist.
     # Bei km <= 0 passiert nichts.
     # ==========================================================================
@@ -46,7 +46,7 @@ class Fahrzeug:
         pass
 
     # ==========================================================================
-    # TODO 3: Methode berechne_restwert(self, aktuelles_jahr: int) -> float
+    # 🎯 TEILZIEL 3 (TODO 3): Methode berechne_restwert(self, aktuelles_jahr: int) -> float
     # Berechnet den aktuellen Restwert des Fahrzeugs:
     # 1. Alter = max(0, aktuelles_jahr - self.baujahr)
     # 2. Wertverlust = self.grundpreis * 0.05 * Alter (5% Wertverlust pro Jahr)
@@ -58,7 +58,7 @@ class Fahrzeug:
         pass
 
     # ==========================================================================
-    # TODO 4: Methode info(self) -> str
+    # 🎯 TEILZIEL 4 (TODO 4): Methode info(self) -> str
     # Gibt einen formatierten Infostring zurück:
     # Format: "{marke} {modell} ({baujahr}) - {kilometerstand:.1f} km"
     # Beispiel: "BMW 320d (2020) - 45000.0 km"
@@ -80,7 +80,7 @@ class Auto(Fahrzeug):
     """
 
     # ==========================================================================
-    # TODO 5: Konstruktor __init__ von Auto
+    # 🎯 TEILZIEL 5 (TODO 5): Konstruktor __init__ von Auto
     # Parameter: marke (str), modell (str), baujahr (int), grundpreis (float),
     #            sitzplaetze (int = 5), anzahl_tueren (int = 5)
     # 1. Rufe den Konstruktor der Elternklasse mit super().__init__(...) auf!
@@ -98,7 +98,7 @@ class Auto(Fahrzeug):
         pass
 
     # ==========================================================================
-    # TODO 6: Methode hupen(self) -> str
+    # 🎯 TEILZIEL 6 (TODO 6): Methode hupen(self) -> str
     # Gibt einen Hup-Laut mit Marke und Modell zurück:
     # Format: "Hup hup! Platz da für den {marke} {modell}!"
     # Beispiel: "Hup hup! Platz da für den VW Golf!"
@@ -107,7 +107,7 @@ class Auto(Fahrzeug):
         pass
 
     # ==========================================================================
-    # TODO 7: Methode info(self) -> str (Method Overriding / Erweitern)
+    # 🎯 TEILZIEL 7 (TODO 7): Methode info(self) -> str (Method Overriding / Erweitern)
     # Rufe super().info() auf und hänge " | {sitzplaetze} Sitze, {anzahl_tueren} Türen" an.
     # Format: "{super().info()} | {self.sitzplaetze} Sitze, {self.anzahl_tueren} Türen"
     # Beispiel: "VW Golf (2021) - 12000.0 km | 5 Sitze, 5 Türen"
@@ -127,7 +127,7 @@ class ElektroAuto(Auto):
     """
 
     # ==========================================================================
-    # TODO 8: Konstruktor __init__ von ElektroAuto
+    # 🎯 TEILZIEL 8 (TODO 8): Konstruktor __init__ von ElektroAuto
     # Parameter: marke (str), modell (str), baujahr (int), grundpreis (float),
     #            batterie_kapazitaet_kwh (float), sitzplaetze (int = 5),
     #            anzahl_tueren (int = 5), verbrauch_pro_100km (float = 18.0)
@@ -150,7 +150,7 @@ class ElektroAuto(Auto):
         pass
 
     # ==========================================================================
-    # TODO 9: Methode reichweite(self) -> float
+    # 🎯 TEILZIEL 9 (TODO 9): Methode reichweite(self) -> float
     # Berechnet die verbleibende Reichweite in Kilometern:
     # Formel: (aktueller_ladestand / verbrauch_pro_100km) * 100
     # Wenn verbrauch_pro_100km <= 0: 0.0 zurückgeben.
@@ -159,7 +159,7 @@ class ElektroAuto(Auto):
         pass
 
     # ==========================================================================
-    # TODO 10: Methode fahren(self, km: float) -> bool (Überschreiben mit Logik)
+    # 🎯 TEILZIEL 10 (TODO 10): Methode fahren(self, km: float) -> bool (Überschreiben mit Logik)
     # 1. Wenn km <= 0: False zurückgeben.
     # 2. Berechne den benötigten Strom: benoetigt = (km / 100.0) * self.verbrauch_pro_100km
     # 3. Wenn self.batterie_ladestand_kwh >= benoetigt:
@@ -174,7 +174,7 @@ class ElektroAuto(Auto):
         pass
 
     # ==========================================================================
-    # TODO 11: Methode aufladen(self, kwh: float) -> float
+    # 🎯 TEILZIEL 11 (TODO 11): Methode aufladen(self, kwh: float) -> float
     # Lädt den Akku auf, aber maximal bis batterie_kapazitaet_kwh!
     # 1. Wenn kwh <= 0: return 0.0
     # 2. Berechne den freien Platz im Akku: batterie_kapazitaet_kwh - batterie_ladestand_kwh
@@ -186,7 +186,7 @@ class ElektroAuto(Auto):
         pass
 
     # ==========================================================================
-    # TODO 12: Methode info(self) -> str
+    # 🎯 TEILZIEL 12 (TODO 12): Methode info(self) -> str
     # Format: "{super().info()} | Akku: {batterie_ladestand_kwh:.1f}/{batterie_kapazitaet_kwh:.1f} kWh ({reichweite():.1f} km Reichweite)"
     # Beispiel: "Tesla Model 3 (2023) - 5000.0 km | 5 Sitze, 5 Türen | Akku: 60.0/60.0 kWh (333.3 km Reichweite)"
     # ==========================================================================
@@ -204,7 +204,7 @@ class Lkw(Fahrzeug):
     """
 
     # ==========================================================================
-    # TODO 13: Konstruktor __init__ von Lkw
+    # 🎯 TEILZIEL 13 (TODO 13): Konstruktor __init__ von Lkw
     # Parameter: marke (str), modell (str), baujahr (int), grundpreis (float),
     #            max_zuladung_kg (float)
     # 1. Rufe super().__init__(marke, modell, baujahr, grundpreis) auf.
@@ -222,7 +222,7 @@ class Lkw(Fahrzeug):
         pass
 
     # ==========================================================================
-    # TODO 14: Methode beladen(self, kg: float) -> bool
+    # 🎯 TEILZIEL 14 (TODO 14): Methode beladen(self, kg: float) -> bool
     # 1. Wenn kg > 0 und self.aktuelle_ladung_kg + kg <= self.max_zuladung_kg:
     #       - Erhöhe self.aktuelle_ladung_kg um kg
     #       - return True
@@ -232,7 +232,7 @@ class Lkw(Fahrzeug):
         pass
 
     # ==========================================================================
-    # TODO 15: Methode entladen(self, kg: float) -> float
+    # 🎯 TEILZIEL 15 (TODO 15): Methode entladen(self, kg: float) -> float
     # Entlädt maximal die vorhandene Ladung.
     # 1. Wenn kg <= 0: return 0.0
     # 2. tatsaechlich = min(self.aktuelle_ladung_kg, kg)
@@ -243,7 +243,7 @@ class Lkw(Fahrzeug):
         pass
 
     # ==========================================================================
-    # TODO 16: Methode info(self) -> str
+    # 🎯 TEILZIEL 16 (TODO 16): Methode info(self) -> str
     # Format: "{super().info()} | Ladung: {aktuelle_ladung_kg:.1f}/{max_zuladung_kg:.1f} kg"
     # Beispiel: "MAN TGX (2019) - 150000.0 km | Ladung: 8500.0/18000.0 kg"
     # ==========================================================================

lehrpfad_3_fortgeschrittenes_oop/11_polymorphie_und_interfaces/aufgabe.py

@@ -25,7 +25,7 @@ class Form(ABC):
     """
 
     # ==========================================================================
-    # TODO 1: Konstruktor __init__ der Basisklasse Form
+    # 🎯 TEILZIEL 1 (TODO 1): Konstruktor __init__ der Basisklasse Form
     # Parameter: farbe (str = "schwarz")
     # Setze self.farbe = farbe
     # ==========================================================================
@@ -33,7 +33,7 @@ class Form(ABC):
         pass
 
     # ==========================================================================
-    # TODO 2: Abstrakte Methode flaeche(self) -> float
+    # 🎯 TEILZIEL 2 (TODO 2): Abstrakte Methode flaeche(self) -> float
     # Deklariere die Methode mit @abstractmethod.
     # Da es eine abstrakte Methode ist, enthält der Rumpf nur 'pass'.
     # ==========================================================================
@@ -42,7 +42,7 @@ class Form(ABC):
         pass
 
     # ==========================================================================
-    # TODO 3: Abstrakte Methode umfang(self) -> float
+    # 🎯 TEILZIEL 3 (TODO 3): Abstrakte Methode umfang(self) -> float
     # Deklariere die Methode mit @abstractmethod.
     # Rumpf: 'pass'
     # ==========================================================================
@@ -51,7 +51,7 @@ class Form(ABC):
         pass
 
     # ==========================================================================
-    # TODO 4: Methode info(self) -> str
+    # 🎯 TEILZIEL 4 (TODO 4): Methode info(self) -> str
     # Gibt einen allgemeinen Infostring zurück:
     # Format: "{Klassenname} ({farbe}) - Fläche: {flaeche():.2f}, Umfang: {umfang():.2f}"
     # Tipp: self.__class__.__name__ liefert den Namen der jeweiligen Kindklasse!
@@ -75,7 +75,7 @@ class Rechteck(Form):
     """
 
     # ==========================================================================
-    # TODO 5: Konstruktor __init__ von Rechteck
+    # 🎯 TEILZIEL 5 (TODO 5): Konstruktor __init__ von Rechteck
     # Parameter: breite (float), hoehe (float), farbe (str = "rot")
     # 1. Rufe super().__init__(farbe) auf.
     # 2. Setze self.breite = float(breite)
@@ -85,21 +85,21 @@ class Rechteck(Form):
         pass
 
     # ==========================================================================
-    # TODO 6: Methode flaeche(self) -> float (Überschreiben)
+    # 🎯 TEILZIEL 6 (TODO 6): Methode flaeche(self) -> float (Überschreiben)
     # Formel: breite * hoehe
     # ==========================================================================
     def flaeche(self) -> float:
         pass
 
     # ==========================================================================
-    # TODO 7: Methode umfang(self) -> float (Überschreiben)
+    # 🎯 TEILZIEL 7 (TODO 7): Methode umfang(self) -> float (Überschreiben)
     # Formel: 2 * (breite + hoehe)
     # ==========================================================================
     def umfang(self) -> float:
         pass
 
     # ==========================================================================
-    # TODO 8: Methode info(self) -> str (Überschreiben)
+    # 🎯 TEILZIEL 8 (TODO 8): Methode info(self) -> str (Überschreiben)
     # Format: "Rechteck ({farbe}, {breite:.1f}x{hoehe:.1f}) - Fläche: {flaeche():.2f}, Umfang: {umfang():.2f}"
     # Beispiel: "Rechteck (rot, 4.0x5.0) - Fläche: 20.00, Umfang: 18.00"
     # ==========================================================================
@@ -117,7 +117,7 @@ class Kreis(Form):
     """
 
     # ==========================================================================
-    # TODO 9: Konstruktor __init__ von Kreis
+    # 🎯 TEILZIEL 9 (TODO 9): Konstruktor __init__ von Kreis
     # Parameter: radius (float), farbe (str = "blau")
     # 1. Rufe super().__init__(farbe) auf.
     # 2. Setze self.radius = float(radius)
@@ -126,21 +126,21 @@ class Kreis(Form):
         pass
 
     # ==========================================================================
-    # TODO 10: Methode flaeche(self) -> float (Überschreiben)
+    # 🎯 TEILZIEL 10 (TODO 10): Methode flaeche(self) -> float (Überschreiben)
     # Formel: math.pi * (radius ** 2)
     # ==========================================================================
     def flaeche(self) -> float:
         pass
 
     # ==========================================================================
-    # TODO 11: Methode umfang(self) -> float (Überschreiben)
+    # 🎯 TEILZIEL 11 (TODO 11): Methode umfang(self) -> float (Überschreiben)
     # Formel: 2 * math.pi * radius
     # ==========================================================================
     def umfang(self) -> float:
         pass
 
     # ==========================================================================
-    # TODO 12: Methode info(self) -> str (Überschreiben)
+    # 🎯 TEILZIEL 12 (TODO 12): Methode info(self) -> str (Überschreiben)
     # Format: "Kreis ({farbe}, r={radius:.1f}) - Fläche: {flaeche():.2f}, Umfang: {umfang():.2f}"
     # Beispiel: "Kreis (blau, r=3.0) - Fläche: 28.27, Umfang: 18.85"
     # ==========================================================================
@@ -159,7 +159,7 @@ class Dreieck(Form):
     """
 
     # ==========================================================================
-    # TODO 13: Konstruktor __init__ von Dreieck
+    # 🎯 TEILZIEL 13 (TODO 13): Konstruktor __init__ von Dreieck
     # Parameter: seite_a (float), seite_b (float), farbe (str = "gruen")
     # 1. Rufe super().__init__(farbe) auf.
     # 2. Setze self.seite_a = float(seite_a)
@@ -169,7 +169,7 @@ class Dreieck(Form):
         pass
 
     # ==========================================================================
-    # TODO 14: Methode hypotenuse(self) -> float
+    # 🎯 TEILZIEL 14 (TODO 14): Methode hypotenuse(self) -> float
     # Berechnet die dritte Seite c mit dem Satz des Pythagoras:
     # Formel: math.sqrt(seite_a**2 + seite_b**2)
     # ==========================================================================
@@ -177,21 +177,21 @@ class Dreieck(Form):
         pass
 
     # ==========================================================================
-    # TODO 15: Methode flaeche(self) -> float (Überschreiben)
+    # 🎯 TEILZIEL 15 (TODO 15): Methode flaeche(self) -> float (Überschreiben)
     # Formel: 0.5 * seite_a * seite_b
     # ==========================================================================
     def flaeche(self) -> float:
         pass
 
     # ==========================================================================
-    # TODO 16: Methode umfang(self) -> float (Überschreiben)
+    # 🎯 TEILZIEL 16 (TODO 16): Methode umfang(self) -> float (Überschreiben)
     # Formel: seite_a + seite_b + self.hypotenuse()
     # ==========================================================================
     def umfang(self) -> float:
         pass
 
     # ==========================================================================
-    # TODO 17: Methode info(self) -> str (Überschreiben)
+    # 🎯 TEILZIEL 17 (TODO 17): Methode info(self) -> str (Überschreiben)
     # Format: "Dreieck ({farbe}, a={seite_a:.1f}, b={seite_b:.1f}, c={hypotenuse():.1f}) - Fläche: {flaeche():.2f}, Umfang: {umfang():.2f}"
     # Beispiel: "Dreieck (gruen, a=3.0, b=4.0, c=5.0) - Fläche: 6.00, Umfang: 12.00"
     # ==========================================================================
@@ -209,7 +209,7 @@ class Zeichenflaeche:
     """
 
     # ==========================================================================
-    # TODO 18: Konstruktor __init__ von Zeichenflaeche
+    # 🎯 TEILZIEL 18 (TODO 18): Konstruktor __init__ von Zeichenflaeche
     # Parameter: name (str = "Meine Zeichenfläche")
     # Attribute:
     #   - self.name: str = name
@@ -219,21 +219,21 @@ class Zeichenflaeche:
         pass
 
     # ==========================================================================
-    # TODO 19: Methode hinzufuegen(self, form: Form) -> None
+    # 🎯 TEILZIEL 19 (TODO 19): Methode hinzufuegen(self, form: Form) -> None
     # Fügt die übergebene Form zur Liste self.formen hinzu.
     # ==========================================================================
     def hinzufuegen(self, form: Form) -> None:
         pass
 
     # ==========================================================================
-    # TODO 20: Methode anzahl_formen(self) -> int
+    # 🎯 TEILZIEL 20 (TODO 20): Methode anzahl_formen(self) -> int
     # Gibt die Anzahl der aktuell enthaltenen Formen zurück.
     # ==========================================================================
     def anzahl_formen(self) -> int:
         pass
 
     # ==========================================================================
-    # TODO 21: Methode gesamte_flaeche(self) -> float (Polymorphie in Aktion!)
+    # 🎯 TEILZIEL 21 (TODO 21): Methode gesamte_flaeche(self) -> float (Polymorphie in Aktion!)
     # Berechnet die Summe aller Flächen der enthaltenen Formen.
     # Nutze eine Schleife oder sum(...), um form.flaeche() für jede Form aufzurufen.
     # Wenn self.formen leer ist: 0.0 zurückgeben.
@@ -242,7 +242,7 @@ class Zeichenflaeche:
         pass
 
     # ==========================================================================
-    # TODO 22: Methode gesamter_umfang(self) -> float (Polymorphie in Aktion!)
+    # 🎯 TEILZIEL 22 (TODO 22): Methode gesamter_umfang(self) -> float (Polymorphie in Aktion!)
     # Berechnet die Summe aller Umfänge der enthaltenen Formen.
     # Nutze form.umfang() für jedes Objekt in self.formen.
     # Wenn self.formen leer ist: 0.0 zurückgeben.
@@ -251,7 +251,7 @@ class Zeichenflaeche:
         pass
 
     # ==========================================================================
-    # TODO 23: Methode formen_nach_farbe(self, farbe: str) -> list[Form]
+    # 🎯 TEILZIEL 23 (TODO 23): Methode formen_nach_farbe(self, farbe: str) -> list[Form]
     # Filtert alle Formen heraus, die die angegebene Farbe haben.
     # WICHTIG: Groß-/Kleinschreibung ignorieren (z.B. mit farbe.lower())!
     # ==========================================================================
@@ -259,7 +259,7 @@ class Zeichenflaeche:
         pass
 
     # ==========================================================================
-    # TODO 24: Methode groesste_form(self) -> Form | None
+    # 🎯 TEILZIEL 24 (TODO 24): Methode groesste_form(self) -> Form | None
     # Findet die Form mit dem größten Flächeninhalt (form.flaeche()).
     # Wenn die Liste leer ist: return None
     # Tipp: Nutze max(self.formen, key=lambda f: f.flaeche())
@@ -268,7 +268,7 @@ class Zeichenflaeche:
         pass
 
     # ==========================================================================
-    # TODO 25: Methode report(self) -> list[str]
+    # 🎯 TEILZIEL 25 (TODO 25): Methode report(self) -> list[str]
     # Gibt eine Liste der info()-Texte aller enthaltenen Formen zurück.
     # ==========================================================================
     def report(self) -> List[str]:

lehrpfad_3_fortgeschrittenes_oop/12_exceptions_und_fehlerbehandlung/aufgabe.py

@@ -12,7 +12,7 @@ from typing import Optional
 
 
 # ==============================================================================
-# TODO 1: Eigene Exception-Klassen definieren
+# 🎯 TEILZIEL 1 (TODO 1): Eigene Exception-Klassen definieren
 # ==============================================================================
 # Erstelle eine Basis-Exception-Klasse 'BankFehler', die von 'Exception' erbt.
 # Erstelle dann 4 abgeleitete Exception-Klassen, die alle von 'BankFehler' erben:
@@ -43,7 +43,7 @@ class UngueltigerBetragError(BankFehler):
 
 
 # ==============================================================================
-# TODO 2: Klasse Bankkonto
+# 🎯 TEILZIEL 2 (TODO 2): Klasse Bankkonto
 # ==============================================================================
 class Bankkonto:
     def __init__(self, inhaber: str, pin: str, kontostand: float = 0.0):
@@ -137,7 +137,7 @@ class Bankkonto:
 
 
 # ==============================================================================
-# TODO 3: Geldautomat-Auszahlung mit try - except - else - finally
+# 🎯 TEILZIEL 3 (TODO 3): Geldautomat-Auszahlung mit try - except - else - finally
 # ==============================================================================
 def geldautomat_abheben(konto: Bankkonto, betrag: float, pin: str) -> str:
     """

lehrpfad_3_fortgeschrittenes_oop/13_persistenz_json_und_csv/aufgabe.py

@@ -16,7 +16,7 @@ from typing import List, Optional, Dict, Any
 
 
 # ==============================================================================
-# TODO 1: Klasse Spieler mit Serialisierung
+# 🎯 TEILZIEL 1 (TODO 1): Klasse Spieler mit Serialisierung
 # ==============================================================================
 class Spieler:
     def __init__(self, name: str, level: int, punkte: int, inventar: Optional[List[str]] = None):
@@ -71,7 +71,7 @@ class Spieler:
 
 
 # ==============================================================================
-# TODO 2: Klasse Spielstand mit JSON- und CSV-Persistenz
+# 🎯 TEILZIEL 2 (TODO 2): Klasse Spielstand mit JSON- und CSV-Persistenz
 # ==============================================================================
 class Spielstand:
     def __init__(self, titel: str = "Neuer Spielstand"):

lehrpfad_3_fortgeschrittenes_oop/14_gui_mit_tkinter/aufgabe.py

@@ -99,7 +99,7 @@ class ZaehlerLogik:
     """
 
     # ==========================================================================
-    # TODO 1: Konstruktor __init__
+    # 🎯 TEILZIEL 1 (TODO 1): Konstruktor __init__
     # Parameter:
     #   - startwert (int, Standard: 0)
     #   - min_wert (int, Standard: -100)
@@ -181,7 +181,7 @@ class ZaehlerApp:
     """
 
     # ==========================================================================
-    # TODO 4: Konstruktor __init__(self, root: tk.Tk)
+    # 🎯 TEILZIEL 4 (TODO 4): Konstruktor __init__(self, root: tk.Tk)
     # Parameter: root (das Tkinter-Hauptfenster)
     #
     # 1. Speichere das Fenster:
@@ -269,7 +269,7 @@ class ZaehlerApp:
         pass
 
     # ==========================================================================
-    # TODO 6: Methode aktualisiere_anzeige(self) -> None
+    # 🎯 TEILZIEL 6 (TODO 6): Methode aktualisiere_anzeige(self) -> None
     # Synchronisiert die Oberfläche mit den aktuellen Werten aus self.logik:
     #
     # 1. Hauptanzeige:

lehrpfad_3_fortgeschrittenes_oop/15_parameter_und_container/aufgabe.py

@@ -40,7 +40,7 @@ def berechne_gesamtsumme(*zahlen: float, rabatt_prozent: float = 0.0) -> float:
         berechne_gesamtsumme() -> 0.0
     """
     # ==========================================================================
-    # TODO 1: Implementiere berechne_gesamtsumme
+    # 🎯 TEILZIEL 1 (TODO 1): Implementiere berechne_gesamtsumme
     # 1. Validiere rabatt_prozent: Liegt der Wert nicht zwischen 0.0 und 100.0,
     #    löse einen ValueError mit passender Nachricht aus.
     # 2. Summiere alle Werte in `zahlen` (wenn zahlen leer ist, ist die Summe 0.0).
@@ -68,7 +68,7 @@ def erstelle_profil(name: str, **details: Any) -> Dict[str, Any]:
         -> {"name": "Aragorn", "klasse": "Waldlaeufer", "level": 20}
     """
     # ==========================================================================
-    # TODO 2: Implementiere erstelle_profil
+    # 🎯 TEILZIEL 2 (TODO 2): Implementiere erstelle_profil
     # 1. Erstelle ein Dictionary mit {"name": str(name)}.
     # 2. Füge alle Schlüssel-Wert-Paare aus `details` hinzu.
     # 3. Gib das fertige Dictionary zurück.
@@ -98,7 +98,7 @@ class Gegenstand:
             ValueError: Falls gewicht < 0 oder wert < 0 ist.
         """
         # ==========================================================================
-        # TODO 3: Implementiere Gegenstand.__init__, __repr__, __str__ und __eq__
+        # 🎯 TEILZIEL 3 (TODO 3): Implementiere Gegenstand.__init__, __repr__, __str__ und __eq__
         # 1. Validiere gewicht >= 0 und wert >= 0 (sonst ValueError).
         # 2. Setze self.name = str(name), self.gewicht = float(gewicht), self.wert = int(wert).
         # ==========================================================================
@@ -145,7 +145,7 @@ class Inventar:
             ValueError: Falls max_gewicht <= 0 oder die Start-Gegenstände das Maximalgewicht überschreiten.
         """
         # ==========================================================================
-        # TODO 4: Inventar-Initialisierung
+        # 🎯 TEILZIEL 4 (TODO 4): Inventar-Initialisierung
         # 1. Validiere max_gewicht > 0 (sonst ValueError).
         # 2. Speichere self.max_gewicht = float(max_gewicht).
         # 3. Initialisiere eine interne Liste self._items = [].
@@ -187,7 +187,7 @@ class Inventar:
                         das Maximalgewicht des Inventars überschreiten würde.
         """
         # ==========================================================================
-        # TODO 6: hinzufuegen mit *args
+        # 🎯 TEILZIEL 6 (TODO 6): hinzufuegen mit *args
         # 1. Prüfe für jedes item in `items`, ob es eine Instanz von Gegenstand ist (sonst TypeError).
         # 2. Berechne das Zusatzgewicht aller neuen Gegenstände.
         # 3. Wenn self.gesamtgewicht + zusatz_gewicht > self.max_gewicht:
@@ -201,7 +201,7 @@ class Inventar:
         Ermöglicht len(inventar) -> Gibt die Anzahl der Gegenstände zurück.
         """
         # ==========================================================================
-        # TODO 7: __len__
+        # 🎯 TEILZIEL 7 (TODO 7): __len__
         # ==========================================================================
         pass
 
@@ -217,7 +217,7 @@ class Inventar:
             TypeError: Falls key weder int noch str ist.
         """
         # ==========================================================================
-        # TODO 8: __getitem__ (Multi-Type Lookup: int und str)
+        # 🎯 TEILZIEL 8 (TODO 8): __getitem__ (Multi-Type Lookup: int und str)
         # 1. Wenn isinstance(key, int): gib self._items[key] zurück.
         # 2. Wenn isinstance(key, str): suche den ersten Gegenstand mit passendem Namen
         #    (Vergleich mit g.name.lower() == key.lower()). Wenn gefunden, zurückgeben.
@@ -236,7 +236,7 @@ class Inventar:
             ValueError: Falls durch den Austausch das Maximalgewicht überschritten würde.
         """
         # ==========================================================================
-        # TODO 9: __setitem__
+        # 🎯 TEILZIEL 9 (TODO 9): __setitem__
         # 1. Prüfe Typen (index muss int sein, value muss Gegenstand sein, sonst TypeError).
         # 2. Prüfe Indexgrenzen: -len(self._items) <= index < len(self._items) (sonst IndexError).
         # 3. Berechne neues Gesamtgewicht: gesamtgewicht - altes_item.gewicht + value.gewicht.
@@ -257,7 +257,7 @@ class Inventar:
             TypeError: Falls key weder int noch str ist.
         """
         # ==========================================================================
-        # TODO 10: __delitem__
+        # 🎯 TEILZIEL 10 (TODO 10): __delitem__
         # 1. Wenn int: del self._items[key].
         # 2. Wenn str: suche erstes Element mit passendem Namen (case-insensitive) und entferne es.
         #    Falls nicht vorhanden -> KeyError.
@@ -272,7 +272,7 @@ class Inventar:
         - gegenstand_objekt in inventar -> True/False (Objekt-Prüfung)
         """
         # ==========================================================================
-        # TODO 11: __contains__
+        # 🎯 TEILZIEL 11 (TODO 11): __contains__
         # 1. Wenn str: prüfe, ob ein Gegenstand mit diesem Namen existiert (case-insensitive).
         # 2. Wenn Gegenstand: prüfe `item in self._items`.
         # 3. Andernfalls gebe False zurück.
@@ -284,7 +284,7 @@ class Inventar:
         Ermöglicht Iteration: for item in inventar: ...
         """
         # ==========================================================================
-        # TODO 12: __iter__
+        # 🎯 TEILZIEL 12 (TODO 12): __iter__
         # Gib einen Iterator über self._items zurück (z.B. iter(self._items)).
         # ==========================================================================
         pass
@@ -308,7 +308,7 @@ def packe_inventar(*gegenstaende: Gegenstand, max_gewicht: float = 20.0) -> Inve
     Demonstriert Argument-Unpacking und flexible Parameter.
     """
     # ==========================================================================
-    # TODO 13: packe_inventar
+    # 🎯 TEILZIEL 13 (TODO 13): packe_inventar
     # 1. Erstelle ein Inventar mit `max_gewicht=max_gewicht`.
     # 2. Füge alle `gegenstaende` mit inv.hinzufuegen(*gegenstaende) hinzu.
     # 3. Gib das befüllte Inventar zurück.