alex-mueller/it-praxisportal
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

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

Browse source
This commit is contained in:
Alex Mueller 2026-08-29 15:41:30 +02:00
parent c428db6a5c
commit e472fb0be1
30 changed files with 481 additions and 244 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
.gamification.json
View file

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

2
assets/gamification_data.js
View file

@ -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": {

134
assets/runner.js Normal file
View file

@ -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ß!')"
);
}
});
})();

4
index.html
View file

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

35
lehrpfad_1_grundlagen/01_erste_schritte_taschenrechner/aufgabe.py
View file

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

20
lehrpfad_1_grundlagen/02_variablen_und_datentypen/aufgabe.py
View file

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

20
lehrpfad_1_grundlagen/03_ein_und_ausgabe/aufgabe.py
View file

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

20
lehrpfad_1_grundlagen/04_verzweigungen_und_bedingungen/aufgabe.py
View file

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

25
lehrpfad_1_grundlagen/05_schleifen_und_wiederholungen/aufgabe.py
View file

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

20
lehrpfad_1_grundlagen/06_funktionen_und_module/aufgabe.py
View file

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

15
lehrpfad_1_grundlagen/07_listen_und_sequenzen/aufgabe.py
View file

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

15
lehrpfad_1_grundlagen/08_textverarbeitung_und_strings/aufgabe.py
View file

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

20
lehrpfad_1_grundlagen/09_dictionaries_und_sets/aufgabe.py
View file

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

25
lehrpfad_1_grundlagen/10_comprehensions_datum_algorithmen/aufgabe.py
View file

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

25
lehrpfad_2_oop_einstieg/01_einstieg_klassen/aufgabe.py
View file

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

20
lehrpfad_2_oop_einstieg/02_init_und_self/aufgabe.py
View file

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

25
lehrpfad_2_oop_einstieg/03_methoden_und_verhalten/aufgabe.py
View file

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

35
lehrpfad_2_oop_einstieg/04_str_und_darstellung/aufgabe.py
View file

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

45
lehrpfad_2_oop_einstieg/05_objekte_kombinieren/aufgabe.py
View file

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

30
lehrpfad_2_oop_einstieg/06_abschlussprojekt_tamagotchi/aufgabe.py
View file

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

12
lehrpfad_3_fortgeschrittenes_oop/07_referenzen_und_speicher/aufgabe.py
View file

@ -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)"
# ==========================================================================

16
lehrpfad_3_fortgeschrittenes_oop/07_referenzen_und_speicher/index.html
View file

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

18
lehrpfad_3_fortgeschrittenes_oop/08_operator_overloading_dunder/aufgabe.py
View file

@ -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.

20
lehrpfad_3_fortgeschrittenes_oop/09_eigene_unit_tests_schreiben/aufgabe.py
View file

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

32
lehrpfad_3_fortgeschrittenes_oop/10_vererbung_und_super/aufgabe.py
View file

@ -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"
# ==========================================================================

50
lehrpfad_3_fortgeschrittenes_oop/11_polymorphie_und_interfaces/aufgabe.py
View file

@ -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]:

6
lehrpfad_3_fortgeschrittenes_oop/12_exceptions_und_fehlerbehandlung/aufgabe.py
View file

@ -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:
"""

4
lehrpfad_3_fortgeschrittenes_oop/13_persistenz_json_und_csv/aufgabe.py
View file

@ -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"):

6
lehrpfad_3_fortgeschrittenes_oop/14_gui_mit_tkinter/aufgabe.py
View file

@ -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:

24
lehrpfad_3_fortgeschrittenes_oop/15_parameter_und_container/aufgabe.py
View file

@ -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.