Lernziele dieses Kapitels
- Du schreibst effektive Prompts für Python-Code mit KI
- Du reviewest KI-generierten Code kritisch und verbesserst ihn
- Du nutzt KI-gestütztes Debugging für schnelle Fehlerbehebung
- Du erweiterst PyBuddy um einen KI-Prompt-Generator
Effektives Prompting
Gute Prompts sind wie gute Aufträge: spezifisch, strukturiert und kontextreich. Statt "Schreib mir ein Spiel" sagst du: "Erstelle ein Zahlenratespiel in Python mit input(), Zufallszahlen und einem Versuchszähler. Kommentiere den Code."
Die beste Struktur für Prompts:
Kontext: Wer bist du, was kannst du?
Anforderung: Was soll genau gemacht werden?
Format: Wie soll die Antwort aussehen?
Einschränkungen: Was soll vermieden werden?
# Schlechter vs. guter Prompt (als String)
schlecht = "Schreib mir ein Programm"
gut = '''Ich bin 16 Jahre alt und lerne Python.
Erstelle ein Zahlenratespiel mit folgenden Anforderungen:
- Nutze random.randint() für eine Zahl 1-100
- Der Spieler gibt Tipps ein
- Nach jedem Tipp kommt "zu hoch" oder "zu niedrig"
- Zähle die Versuche
- Gib am Ende die Anzahl der Versuche aus
- Kommentiere den Code für Anfänger
Format: Nur Python-Code, keine Erklärungen dazwischen.'''
print("Länge schlecht:", len(schlecht))
print("Länge gut:", len(gut))
Code-Review mit KI
KI ist ein exzellenter Code-Reviewer — wenn du die richtigen Fragen stellst. Lade die KI ein, deinen Code auf Bugs, Sicherheitslücken und Best Practices zu prüfen.
Typische Review-Fragen:
- "Reviewe diese Funktion auf Bugs und Edge Cases."
- "Prüfe auf Python-Best Practices (PEP 8)."
- "Gibt es Sicherheitsprobleme?"
- "Wie kann ich den Code effizienter machen?"
# Beispiel-Code für ein KI-Review
def berechne_rabatt(preis, prozent):
return preis - (preis * prozent / 100)
# KI-Prompt:
review_prompt = '''
Reviewe die Funktion berechne_rabatt().
- Prüfe auf Bugs (z.B. negative Preise, Prozent > 100)
- Schlage Input-Validierung vor
- Formatiere nach PEP 8
- Gib den verbesserten Code als Komplettlösung aus
'''
print(review_prompt)
KI-gestütztes Debugging
Wenn dein Code nicht funktioniert, kopiere Fehlermeldung + Code in die KI. Die beste Frage ist konkret: "Ich bekomme [FEHLER]. Hier ist mein Code. Erkläre mir warum und wie ich ihn behebe."
Pro Tipp
Gib immer den vollständigen Fehlertext und den relevanten Code-Ausschnitt. Ohne Kontext ratet die KI nur.
# Beispiel für KI-Debugging-Request
fehler_code = '''
noten = [2, 3, 1, 4]
durchschnitt = sum(noten) / len(noten)
print(f"Durchschnitt: {durchschnitt:.2f}")
'''
fehlermeldung = "TypeError: unsupported operand type(s) for /: 'int' and 'list'"
debug_prompt = f'''
Ich bekomme diesen Fehler:
{fehlermeldung}
Hier ist mein Code:
{fehler_code}
Erkläre mir:
1. Warum tritt der Fehler auf?
2. Wie behebe ich ihn?
3. Zeige mir den korrigierten Code.
'''
print(debug_prompt)
KI-Refactoring in der Praxis
Refactoring bedeutet: Code verbessern, ohne sein Verhalten zu ändern. Die KI kann dir helfen, unleserlichen Code in saubere, pythonic Lösungen zu verwandeln.
# Vorher: Unleserlicher Code
def note_von_prozent(p):
if p > 89:
return 1
if p > 76:
return 2
if p > 63:
return 3
if p > 50:
return 4
return 5
# Nach KI-Refactoring (besser):
def note_von_prozent(p):
"""Gibt die Schulnote (1-5) basierend auf Prozent zurück."""
if not (0 <= p <= 100):
raise ValueError("Prozent muss zwischen 0 und 100 liegen")
grenzen = [(89, 1), (76, 2), (63, 3), (50, 4)]
for grenze, note in grenzen:
if p >= grenze:
return note
return 5
# Test
for p in [95, 82, 70, 55, 40]:
print(f"{p}% = Note {note_von_prozent(p)}")
Du kennst bereits JavaScript aus dem JS-Quest. Hier ist der direkte Vergleich:
def note_von_prozent(p):
if p >= 89: return 1
if p >= 76: return 2
...
function noteVonProzent(p) {
if (p >= 89) return 1;
if (p >= 76) return 2;
...
}
PyBuddy meets KI
PyBuddy bekommt eine Funktion, die strukturierte KI-Prompts generiert. Der Nutzer gibt ein Thema ein, PyBuddy erstellt einen perfekten Prompt dafür.
# pybuddy/main.py
def ki_prompt(thema, zielgruppe="Anfänger", sprache="de"):
"""Generiert einen strukturierten KI-Prompt."""
prompt = f"""
Erkläre mir das Thema '{thema}' in Python.
Zielgruppe: {zielgruppe} (15-19 Jahre)
Sprache: {sprache}
Format: Code-Beispiel + Erklärung
Anforderungen:
- Nutze ein praktisches Beispiel
- Kommentiere den Code für Anfänger
- Zeige typische Fehler und wie man sie vermeidet
- Maximal 30 Zeilen Code
"""
return prompt.strip()
# Nutzung
thema = input(" Welches Thema willst du lernen? ")
prompt = ki_prompt(thema)
print("\n Dein KI-Prompt:")
print("=" * 40)
print(prompt)
print("=" * 40)
Warm-Up: KI-Refactor Challenge
Nimm deine Noten-Rechner-Funktion aus Kapitel 4. Schreibe einen Prompt, der die KI bittet, sie mit Input-Validierung, Docstring und Typ-Hinweisen zu verbessern.
Hinweis: # Alter Code (aus Kapitel 4)
def note(p):
if p >= 89: return 1
elif p >= 76: return 2
elif p >= 63: return 3
elif p >= 50: return 4
else: return 5
# KI-Prompt:
prompt = '''Refactore diese Funktion mit:
1. Input-Validierung (0-100)
2. Docstring
3. Typ-Hinweise
4. PEP 8 Konformität
5. Test-Beispiele
Code:
def note(p):
if p >= 89: return 1
...'''
print(prompt)
# Alter Code (aus Kapitel 4)
def note(p):
if p >= 89: return 1
elif p >= 76: return 2
elif p >= 63: return 3
elif p >= 50: return 4
else: return 5
# KI-Prompt:
prompt = '''Refactore diese Funktion mit:
1. Input-Validierung (0-100)
2. Docstring
3. Typ-Hinweise
4. PEP 8 Konformität
5. Test-Beispiele
Code:
def note(p):
if p >= 89: return 1
...'''
print(prompt)
Challenge: Debugging-Übung
Schreibe absichtlich fehlerhaften Code (z.B. IndexError, TypeError). Dann schreibe einen KI-Prompt, der Fehlermeldung und Code enthält und um Erklärung bittet.
Hinweis: # Absichtlich fehlerhafter Code
code = "\nspieler = ['Anna', 'Ben']\nprint(spieler[5]) # IndexError!\n"
fehler = 'IndexError: list index out of range'
prompt = f'''\nIch bekomme diesen Fehler: {fehler}\n\nMein Code:{code}\n\nErkläre mir:\n1. Warum passiert das?\n2. Wie finde ich die Zeile mit dem Fehler?\n3. Wie behebe ich ihn sicher?\n'''
print(prompt)
# Absichtlich fehlerhafter Code
code = "\nspieler = ['Anna', 'Ben']\nprint(spieler[5]) # IndexError!\n"
fehler = 'IndexError: list index out of range'
prompt = f'''\nIch bekomme diesen Fehler: {fehler}\n\nMein Code:{code}\n\nErkläre mir:\n1. Warum passiert das?\n2. Wie finde ich die Zeile mit dem Fehler?\n3. Wie behebe ich ihn sicher?\n'''
print(prompt)
PyBuddy-Checkpoint: KI-Integration
PyBuddy bekommt eine Funktion, die den Nutzer nach einem Thema fragt und einen strukturierten Prompt für KI-Tools generiert.
Hinweis: # pybuddy/main.py
def ki_generator():
print(" PyBuddy KI-Assistent")
thema = input("Thema: ")
level = input("Level (Anfänger/Fortgeschritten/Pro): ") or "Anfänger"
prompt = f"""\nErkläre mir '{thema}' in Python.\nMein Level: {level}\nFormat: Kurzes Code-Beispiel + Erklärung\nAnforderungen:\n- Praxisnah und verständlich\n- Maximal 20 Zeilen Code\n- Tipps für häufige Fehler\n"""
print("\n Kopiere diesen Prompt in deine KI:")
print("-" * 40)
print(prompt)
print("-" * 40)
ki_generator()
# pybuddy/main.py
def ki_generator():
print(" PyBuddy KI-Assistent")
thema = input("Thema: ")
level = input("Level (Anfänger/Fortgeschritten/Pro): ") or "Anfänger"
prompt = f"""\nErkläre mir '{thema}' in Python.\nMein Level: {level}\nFormat: Kurzes Code-Beispiel + Erklärung\nAnforderungen:\n- Praxisnah und verständlich\n- Maximal 20 Zeilen Code\n- Tipps für häufige Fehler\n"""
print("\n Kopiere diesen Prompt in deine KI:")
print("-" * 40)
print(prompt)
print("-" * 40)
ki_generator()
In Portal 2 programmierst du mit visuellen Blöcken — die KI GLaDOS kommentiert deinen Code. KI-Assistenten sind längst Realität: GitHub Copilot, ChatGPT, Claude — sie alle helfen Entwicklern, schneller besseren Code zu schreiben. Du lernst gerade, diese Tools professionell einzusetzen!
Zusammenfassung
- Gute Prompts = Kontext + Anforderung + Format + Einschränkungen
- KI als Code-Reviewer: Bugs, Sicherheit, Best Practices prüfen
- Debugging: Fehlermeldung + Code → KI für schnelle Hilfe
- Refactoring mit KI: Unleserlichen Code in pythonic Code verwandeln
- PyBuddy generiert jetzt strukturierte KI-Prompts