diff --git a/04b_umstieg_vscode/index.html b/04b_umstieg_vscode/index.html index 367d991..fb4a751 100644 --- a/04b_umstieg_vscode/index.html +++ b/04b_umstieg_vscode/index.html @@ -308,7 +308,7 @@ sudo snap install --classic code diff --git a/04c_git_und_versionskontrolle/README.md b/04c_git_und_versionskontrolle/README.md new file mode 100644 index 0000000..58f6315 --- /dev/null +++ b/04c_git_und_versionskontrolle/README.md @@ -0,0 +1,45 @@ +# Kapitel 04c: Git & Versionskontrolle: Deine Programmier-Zeitmaschine 🌿⏱️ + +Herzlich willkommen zum Git-Guide! + +**Git** ist das weltweit am meisten genutzte Versionskontrollsystem. Es ermöglicht dir, deinen Code in sauberen Spielständen (Commits) zu speichern, jederzeit alte Versionen wiederherzustellen und im Team zu arbeiten. + +--- + +## 🎮 Der Lebenszyklus eines Codes in Git + +1. **Arbeitsverzeichnis (Working Tree):** Deine Dateien, die du in VS Code bearbeitest. +2. **Staging Area (`git add .`):** Die Bereitstellung. Du wählst aus, welche geänderten Dateien in den nächsten Speicherpunkt gehören. +3. **Commit (`git commit -m "Nachricht"`):** Der fertige Speicherpunkt mit Zeitstempel und Erklärung. +4. **Push (`git push`):** Hochladen deiner Commits auf den entfernten Server (z.B. dein Aufgaben-Repository). + +--- + +## 🖥️ Git in VS Code nutzen + +1. Drücke `Strg + Shift + G` (Mac: `Cmd + Shift + G`), um links das Git-Panel zu öffnen. +2. Klicke auf eine veränderte Datei → Du siehst sofort den **Diff** (Rot = alter Code, Grün = neuer Code). +3. Klicke auf `+` neben der Datei (Staging). +4. Tippe eine Commit-Nachricht ins Textfeld und klicke auf das Häkchen **✓ Commit**. +5. Klicke auf **Sync Changes / Push**, um alles auf den Server zu laden! + +--- + +## ⌨️ Die wichtigsten Terminal-Befehle + +| Befehl | Erklärung | +| :--- | :--- | +| `git status` | Zeigt geänderte und neue Dateien an | +| `git add .` | Packt alle aktuellen Änderungen in die Staging Area | +| `git commit -m "Text"` | Erstellt einen Commit mit einer Beschreibung | +| `git push` | Lädt neue Commits auf den Server hoch | +| `git log --oneline` | Zeigt die bisherige Versions-Historie an | + +--- + +## 🧪 Mitmach-Übung in `git_uebung.py` + +1. Öffne `git_uebung.py`, ändere den Text und speichere. +2. Öffne den Git-Tab in VS Code (`Strg + Shift + G`). +3. Betrachte die Änderung und erstelle einen Commit mit der Nachricht: *"Mein erster eigener Git-Commit"*. +4. Überprüfe die Historie mit `git log --oneline -n 3`. diff --git a/04c_git_und_versionskontrolle/git_uebung.py b/04c_git_und_versionskontrolle/git_uebung.py new file mode 100644 index 0000000..5d9458b --- /dev/null +++ b/04c_git_und_versionskontrolle/git_uebung.py @@ -0,0 +1,30 @@ +""" +🌿 GIT-MITMACH-ÜBUNG 🌿 +======================= +Diese Datei ist für dein erstes Git-Experiment da! + +ANLEITUNG: +1. Ändere die Variable 'dein_name' unten zu deinem echten Vornamen. +2. Füge eine neue Lieblingsprogrammiersprache oder ein Hobby zur Liste hinzu. +3. Speichere die Datei mit Strg + S (Mac: Cmd + S). +4. Öffne links in VS Code den Quellcodeverwaltungs-Tab (Strg + Shift + G). +5. Klicke auf 'git_uebung.py', um die roten/grünen Änderungen zu sehen! +6. Gib oben eine Nachricht ein wie: "Update git_uebung mit meinem Namen" +7. Klicke auf das blaue Häkchen (Commit). +""" + +dein_name = "Nachhilfe-Schülerin" +lieblings_sprachen = ["Python", "HTML", "CSS"] +lieblings_feature_in_python = "Objektorientierte Programmierung mit Klassen!" + + +def begruessung(): + return f"Hallo! Ich bin {dein_name} und lerne gerade Git & Versionskontrolle! 🎉" + + +if __name__ == "__main__": + print("=" * 60) + print(begruessung()) + print("Meine Sprachen:", ", ".join(lieblings_sprachen)) + print("Mein Lieblings-Feature:", lieblings_feature_in_python) + print("=" * 60) diff --git a/04c_git_und_versionskontrolle/index.html b/04c_git_und_versionskontrolle/index.html new file mode 100644 index 0000000..e5b4ae6 --- /dev/null +++ b/04c_git_und_versionskontrolle/index.html @@ -0,0 +1,214 @@ + + + + + + Kapitel 04c: Git & Versionskontrolle + + + + +
+
+ +
Versionskontrolle • Profi-Werkzeug
+

Git & Versionskontrolle: Deine Programmier-Zeitmaschine 🌿⏱️

+

Lerne, wie du deinen Code versionierst, Spielstände sicherst und Änderungen in VS Code & im Terminal verwaltest.

+
+
+ +
+ + +
+

1. Was ist Git und warum braucht es jede(r) Entwickler(in)?

+ +

+ Hast du schon mal Dateien so genannt wie aufgabe.py, aufgabe_final.py, aufgabe_final2_wirklich_fertig.py? 😅 + Genau dieses Chaos verhindert Git! +

+ +
+
🎮 Die Spielstand- & Zeitmaschinen-Analogie:
+
    +
  • Ein Commit ist wie ein Speicherpunkt in einem Computerspiel: Wenn du vor einem Bosskampf stehst (oder eine neue Funktion ausprobierst) und dein Code kaputtgeht, kannst du mit einem Klick genau zu diesem perfekten Zustand zurückreisen!
  • +
  • Git dokumentiert die Geschichte: Du siehst immer genau, wer wann welche Zeile verändert hat und warum.
  • +
+
+
+ + +
+

2. Der Git-Lebenszyklus: Die 3 Stationen eines Codes

+ +

Wenn du Code in Git sicherst, durchläuft er drei Stationen:

+ +
+ +
+
📝
+

1. Arbeitsbereich (Working Tree)

+

Du tippst und speicherst deine Dateien ganz normal im Editor.

+
+ +
+
📦
+

2. Bereitstellung (Staging Area)

+

Mit git add . wählst du aus, welche Dateien in den nächsten Spielstand gepackt werden.

+
+ +
+
💾
+

3. Commit (Speicherpunkt)

+

Mit git commit -m "..." schnürst du das Paket fest und gibst ihm eine aussagekräftige Nachricht.

+
+ +
+ +
+
🚀 Der letzte Schritt: git push (In die Cloud laden):
+ Mit git push schickst du deine lokalen Commits an den Git-Server (z.B. dein Aufgaben-Repository), damit dein Lehrer oder dein Nachhilfelehrer deinen Code einsehen kann. +
+
+ + +
+

3. 🖥️ Git visuell in VS Code bedienen

+ +

+ Du musst Befehle nicht zwingend im Terminal tippen – VS Code hat eine fantastische Quellcodeverwaltung eingebaut: +

+ +
    +
  1. + Drücke Strg + Shift + G (Mac: Cmd + Shift + G) oder klicke links auf das Ast-/Verzweigungs-Symbol (Quellcodeverwaltung). +
  2. +
  3. + Änderungen sehen (Diff): Klicke auf eine geänderte Datei. VS Code öffnet einen geteilten Bildschirm: Links siehst du den alten Code (rot) und rechts deinen neuen Code (grün)! +
  4. +
  5. + Stagen: Klicke neben der Datei auf das +-Symbol (Staged Changes). +
  6. +
  7. + Committen: Tippe oben ins Textfeld eine kurze Nachricht (z.B. "Löse Aufgabe in Kapitel 05") und klicke auf das blaue Häkchen ✓ Commit. +
  8. +
  9. + Pushen: Klicke auf den blauen Button "Sync Changes" oder unten links auf das Wolken-/Drehsymobl. Fertig! 🎉 +
  10. +
+
+ + +
+

4. ⌨️ Das Git-Terminal Cheat-Sheet

+ +

Wenn du lieber im Terminal arbeitest (Strg + `), sind das die 5 wichtigsten Befehle deines Entwickler-Lebens:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
BefehlWas er macht
git statusZeigt an, welche Dateien geändert oder neu erstellt wurden.
git add .Packt alle aktuellen Änderungen in die Staging-Area.
git commit -m "Text"Erstellt einen neuen Speicherpunkt mit deiner Nachricht.
git pushLädt alle neuen Commits auf den Server hoch.
git log --onelineZeigt die Liste aller bisherigen Commits kurz und übersichtlich.
+
+ + +
+

5. 🙈 Was ist die .gitignore-Datei?

+ +

+ Nicht jede Datei soll in Git gespeichert werden (z.B. temporäre Cache-Dateien wie __pycache__ oder Passwörter). + In einer Textdatei namens .gitignore im Hauptordner schreibt man Dateinamen auf, die Git einfach vollständig ignorieren soll. +

+ +
+
+ Beispiel: Typische .gitignore für Python +
+
__pycache__/
+*.pyc
+.DS_Store
+.venv/
+
+
+ + +
+

6. 🧪 Dein Git-Mitmach-Check

+ +

Öffne die Datei 04c_git_und_versionskontrolle/git_uebung.py und führe deinen ersten eigenen Commit durch:

+ + + +
+
🏆 Bravo! Du beherrschst nun echte Entwickler-Tools!
+ Ab jetzt kannst du jedes gelöste Kapitel wie ein Profi committen. Weiter geht's mit Kapitel 05 (Objekte kombinieren)! +
+ + +
+ +
+ + + diff --git a/05_objekte_kombinieren/index.html b/05_objekte_kombinieren/index.html index 2d2f63c..9c3e670 100644 --- a/05_objekte_kombinieren/index.html +++ b/05_objekte_kombinieren/index.html @@ -13,7 +13,7 @@ @@ -190,7 +190,7 @@ diff --git a/LEHRPLAN.md b/LEHRPLAN.md index 4d9cfb4..09d71a9 100644 --- a/LEHRPLAN.md +++ b/LEHRPLAN.md @@ -9,37 +9,41 @@ Es gleicht die Übungsreihe mit dem offiziellen Lehrplan und Skriptum des Lehrer 1. **Type Hints als Standard:** Da der Lehrer in Teil 2 strikt Typ-Annotationen verwendet (`name: str`, `def alter(self) -> int:`), führen wir diese ab den Klassen sauber ein. 2. **UML-Klassendiagramme:** Das Skriptum fordert UML-Diagramme (`22.1_UML.md`). Jedes Kapitel enthält visuelle UML-Karten. -3. **Praxisnahe Analogien:** Statt trockener Theorie nutzen wir greifbare Alltagsbeispiele (Fahrrad-Verleih, Spotify-Playlists, Stammbäume, Geldautomaten). -4. **Automatische Tests & Sofort-Feedback:** Jedes Kapitel hat ein Testskript (`test_aufgabe.py`), das bei `python3 test_aufgabe.py` oder `python3 test_all.py` sofort anzeigt, was schon klappt. -5. **Autonomes Lernen:** Die Schülerin kann alle Kapitel über die modernen, interaktiven HTML-Seiten im Browser selbstständig durcharbeiten. +3. **Echte Entwickler-Werkzeuge früh erlernen:** Nach den ersten OOP-Kapiteln folgen **VS Code (04b)** und **Git Versionskontrolle (04c)**, damit die Schülerin ab Kapitel 05 jedes gelöste Kapitel selbstständig versioniert und committet. +4. **Eigene Unit Tests schreiben:** Ab Kapitel 09 lernt die Schülerin, wie man mit `unittest` eigene Testsuiten und Test-Driven Development (TDD) praktiziert. +5. **Praxisnahe Analogien:** Statt trockener Theorie nutzen wir greifbare Alltagsbeispiele (Fahrrad-Verleih, Spotify-Playlists, Stammbäume, Geldautomaten). +6. **Automatische Tests & Sofort-Feedback:** Jedes Kapitel hat ein Testskript (`test_aufgabe.py`), das bei `python3 test_aufgabe.py` oder `python3 test_all.py` sofort anzeigt, was schon klappt. +7. **Autonomes Lernen:** Die Schülerin kann alle Kapitel über die modernen, interaktiven HTML-Seiten im Browser selbstständig durcharbeiten. --- -## 🗺️ Der Gesamtlehrplan im Überblick +## 🗺️ Der Gesamtlehrplan im Überblick (Kapitel 00 bis 16) ``` PHASE 1: GRUNDLAGEN DER OBJEKTORIENTIERUNG (OOP) & TOOLING ├── Kapitel 00: Fehlersuche & Python-Debugging (Warm-up) - ├── Kapitel 01: Erste Klasse & Baupläne (Lehrer 22.0) + ├── Kapitel 01: Erste Klasse & Baupläne (Lehrer 22.0 / 21.0 Type Hints) ├── Kapitel 02: Konstruktor __init__, self & UML (Lehrer 22.0 / 22.1) ├── Kapitel 03: Methoden & Objekt-Interaktion (Lehrer 22.0) ├── Kapitel 04: Schöne Textausgabe mit __str__ (Lehrer 28.0) - ├── Kapitel 04b: Umstieg & Installation von VS Code (Lehrer 20.1 / 20.2) + ├── Kapitel 04b: Umstieg & Installation von VS Code (Lehrer 20.1) + ├── Kapitel 04c: Git & Versionskontrolle (VS Code & Terminal) 🌿 ├── Kapitel 05: Assoziation & Aggregation: Spotify Playlists (Lehrer 23.0) └── Kapitel 06: Mini-Abschlussprojekt: Tamagotchi Terminal-Game -PHASE 2: FORTGESCHRITTENES OOP, SPEICHER & DATEN-PERSISTENZ +PHASE 2: FORTGESCHRITTENES OOP, TESTING & SPEICHER ├── Kapitel 07: Referenzen, Speicher & Stammbäume (Lehrer 24.0) 🧠 ├── Kapitel 08: Operator Overloading & Dunder-Methoden (Lehrer 28.0) ➕ - ├── Kapitel 09: Vererbung (Inheritance) & super() (Lehrer 25.0) 🧬 - ├── Kapitel 10: Polymorphie & Duck Typing (Lehrer 25.1) 🎭 - ├── Kapitel 11: Exceptions & Robuste Fehlerbehandlung (Lehrer 26.0) 🛡️ - └── Kapitel 12: Speichern & Laden: JSON & CSV Persistenz (Lehrer 14.0) 💾 + ├── Kapitel 09: Eigene Unit Tests schreiben & TDD (unittest) 🧪 + ├── Kapitel 10: Vererbung (Inheritance) & super() (Lehrer 25.0) 🧬 + ├── Kapitel 11: Polymorphie & Duck Typing (Lehrer 25.1) 🎭 + ├── Kapitel 12: Exceptions & Robuste Fehlerbehandlung (Lehrer 26.0) 🛡️ + └── Kapitel 13: Speichern & Laden: JSON & CSV Persistenz (Lehrer 14.0) 💾 PHASE 3: GRAFISCHE OBERFLÄCHEN & PROFESSIONS-MODULE - ├── Kapitel 13: Grafische Oberflächen mit Tkinter / CustomTkinter (Lehrer 27.0) 🖥️ - ├── Kapitel 14: Erweiterte Parameter (*args, **kwargs) & Container (Lehrer 29.0 / 30.0) 📦 - └── Kapitel 15: Master-Abschlussprojekt: Grafische Desktop-App mit Savegame 🏆 + ├── Kapitel 14: Grafische Oberflächen mit Tkinter / CustomTkinter (Lehrer 27.0) 🖥️ + ├── Kapitel 15: Erweiterte Parameter (*args, **kwargs) & Container (Lehrer 29/30) 📦 + └── Kapitel 16: Master-Abschlussprojekt: Grafische Desktop-App mit Savegame 🏆 ``` --- @@ -53,15 +57,17 @@ PHASE 3: GRAFISCHE OBERFLÄCHEN & PROFESSIONS-MODULE | **02** | **Konstruktor & self** | *22.0 & 22.1* | `__init__`, `self`, Startwerte, erstes UML-Klassendiagramm (`Bankkonto` & `Smartphone`) | | **03** | **Methoden & Verhalten** | *22.0* | Methoden definieren, Rückgabewerte, Interaktion zweier Objekte (`Rennauto` & RPG-Duell) | | **04** | **`__str__` & Darstellung** | *28.0* | Dunder-Methode `__str__`, lesbare Ausgabe von Objekten, Kassenzettel (`Warenkorb`) | -| **04b** | **VS Code Umstieg** | *20.1 & 20.2* | Installation (Windows/Mac/Linux), Plugins (Error Lens, Python), Shortcuts, Projektordner | +| **04b** | **VS Code Umstieg** | *20.1* | Installation (Windows/Mac/Linux), Plugins (Error Lens, Python), Shortcuts, Projektordner | +| **04c** | **Git Versionskontrolle** | *Tooling* | Was ist Git? Spielstand-Analogie, `git add`, `git commit`, `git push`, VS Code Git-Tab | | **05** | **Objekte kombinieren** | *23.0* | Assoziation & Aggregation (1:1 und 1:n), Listen von Objekten filtern (`Spotify Playlist`) | | **06** | **Abschlussprojekt OOP 1** | *Konsolidierung* | Tamagotchi-Konsolenspiel (Lebenszyklus, Hunger, Müdigkeit, Zufallsevents) | | **07** | **Referenzen & Speicher** | *24.0 Referenzen* | RAM-Visualisierung, Mutable vs. Immutable, `is` vs. `==`, Aliasing, `Stammbaum`-Projekt | | **08** | **Operator Overloading** | *28.0 Spezielle Methoden*| `__add__`, `__sub__`, `__eq__`, `__lt__`, `__len__` (2D-Vektoren & Kartenspiel) | -| **09** | **Vererbung & `super()`** | *25.0 Vererbung* | Basisklassen, Kindklassen, Vermeidung von Code-Duplikaten, `super().__init__()` (`Fahrzeuge`) | -| **10** | **Polymorphie & Interfaces**| *25.1 Polymorphie* | Methoden überschreiben, gemeinsames Interface, Geometrie- & Grafik-Engine (`Formen`) | -| **11** | **Exceptions & Fehler** | *26.0 Exceptions* | `try/except/else/finally`, `raise`, eigene Exception-Klassen (`Geldautomat`) | -| **12** | **JSON & CSV Speichern** | *14.0 CSV / Persistenz* | `with open()`, `json.dump`/`json.load`, Spielstände dauerhaft sichern (`Savegame`) | -| **13** | **Tkinter Desktop-GUI** | *27.0 Tkinter* | Fenster, Buttons, Labels, Eingabefelder, Event-Handling in OOP-Klassen | -| **14** | **Parameter & Container** | *29.0 & 30.0 Parameter*| `*args`, `**kwargs`, Dunder `__getitem__`, `__iter__` für eigene Listen-Container | -| **15** | **Master-Abschlussprojekt**| *Meisterstück* | Vollständige Desktop-App mit grafischer Oberfläche, Speichern & Laden | +| **09** | **Eigene Unit Tests & TDD**| *Softwarequalität* | Testsuiten schreiben mit `unittest`, `assertEqual`, `assertTrue`, `assertRaises` | +| **10** | **Vererbung & `super()`** | *25.0 Vererbung* | Basisklassen, Kindklassen, Vermeidung von Code-Duplikaten, `super().__init__()` (`Fahrzeuge`) | +| **11** | **Polymorphie & Interfaces**| *25.1 Polymorphie* | Methoden überschreiben, gemeinsames Interface, Geometrie- & Grafik-Engine (`Formen`) | +| **12** | **Exceptions & Fehler** | *26.0 Exceptions* | `try/except/else/finally`, `raise`, eigene Exception-Klassen (`Geldautomat`) | +| **13** | **JSON & CSV Speichern** | *14.0 CSV / Persistenz* | `with open()`, `json.dump`/`json.load`, Spielstände dauerhaft sichern (`Savegame`) | +| **14** | **Tkinter Desktop-GUI** | *27.0 Tkinter* | Fenster, Buttons, Labels, Eingabefelder, Event-Handling in OOP-Klassen | +| **15** | **Parameter & Container** | *29.0 & 30.0 Parameter*| `*args`, `**kwargs`, Dunder `__getitem__`, `__iter__` für eigene Listen-Container | +| **16** | **Master-Abschlussprojekt**| *Meisterstück* | Vollständige Desktop-App mit grafischer Oberfläche, Speichern & Laden | diff --git a/README.md b/README.md index d528188..5e12399 100644 --- a/README.md +++ b/README.md @@ -8,7 +8,7 @@ Diese Übungsreihe ist didaktisch aufbereitet und **1:1 mit dem offiziellen Lehr ## 🗺️ Der Lernpfad -### 🌱 Phase 1: Grundlagen OOP & Entwicklungsumgebung +### 🌱 Phase 1: Grundlagen OOP & Werkzeuge | Kapitel | Thema | Was du lernst | | :--- | :--- | :--- | | **[00. Fehlersuche & Grundlagen](./00_fehlersuche_und_grundlagen/)** | Warm-up & Debugging | Tracebacks lesen, Einrückungen (`IndentationError`), Typfehler & Detektiv-Aufgabe | @@ -17,20 +17,22 @@ Diese Übungsreihe ist didaktisch aufbereitet und **1:1 mit dem offiziellen Lehr | **[03. Methoden & Verhalten](./03_methoden_und_verhalten/)** | Methoden & Interaktion | Objekte können handeln & miteinander im Duell interagieren | | **[04. Schöne Textausgabe](./04_str_und_darstellung/)** | `__str__` Dunder-Methode | Wie Objekte lesbar mit `print()` ausgegeben werden (Warenkorb & Bon) | | **[04b. Umstieg & Installation VS Code](./04b_umstieg_vscode/)** | **Exkurs: IDE-Wechsel** | **Installation (Win/Mac/Linux), Plugins (Error Lens, Python), Shortcuts & Terminal** | +| **[04c. Git & Versionskontrolle](./04c_git_und_versionskontrolle/)** | **Exkurs: Git-Tooling** | **Spielstände (Commits) sichern, VS Code Git-Tab, Terminal-Befehle & Remote Push** | | **[05. Objekte kombinieren](./05_objekte_kombinieren/)** | Assoziation & Komposition | Listen von Objekten & Spotify-Playlists filtern und berechnen | | **[06. Abschlussprojekt OOP 1](./06_abschlussprojekt_tamagotchi/)** | Mini-Projekt: Tamagotchi | Ein interaktives Konsolenspiel mit allem Gelernten | -### 🧠 Phase 2: Fortgeschrittenes OOP, Speicher & Persistenz +### 🧠 Phase 2: Fortgeschrittenes OOP, Testing & Persistenz | Kapitel | Thema | Was du lernst | | :--- | :--- | :--- | | **[07. Referenzen, Speicher & Stammbäume](./07_referenzen_und_speicher/)** | **Speicher & RAM** | **Referenzen, Aliasing (`b = a`), Mutable vs. Immutable, `is` vs. `==` & Familienstammbaum** | | *08. Operator Overloading* | *Dunder-Methoden* | *`__add__`, `__eq__`, `__lt__` (2D-Vektoren & Kartenspiele)* | -| *09. Vererbung & `super()`* | *Inheritance* | *Basisklassen, Kindklassen & `super().__init__()` (Fahrzeuge & RPG-Helden)* | -| *10. Polymorphie & Interfaces* | *Polymorphism* | *Methoden überschreiben, Geometrie- & Grafik-Engine* | -| *11. Exceptions & Fehler* | *Robustes Coding* | *`try/except/else/finally`, `raise`, eigene Exception-Klassen* | -| *12. JSON & CSV Speichern* | *Persistenz* | *Spielstände dauerhaft mit JSON/CSV auf der Festplatte sichern* | +| *09. Eigene Unit Tests & TDD* | *Softwarequalität* | *Testsuiten schreiben mit `unittest`, `assertEqual`, `assertTrue`, `assertRaises`* | +| *10. Vererbung & `super()`* | *Inheritance* | *Basisklassen, Kindklassen & `super().__init__()` (Fahrzeuge & RPG-Helden)* | +| *11. Polymorphie & Interfaces* | *Polymorphism* | *Methoden überschreiben, Geometrie- & Grafik-Engine* | +| *12. Exceptions & Fehler* | *Robustes Coding* | *`try/except/else/finally`, `raise`, eigene Exception-Klassen* | +| *13. JSON & CSV Speichern* | *Persistenz* | *Spielstände dauerhaft mit JSON/CSV auf der Festplatte sichern* | -*(Den vollständigen didaktischen Masterplan für alle Kapitel bis 15 findest du in [`LEHRPLAN.md`](./LEHRPLAN.md).)* +*(Den vollständigen didaktischen Masterplan für alle Kapitel bis 16 findest du in [`LEHRPLAN.md`](./LEHRPLAN.md).)* --- diff --git a/index.html b/index.html index 57c9fb3..093d0a1 100644 --- a/index.html +++ b/index.html @@ -12,7 +12,7 @@
🐍 Python Nachhilfe & Selbstlern-Kurs

Objektorientierte Programmierung (OOP)

-

Lerne Schritt für Schritt, wie du eigene Klassen baust, Methoden nutzt und professionell mit automatischen Tests arbeitest.

+

Lerne Schritt für Schritt, wie du eigene Klassen baust, Methoden nutzt und professionell mit Git & Unit Tests arbeitest.

@@ -36,9 +36,9 @@ - +
-

🌱 Phase 1: Grundlagen OOP & Entwicklungsumgebung

+

🌱 Phase 1: Grundlagen OOP & Entwickler-Werkzeuge

@@ -101,6 +101,16 @@ + + +
+ Exkurs 04c +
🌿 Git & Versionskontrolle
+
Die Programmier-Zeitmaschine: Spielstände (Commits) sichern, Diffs in VS Code, Terminal-Befehle & Push.
+
+ +
+
@@ -126,7 +136,7 @@
-

🧠 Phase 2: Fortgeschrittenes OOP, Speicher & Persistenz

+

🧠 Phase 2: Fortgeschrittenes OOP, Testing & Persistenz

@@ -142,29 +152,29 @@
- Kapitel 08 • Geplant + Kapitel 08 • In Vorbereitung
➕ Operator Overloading & Dunder
Eigene Klassen rechen- und vergleichbar machen mit __add__, __eq__, __lt__ für 2D-Vektoren & Kartenspiele.
- +
-
+
- Kapitel 09 • Geplant -
🧬 Vererbung & super()
-
Basisklassen, Kindklassen, Code-Wiederverwendung und super().__init__() für Fahrzeugflotten & RPG-Helden.
+ Kapitel 09 • Neu +
🧪 Eigene Unit Tests schreiben (TDD)
+
Schreibe eigene Testsuiten mit unittest, self.assertEqual(), assertRaises() und lerne Test-Driven Development.
- +
- +
- Kapitel 10 - 12 • Geplant -
🛡️ Exceptions, Persistenz & GUI
-
Polymorphie (10), Eigene Fehlerklassen (11), Spielstände dauerhaft mit JSON/CSV sichern (12) und Desktop-Apps mit Tkinter (13).
+ Kapitel 10 - 13 • Geplant +
🧬 Vererbung, Exceptions & JSON
+
Vererbung & super() (10), Polymorphie (11), Eigene Fehlerklassen (12) und Savegames mit JSON/CSV sichern (13).