Claude Code + Python: Automatisierung auf einem neuen Level

Python ist die Sprache der Datenwissenschaft, Automatisierung und KI. Claude Code ist der Assistent der Python-Skripte schreibt, debuggt und orchestriert — ohne dass man selbst jede Zeile tippen muss. Zusammen entstehen Workflows die früher Stunden dauerten und jetzt Minuten brauchen.

Warum Claude Code + Python so gut zusammenpassen

Python hat eine einzigartige Stellung in der Entwicklerwelt: Es ist gleichzeitig Scripting-Sprache für einfache Automatisierungen, Daten-Analyse-Tool mit Pandas und NumPy, Web-Scraping-Plattform mit Playwright und BeautifulSoup, und Backend-Sprache für APIs und Microservices. Diese Breite macht Python zum perfekten Partner für einen KI-Coding-Assistenten — denn Claude Code Python Automatisierung bedeutet: Claude versteht nicht nur Syntax, sondern auch Ökosystem, Patterns und Best Practices.

Was macht die Kombination besonders stark?

• Python-Lesbarkeit: Claudes Kontext reicht aus, um ganze Python-Dateien zu verstehen und zu modifizieren — nicht nur einzelne Funktionen
• Reiches Ökosystem: Claude kennt numpy, pandas, requests, fastapi, playwright, SQLAlchemy und Hunderte weiterer Libraries
• Iterative Analyse: Claude kann Python-Outputs interpretieren und darauf aufbauend den nächsten Schritt planen
• Autonomes Ausführen: Claude Code kann Python-Skripte direkt starten, die Ausgabe lesen und reagieren — kein manuelles Copy-Paste

5 konkrete Anwendungsfälle für Python Automatisierung mit Claude Code

1. Daten-Analyse automatisieren: CSV/JSON einlesen, analysieren, Bericht generieren

Der klassische Python-Datenanalyse-Workflow — Datei einlesen, bereinigen, analysieren, visualisieren — ist mit Claude Code vollständig automatisierbar. Man wirft Claude Code eine CSV-Datei und einen Prompt hin; heraus kommt ein vollständiger Analysebericht.

Claude Code wird daraufhin: die CSV-Struktur inspizieren, fehlende Werte identifizieren, Pandas-Code für die Analyse schreiben, das Skript ausführen, die Ausgabe lesen und in einem lesbaren HTML-Bericht zusammenfassen. Der gesamte Prozess läuft ohne manuellen Eingriff.

Besonders nützlich: Claude erkennt statistische Ausreißer und erklärt sie sprachlich — nicht nur als Zahl, sondern im Kontext der Daten. Das ist der Unterschied zu einem reinen Python-Skript.

2. Web Scraping mit KI-Verarbeitung: Playwright scrapt, Claude interpretiert

Playwright (oder BeautifulSoup für einfachere Fälle) sammelt Rohdaten von Websites. Claude Code übernimmt die Interpretation: Welche Informationen sind relevant? Welche Struktur haben die Daten? Was sind die Key Insights?

# Claude Code generiert diesen Scraper automatisch:
from playwright.sync_api import sync_playwright
import json

def scrape_pricing(url: str) -> dict:
    with sync_playwright() as p:
        browser = p.chromium.launch()
        page = browser.new_page()
        page.goto(url, wait_until="networkidle")

        # Preise und Features extrahieren
        plans = page.query_selector_all(".pricing-plan")
        data = []
        for plan in plans:
            data.append({
                "name": plan.query_selector(".plan-name").inner_text(),
                "price": plan.query_selector(".plan-price").inner_text(),
                "features": [f.inner_text() for f in
                             plan.query_selector_all(".feature-item")]
            })
        browser.close()
        return {"url": url, "plans": data}
pythonpython

Claude Code schreibt nicht nur den Scraper — es führt ihn aus, liest die extrahierten Daten und erstellt direkt die Analyse. Der Wechsel zwischen Scraping und Interpretation passiert im selben Workflow.

3. Automatische Code-Generierung: Claude schreibt Python-Skripte nach Beschreibung

Das offensichtlichste Anwendungsfeld — aber oft unterschätzt in seiner Tiefe. Es geht nicht nur darum, eine einzelne Funktion zu generieren. Claude Code kann vollständige Python-Module mit Tests, Dokumentation und Fehlerbehandlung erzeugen.

Claude Code liefert dann: den vollständigen Modul-Code mit korrekten Imports, eine requirements.txt mit den benötigten Libraries, pytest-Tests für alle Kernfunktionen und eine kurze README. Anschließend führt Claude pytest aus und behebt ggf. gefundene Fehler selbst.

4. Data Pipeline: CSV → Clean → Transform → Visualize — alles per Prompt

Daten-Pipelines sind typischerweise mehrstufige Prozesse die manuelle Koordination benötigen. Mit Claude Code lässt sich eine vollständige Pipeline in einem einzigen Prompt beschreiben:

# Pipeline-Struktur die Claude Code generiert:
import pandas as pd
import matplotlib.pyplot as plt
from pathlib import Path
from dataclasses import dataclass
from typing import Optional

@dataclass
class PipelineConfig:
    input_path: Path
    output_dir: Path
    date_column: str = "order_date"
    revenue_column: str = "amount"
    customer_column: str = "customer_id"

class DataPipeline:
    def __init__(self, config: PipelineConfig):
        self.config = config
        self.df: Optional[pd.DataFrame] = None

    def clean(self) -> "DataPipeline":
        # Duplikate entfernen
        self.df = self.df.drop_duplicates()
        # Datumsformat normalisieren
        self.df[self.config.date_column] = pd.to_datetime(
            self.df[self.config.date_column], infer_datetime_format=True
        )
        return self  # Method chaining

    def run(self) -> dict:
        return (
            self.load()
                .clean()
                .transform()
                .visualize()
                .export()
        )
python

project/
  src/
    __init__.py
    core.py         # Haupt-Logik
    models.py       # Datenstrukturen (Pydantic/dataclasses)
    utils.py        # Helfer-Funktionen
  tests/
    test_core.py
    test_models.py
  scripts/
    analyze.py      # Einmalige Analyse-Skripte
    pipeline.py     # Pipeline-Entry-Point
  data/
    raw/            # Input-Daten
    processed/      # Output-Daten
  requirements.txt
  .python-version   # pyenv-Version
  CLAUDE.md         # Kontext für Claude Code
text

# venv erstellen und aktivieren
python -m venv .venv
source .venv/bin/activate  # Linux/Mac
# .venv\Scripts\activate  # Windows

# Claude Code findet automatisch das aktive venv
# und installiert Libraries darin
pip install -r requirements.txt
bash

# CLAUDE.md
## Python Setup
- Python 3.12, venv unter .venv/
- Hauptdependencies: pandas 2.x, pydantic v2, httpx
- Code-Style: Black + Ruff, Type Hints Pflicht
- Tests: pytest mit fixtures in conftest.py

## Wichtige Dateien
- src/models.py: Alle Pydantic-Modelle hier
- data/raw/: Nie modifizieren, immer nach data/processed/ schreiben
- NIEMALS relative Imports verwenden
markdown

import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
from typing import NamedTuple

class AnalysisResult(NamedTuple):
    top_customers: pd.DataFrame
    monthly_revenue: pd.Series
    yoy_growth: float
    anomalies: pd.DataFrame

def analyze_sales(csv_path: str) -> AnalysisResult:
    """
    Vollständige Verkaufsanalyse aus CSV-Datei.

    Args:
        csv_path: Pfad zur CSV-Datei mit Spalten:
                  date, customer_id, amount, product_id

    Returns:
        AnalysisResult mit Top-Kunden, Monatsumsatz,
        YoY-Wachstum und Anomalien
    """
    df = pd.read_csv(csv_path, parse_dates=["date"])

    # Bereinigung: negative Beträge entfernen, Duplikate
    df = df[df["amount"] > 0].drop_duplicates()

    # Top-Kunden nach Gesamtumsatz
    top_customers = (
        df.groupby("customer_id")["amount"]
        .agg(["sum", "count", "mean"])
        .rename(columns={"sum": "total", "count": "orders", "mean": "avg_order"})
        .sort_values("total", ascending=False)
        .head(10)
    )

    # Monatsumsatz mit Saisonalitäts-Index
    monthly = df.set_index("date")["amount"].resample("ME").sum()

    # YoY-Wachstum (letztes vs. vorletztes Jahr)
    years = df["date"].dt.year.unique()
    yoy = 0.0
    if len(years) >= 2:
        r_curr = df[df["date"].dt.year == years[-1]]["amount"].sum()
        r_prev = df[df["date"].dt.year == years[-2]]["amount"].sum()
        yoy = (r_curr - r_prev) / r_prev * 100

    # Anomalien: Beträge außerhalb 3 Standardabweichungen
    mean, std = df["amount"].mean(), df["amount"].std()
    anomalies = df[(abs(df["amount"] - mean) > 3 * std)]

    return AnalysisResult(top_customers, monthly, yoy, anomalies)

if __name__ == "__main__":
    result = analyze_sales("data/raw/sales_2025.csv")
    print(f"YoY-Wachstum: {result.yoy_growth:.1f}%")
    print(f"Anomalien gefunden: {len(result.anomalies)}")
    result.top_customers.to_csv("data/processed/top_customers.csv")
python

# Claude Code Debug-Strategie:
# 1. Isoliere den fehlerhaften Bereich
# 2. Füge strategische print()-Statements ein
# 3. Führe aus und lies Output
# 4. Narrowe auf die genaue Zeile ein

# Beispiel für Debug-Instruktion an Claude:
"""
Füge print()-Statements nach jedem Pipeline-Schritt ein:
print(f"Nach clean(): {df.shape}, dtypes: {df.dtypes.to_dict()}")
Dann ausführen und mir die Ausgabe zeigen.
"""
python