Wenn du neu in der Programmierung bist oder gerade erst mit Python anfängst, kann es einschüchternd wirken, eine KI wie OpenAI ChatGPT zu integrieren. Keine Sorge – in diesem Leitfaden führen wir dich Schritt für Schritt durch jeden Befehl und Begriff, sodass du problemlos folgen kannst, auch wenn dies dein erstes Projekt ist.

Voraussetzungen

Stelle vorab sicher, dass du Folgendes installiert und eingerichtet hast:

  1. Python 3.7 oder neuer
    • Lade Python von python.org herunter und installiere es.
    • Aktiviere während der Windows-Installation die Option „Add Python to PATH“, damit du python in der Eingabeaufforderung nutzen kannst.
  2. Einen kostenlosen OpenAI API-Schlüssel
    • Registriere dich oder melde dich unter platform.openai.com an.
    • Klicke auf API Keys → Create new secret key.
    • Kopiere den Schlüssel – du wirst ihn im nächsten Schritt benötigen.
  3. Ein Terminal- oder Kommandozeilenfenster
    • Windows: Suche nach „Eingabeaufforderung“ oder „PowerShell“.
    • macOS/Linux: Öffne die integrierte Terminal-App.

Virtuelle Umgebung erstellen und aktivieren

Durch das Isolieren von Abhängigkeiten bleibt dein globaler Python-Setup sauber:

# macOS/Linux
python3 -m venv venv
source venv/bin/activate

# Windows (PowerShell)
python -m venv venv
venv\Scripts\Activate.ps1

Code-Erklärung

  • python3 -m venv venv: Erstellt eine neue virtuelle Umgebung namens venv im Projektordner.
  • source venv/bin/activate (macOS/Linux) bzw. venv\Scripts\Activate.ps1 (Windows): Aktiviert die Umgebung, sodass nachfolgende pip-Installationen dort landen.
  • Dein Prompt zeigt (venv), was signalisiert, dass du im geschützten Umfeld arbeitest.

Installiere dann die benötigten Pakete:

pip install openai python-dotenv

Code-Erklärung

  • pip install openai python-dotenv: Installiert die OpenAI-Bibliothek und python-dotenv zum Laden von Umgebungsvariablen aus einer .env-Datei.

API-Schlüssel sicher speichern

Hard-Coding von Schlüsseln ist riskant. Nutze stattdessen Umgebungsvariablen oder eine .env-Datei:

  1. Erstelle im Projektstamm eine Datei .env mit folgendem Inhalt: OPENAI_API_KEY="sk-…dein_secret_key…"
  2. Lade sie im Python-Skript: from dotenv import load_dotenv import os load_dotenv() openai.api_key = os.getenv("OPENAI_API_KEY")

Code-Erklärung

  • load_dotenv(): Liest die .env-Datei und lädt die Schlüssel in os.environ.
  • os.getenv("OPENAI_API_KEY"): Holt den Wert der Variable OPENAI_API_KEY.
  • openai.api_key = ...: Konfiguriert den OpenAI-Client mit deinem Schlüssel.

Erstes Python-Skript schreiben

Erstelle chat.py und füge ein:

import os
import openai
from dotenv import load_dotenv

load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")

messages = [
    {"role": "system", "content": "Du bist ein freundlicher Coding-Tutor."},
    {"role": "user",   "content": "Wie gebe ich 'Hello, world!' in Python aus?"}
]

response = openai.ChatCompletion.create(
    model="gpt-3.5-turbo",
    messages=messages,
    temperature=0.5,
    max_tokens=150
)

print(response.choices[0].message.content)

Code-Erklärung

  • messages: Definiert den Gesprächsverlauf; "system" steuert das Verhalten des Assistenten, "user" ist deine Eingabe.
  • ChatCompletion.create(...): Sendet die Nachrichten an die API.
  • response.choices[0].message.content: Extrahiert die Antwort des Modells.

Antwortstruktur und Token-Usage prüfen

print(response)  # komplette JSON-Antwort
print("Antwort:", response.choices[0].message.content)
print("Prompt-Tokens:", response.usage.prompt_tokens)
print("Completion-Tokens:", response.usage.completion_tokens)
print("Total Tokens:", response.usage.total_tokens)

Code-Erklärung

  • response.usage.prompt_tokens: Anzahl der genutzten Tokens für die Eingabe.
  • response.usage.completion_tokens: Tokens in der Modell-Antwort.
  • response.usage.total_tokens: Summe beider, relevant für die Abrechnung.

Echtzeit-Streaming aktivieren

for chunk in openai.ChatCompletion.create(
    model="gpt-3.5-turbo",
    messages=messages,
    stream=True
):
    delta = chunk.choices[0].delta
    if delta.content:
        print(delta.content, end="", flush=True)

Code-Erklärung

  • stream=True: Aktiviert den Rückfluss von Teilantworten.
  • delta.content: Enthält neue Textabschnitte, die sofort ausgegeben werden.

Fehlerbehandlung und Retry-Logik

import time
from openai.error import RateLimitError, OpenAIError

def safe_chat(messages):
    for attempt in range(3):
        try:
            return openai.ChatCompletion.create(model="gpt-3.5-turbo", messages=messages)
        except RateLimitError:
            wait = 2 ** attempt
            print(f"Rate limit erreicht. Warte {wait}s...")
            time.sleep(wait)
        except OpenAIError as e:
            print("API-Fehler:", e)
            break
    return None

Code-Erklärung

  • Versucht bis zu dreimal bei RateLimitError mit exponentiellem Backoff (1s, 2s, 4s).
  • Protokolliert andere Fehler und bricht ab.

Einfacher Chatbot in der Konsole

import os, openai, time
from dotenv import load_dotenv
from openai.error import RateLimitError

load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")

def chat_loop():
    history = [{"role": "system", "content": "Du hilfst Anfängern, Python zu lernen."}]
    print("Willkommen bei ChatGPT! (tippe 'exit' zum Beenden)\n")

    while True:
        user_input = input("You: ")
        if user_input.lower() in ("exit", "quit"):
            print("Auf Wiedersehen!")
            break

        history.append({"role": "user", "content": user_input})
        for attempt in range(3):
            try:
                resp = openai.ChatCompletion.create(model="gpt-3.5-turbo", messages=history)
                break
            except RateLimitError:
                time.sleep(2 ** attempt)
        else:
            print("Antwort fehlgeschlagen. Bitte versuche es später erneut.")
            continue

        reply = resp.choices[0].message.content
        print("ChatGPT:", reply)
        history.append({"role": "assistant", "content": reply})

if __name__ == "__main__":
    chat_loop()

Code-Erklärung

  • history: Speichert den Gesprächsverlauf, damit der Kontext erhalten bleibt.
  • Wiederholt Eingabe/Ausgabe bis zum Befehl zum Beenden.

Aufforderungen anpassen

Probiere verschiedene Systemnachrichten und Parameter aus, z. B.:

{"role": "system", "content": "Du bist ein erfahrener Python-Tutor und erklärst in einfachen Worten."}

Weiterführende Ressourcen

  • Offizielle Dokumentation: https://platform.openai.com/docs/guides/chat
  • Function Calling: Strukturierte JSON-Ausgaben
  • Jupyter Notebooks: Interaktive Prototypen
  • Community-Beispiele: GitHub-Suche nach „openai python examples“